Connic

See every step
your agent took

Every LLM call, every tool invocation, every MCP step. Latency, token cost, and failure mode for each one. Built around the questions you have when something breaks.

Start Building FreeRead the guide
Read the observability docs

Run details

#a1b2c3d4
completed
2.34s1,234 tokens$0.018Dec 5 · 14:34:12
  1. Runinvoice-processor2,341msok
  2. LLMgemini-2.5-pro · 1,203 tokens1,892msok
  3. Tooldocuments.parse234msok
  4. MCPlinear.create_issue156msok
  5. Tooldatabase.store_invoice59msok
Inside a run

Every step. Every token. Every dollar.

The trace tree shows what your agent did, why, and what it cost. Click any row to inspect it.

Run details

#a1b2c3d4
completed
2.34s1,234 tokens$0.018Apr 12 · 14:34:12
  1. Runinvoice-processor2,341msok
  2. LLMgemini-2.5-pro · 1,203 tokens1,892msok
  3. Tooldocuments.parse234msok
  4. MCPlinear.create_issue656msok
  5. Tooldatabase.store_invoice59msok
LLM · gemini-2.5-pro · 1,203 tokens
ok
input
system_prompt + invoice text + tool schemas
output
tool_call: documents.parse(s3://invoices/...)
followed by tool_call: database.store_invoice(...)

First LLM hop. Token cost dominates the run.

Beyond a single trace

See the shape of production

One trace tells you what happened once. Aggregates show the patterns: drift, regressions, runaway cost.

Success rate

98.5% · selected range

Avg cost per run

$0.018 · across all runs

Agent runs

completed vs. failed

Usage by model

claude / gemini tokens

Built for the questions you actually ask

Debugging flows, not dashboards

A dashboard answers questions you've already asked. Connic observability is built around the questions you have when something breaks.

Isolate the failing slice

Tag runs from middleware with stable keys, then filter the Logs tab by status, deployment, date, or context. The bad slice surfaces in seconds.

Logs search: customer_id=abc123
Catch runaway-cost runs

Anomaly detection compares each run against the agent's 30-day rolling cost average and pings you when one breaks out. Spend limits pause the agent if a daily or monthly threshold is crossed.

Anomaly: run cost > 3× rolling avg
Compare a bad run to a good one

Open one failing run and one healthy run side by side. Walk down both traces. The first span where they diverge is almost always the real cause.

First-divergence: LLM, Tool, or MCP span

What you'd otherwise stitch together

Connic observability vs. building it on top of a generic APM

What you'd otherwise stitch together
FeatureConnicLangSmithHeliconeDIY OTel
Per-run OpenTelemetry trace treeIncludedIncludedPartialPartial
Cost per run / per agentIncludedIncludedIncludedNot included
Token breakdown (input / output / thinking / cached)IncludedPartialPartialNot included
Captured logs from tools & middlewareIncludedPartialNot includedPartial
Custom dashboards in-productIncludedPartialPartialPartial
Spend alerts & hard limitsIncludedNot includedPartialNot included
Cost anomaly detectionIncludedNot includedNot includedNot included
Re-run any execution from the dashboardIncludedPartialNot includedNot included
Wired to A/B testingIncludedNot includedNot includedNot included
Wired to judgesIncludedPartialNot includedNot included

Keep exploring

Judges

Score every run. Catch drift early.

A/B testing

Compare variants in production.

Approvals

Human-in-the-loop on sensitive calls.

Dev server

Hot-reload local agent runtime.

Testing

Assertions and judges, in CI.

Connectors

Wire agents to your real systems.

Frequently Asked Questions

Connic captures OpenTelemetry spans for each step of a run: LLM calls, Tool invocations, MCP tool calls, Middleware before/after hooks, Sequential agent orchestration, and the top-level Run itself. Each span shows status, duration, inputs, outputs, and metadata. LLM spans also include the model's reasoning whenever the provider returns it (controlled via reasoning_effort on the agent).

Every run records four token categories: input, output, thinking, and cached input. Connic estimates cost using your project's per-model pricing rules, with volume tiering and reduced rates for cached tokens. Totals show up in the runs table, the run detail header, the agent detail page, and observability dashboards.

On the Token Usage page you can set spend alerts (notification only) and limits (hard stop that pauses runs). Both can be scoped globally, per environment, or per agent, and run on a daily or monthly period. Anomaly detection flags single runs that cost more than a configurable multiple of the agent's 30-day rolling average.

Yes. When one agent triggers another, the child run's header shows a 'Triggered by' link back to the parent. You can navigate the full chain from there.

The project Logs tab supports key=value search against the run context dictionary. Attach stable keys (customer_id, request_type, workflow_version) from middleware, then filter Logs to the slice you care about.

Yes. From any run detail view, hit Run Again to re-trigger the same agent with the same input. Queued or running runs also have a Cancel button.

Yes. Middleware after() hooks receive a context dict with run_id, agent_name, duration_ms, and token_usage when the agent finishes. POST that to wherever you want. Anything you print, or emit via Python's logging module from tools, middleware, hooks, and guardrails, is also captured per run and surfaced in the Logs tab.