Ciphyrs — observability for AI agents

See every agent, tool call and model call your application makes, as one connected graph. Built on OpenTelemetry, so the spans are standard OTLP and sit beside whatever tracing you already have — and your model calls stay yours, made directly against your provider.

Install

pip install ciphyrs

One command. OpenTelemetry and httpx come with it. Python 3.9 through 3.14, including the free-threaded 3.14 build (PEP 703).

No framework-specific install, and none exists. @agent and @tool wrap plain functions, so they work with any agent framework, or none.

Monitor your agents

import ciphyrs

ciphyrs.init(api_key="cyp_live_...", project="customer-support")

@ciphyrs.tool
def issue_refund(order: str, amount: float) -> dict:
    return payments.refund(order, amount)   # traced, and checked against policy

@ciphyrs.agent("BillingAgent", role="worker")
def billing(question: str) -> str:
    answer = my_model.generate(question)      # your model call, unchanged
    issue_refund(order="A-1041", amount=12.0)
    return answer

@ciphyrs.agent("RouterAgent", role="router")
def router(message: str) -> str:
    return billing(message)      # called INSIDE router -> a RouterAgent→BillingAgent edge

with ciphyrs.session("conv-7f3a"):            # ties one conversation together
    router("I was charged twice for order A-1041")

ciphyrs.shutdown()                            # flush; short-lived scripts only

That is the whole integration. Nesting is the topology: because billing was called inside router, the dashboard draws the edge. Both agents appear in the fleet at start-up — decorators register themselves, before any traffic.

Async is automatic — declare the function async def and the decorators install async wrappers. Every platform call they make runs off your event loop.

See the inputs and outputs

On by default. Pass capture_io=False to an individual @agent or @tool whose arguments must not be recorded; its spans still carry timing, nesting and errors.

Agents in separate processes

Already on. Outgoing HTTP requests carry the trace context, so an agent that calls another service shows up as one connected graph rather than two disconnected fleets. init(propagate=False) turns it off.

Model and framework internals

Ciphyrs is not in the path of your model call and does not want to be. For spans inside a framework or provider — retriever calls, per-node detail — add that framework's own OpenTelemetry instrumentation (OpenInference or OpenLLMetry). Its spans travel through the exporter init() already installed and nest inside your agent spans.

Is it actually on?

state = ciphyrs.selfcheck()
if state["problems"]:
    log.error("Ciphyrs is not live in this process: %s", state["problems"])

Reports what is genuinely running and names each problem in words. Makes no network call, so it is safe in a readiness probe.

Beyond tracing

The platform also enforces policy on agent messages, masks PII, and can quarantine a misbehaving agent from the dashboard. Tool checks, message checks and PII masking are all on by default once init() has an API key, which means text leaves your process to be evaluated. The documentation says what each one sends and how to turn it off (enforce=, guard_input=, guard_output=, pii=).

• Documentation
• Website
• Dashboard