Agent analytics, risk and insurance

Understand, score and insure your AI agents

traces.insure turns the traces your agents already emit into behavior and product analytics, verifies the controls your agent platform enforces, and turns a verified track record into coverage that grows as each agent proves itself.

Get started Explore analytics

OpenTelemetry in TypeScript and Python SDKs platform-reported controls runs on Cloudflare's global network

user"I was charged for an order that never arrived. Can I get my $420 back?"

invoke_agentsupport-agent
chatplan
execute_toolorders.lookup
chatdecide
approvalplatform policyapproved
execute_toolstripe.refunds.createapproved
chatreply

modeltoolapproval

Controlapproved

rule: refund.amount_over_threshold; 420.00 > 200.00 auto-approve limit
reported by: platform:fastport
approval: approved

Session facts

use_case refund request
outcome resolved
activity refund 420 USD
friction none

Recorded to the agent's evidence chain with the platform-reported control outcome.

Works with what your agents already emit

OpenTelemetryOTLP/HTTP
Vercel AI SDK
OpenAI Agents SDK
LangGraph
Pydantic AI
Mastra
Langfusedual export
TypeScript SDKfirst-party
Python SDKfirst-party

Each one runs through our conformance suite: real agents send traces end to end, and we check that tool calls, token usage and errors arrive intact. GenAI semantic conventions, OpenInference and OpenLLMetry spans are normalized on ingest.

Agent analytics

Know what your agents do, and whether users got what they came for

Every session is enriched once into structured facts: intent, use case, outcome, path, friction and value. Behavior analytics and product analytics are views over the same facts, so they work from the first trace, long before any policy.

01Agent behavior analytics

What your agents actually do

Tool calls, loops, failures, cost and latency for every agent and version, plus signals you define in a sentence and test against history before they go live.

Tool-call patterns
Which tools each agent calls, in what order and how often they fail. Every action lands in the Activity ledger in its own units.
Loops and retries
Repeated tool calls, retry storms, runs that never finish and cost runaways, each linked to its sessions.
Failure and escalation
Failure, escalation and abandonment rates per agent, use case and version.
Cost, latency and tokens
Per agent and per version, down to cost per successful session.
Version over version
Success, frustration, cost per success, turns and signals for version A against version B, with a significance flag.
Baselines and drift
Each agent's normal behavior is profiled, so what changes after a release or a model swap stands out.
Signals in plain language
Describe a pattern in a sentence. It runs as rules, embeddings, a decision model or a rubric, backtested on stored sessions and run in shadow before it goes live.
From signal to issue
Nightly discovery proposes signals from failing sessions, reviews calibrate thresholds, and an active signal can open an issue with its evidence.

Version comparisonsupport-agent · v41 vs v42 · last 14 daysexample data

v41 v42

Example metrics for agent version 41 compared with version 42
Metric	v41 and v42	Change
Success rate	v41 71% v42 78%	+7 ptsbetter
Escalation rate	v41 12% v42 9%	−3 ptsbetter
Tool errors / 100 sessions	v41 6.1 v42 3.4	−44%better
Repeated tool calls / 100	v41 2.3 v42 0.8	−65%better
Cost per success	v41 $0.21 v42 $0.17	−19%better
Median latency	v41 4.2 s v42 4.6 s	+10%worse

Signalwritten in plain language · method: decisionexample data

“Agent keeps going after the user asks for a human”

proposed
backtesting
shadow
active

backtest: 30 days
est. precision: 0.86
reviewed hits: 24

Sessions with a hit, per day

Hits link to their sessions; an active signal can open an issue with that evidence.

02Product analytics

What users wanted, and whether they got it

Use cases, outcomes, funnels and pain points for the product and CX owners of an agent, judged by your own business events, not just by what the agent said.

Ask: Which use cases got worse after the last release?

SELECT use_case_id, agent_version,
  COUNT(DISTINCT session_id) AS sessions,
  AVG(CASE WHEN outcome = 'resolved'
      THEN 1 ELSE 0 END) AS success
FROM session_facts
WHERE day >= '2026-10-01'
GROUP BY use_case_id, agent_version
LIMIT 100

SELECT only, allow-listed tables and columns, tenant filter added server-side, row limit enforced.

Content is analyzed only after PII redaction. In metadata-only mode you still get outcomes from events, funnels from events and tool calls, paths from tool sequences, and cost.

Use cases, discovered
Clustered from real conversations and named for you; confirm, rename or merge. Unmet demand gets its own list.
Outcomes you can trust
Inferred per session, or ground truth from your own events with track() and outcome(). Every outcome shows its source.
The verification gap
Sessions the agent marked resolved that a later business event contradicts: a reopened ticket, a refund that never settled.
Business-event connectors
Stripe, Zendesk and signed webhooks join payments and tickets to sessions. Early access.
Funnels in plain language
Steps from events, tool calls, outcomes, use cases or a sentence. New funnels backfill over history, with ranked reasons people drop.
Paths and pain points
Golden and failing conversation paths, and pain points ranked by impact with representative user quotes and a suggested fix.
End users and segments
identify() attaches traits such as plan or region to slice any view by, and feedback attaches to the trace it's about.
Insights and Ask
A feed of what changed each week and with each release, and plain-language questions answered by one validated query.

Use casesdiscovered from conversations · support-agentexample data

Example use cases with their share of sessions and outcome mix
Use case	Share	Outcomes
Order status	31%	86% resolved, 8% escalated, 6% failed or abandoned
Returns › Damaged item	18%	62% resolved, 21% escalated, 17% failed or abandoned
Refund request	14%	70% resolved, 18% escalated, 12% failed or abandoned
Change delivery address	9%	49% resolved, 14% escalated, 37% failed or abandoned
Billing dispute	6%	44% resolved, 41% escalated, 15% failed or abandoned

resolvedescalatedfailed or abandoned

unmet demand
Change the shipping address after dispatch

Funneldamaged item → exchange · steps in plain languageexample data

Reported a damaged itemuse_case100%
Photo verifiedtool_call82%−18%
Accepted an exchangesemantic54%−34%
exchange_order_createdevent47%−13%

why people drop at step 3
Wanted a refund, not an exchange

verification gap
6.2% marked resolved, contradicted later

How it works

The loop is the product

Each pass makes the agent safer, the coverage larger and the record stronger. The first five steps are useful on their own; the sixth is what nobody else can give you.

step 1 / 6

Observe

Every session, span and tool call, from any agent.

OpenTelemetry over OTLP/HTTP, JSON or protobuf, from any SDK or Collector
Sessions, traces, tool calls, token usage, cost and latency per agent and version
An Activity ledger of what each agent did, in its own units: refunds, rows, pods, messages
Sequence numbers and heartbeats, so gaps in telemetry are visible

See agent behavior analytics

span tree

invoke_agent support-agent
├─ chat
├─ execute_tool orders.lookup
└─ execute_tool stripe.refunds.create  approved

Controls

Your agent platform enforces. We verify, score and insure.

The platform that runs your agent's tools, Fastport or any other agent platform, enforces its own policies and approvals. It reports each outcome on the tool span: allowed, approved or blocked. traces.insure checks who reported it, measures where controls are missing and turns the record into coverage.

Refund 89 USD to a verified customerpayments.refundRefund 420 USD to a verified customerpayments.refundRefund 60 USD to an unverified customerpayments.refund

An agent can describe its own controls too. Those spans are recorded, but only a platform's report counts.

platform policyapproved

Over the platform's auto-approve limit. A person approves it on the platform, then the refund runs.

Reported by

platform:fastportStamped by ingest from the platform's API key, never taken from the span.

Recorded

Counts toward control adoption, with the approver on the evidence chain.

evidence chain · control adoption

Tool span sent by the platform

{
  "name": "execute_tool stripe.refunds.create",
  "kind": "tool",
  "attributes": {
    "gen_ai.operation.name": "execute_tool",
    "gen_ai.tool.name": "stripe.refunds.create",
    "ti.action.class": "payments.refund",
    "ti.impact.kind": "monetary",
    "ti.impact.amount": 420,
    "ti.impact.unit": "USD",
    "ti.action.reversible": false,
    "ti.control.outcome": "approved",
    "ti.control.rules": [
      "refund.amount_over_threshold"
    ],
    "ti.control.policy": "refunds@v12",
    "ti.control.approved_by": "reviewer@example.com",
    "ti.control.approved_at": "2026-11-02T14:03:11Z"
  }
}

Abridged. Illustrative values.

Enforced where the tool runs
Only the executor sees the real arguments, can actually block and can keep counters in the same transaction as the action.
Reported on the tool span
allowed, approved or blocked, with the deciding rules, the policy version and the approver, sent over the same OTLP path as every other span.
Trusted only from the platform
Ingest stamps who reported each span from its API key. Control facts count only when they come from a key issued to the platform.
Adoption and bypasses
The share of risky actions with a reported control outcome, and a signal when a risky action ran with none.
Suggested controls
Issues come with a control to enforce: a plain condition and an outcome that the platform's adapter maps to its own policy language.
Priced into coverage
Control adoption feeds the coverage limit, and an enforced control keeps a flagged issue covered while you fix it.

Developers

Instrument in minutes. Report controls on the span.

Bring the OpenTelemetry you already have, or add the SDK for sessions, tool calls and business events in one place. Telemetry errors are logged and never reach your code, and nothing sits in your agent's action path.

Controls from your agent platform
Fastport reports control outcomes on its tool spans. Any other agent platform can do the same with a platform key and the ti.control.* attributes.
OpenTelemetry Collector
Run a Collector in your network to drop prompt and response content and mask e-mail addresses before anything leaves it.
CLI
Early access. tracesinsure doctor checks your setup; send-test-trace and verify cover the rest, including a CI gate.

.env

# Any OpenTelemetry SDK (Node, Python, Go, Java, .NET) or Collector
OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://ingest.traces.insure/v1/traces
OTEL_EXPORTER_OTLP_TRACES_PROTOCOL=http/json
OTEL_EXPORTER_OTLP_TRACES_HEADERS="Authorization=Bearer%20ti_live_…"
OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai_latest_experimental
OTEL_SERVICE_NAME=refund-agent
OTEL_RESOURCE_ATTRIBUTES="deployment.environment.name=prod"

Already instrumented? Point any OpenTelemetry exporter at ingest. JSON and protobuf, gzip or not. GenAI conventions, OpenInference and OpenLLMetry spans are normalized for you.

One data layer, every owner

Built for everyone who answers for an agent

Observe, understand and assure over the same traces, so engineering, product, risk and leadership look at one version of the truth.

For engineering
What's breaking in production, why, and how to fix it.
- Traces and sessions from any framework, in one place
- Issues with evidence traces and suggested fixes
- Suggested controls for your agent platform to enforce, from real issues
- A release gate in CI on open blocking issues
Agent behavior analytics
For product & CX
What users come for, and whether the agent gets it done.
- Use cases discovered from real conversations
- Outcomes joined to your own business events
- Funnels, paths and ranked pain points with quotes
- A weekly feed of what changed with each release
Product analytics
For risk & compliance
Evidence you can hand to an auditor, a customer or a carrier.
- Every platform-reported control outcome, approval and issue on a hash-chained ledger
- Approvals record who approved and when, as the platform reported it
- Readiness reports mapped to the EU AI Act, ISO/IEC 42001 and AIUC-1
- Telemetry integrity checks: unobserved actions are not covered
For leadership
More autonomy for your agents, with money behind it.
- An Agent Reliability Score per agent and version
- Risk-adjusted economics: value delivered minus cost, expected loss and premium
- Coverage that grows as each agent proves itself
- A public protection page that shows end users they're covered

Score & cover

Coverage that grows as the agent proves itself

Insurance written from a point-in-time audit can't keep up with an agent that changes every week. traces.insure underwrites from behavior: the Agent Reliability Score, the issues you've fixed and verified, and the share of risky actions with a control outcome reported by your agent platform. As the record improves, limits rise and scenarios are added.

First-party
Your own losses
Downtime, data loss, cost overruns and remediation when an internal agent (coding, SRE, data, back-office) gets something wrong.
Third-party
The end users your agents serve
When a customer-facing agent makes a promise it shouldn't or moves money it shouldn't. End users see the cover on your protection page.

traces.insure is not an insurer. Policies are placed with licensed insurance partners, and we're opening coverage with design partners first. Availability, terms and limits depend on the policy.

Coverage limit over an agent's recordillustrative

Baseline
Observed, telemetry complete
Issue in grace
Covered while you fix
Control enforced
Compensating control
Fix verified
Replay, probes, soak
Clean record
Scenario added

traces.insure/protect/your-company

Insured with traces.insure

Your assistants are covered

A public page for your end users: covered assistants, third-party scenarios with live state, and a claim form.

customer_statements.commitmentsCovered
payments.refundCovered
customer_statements.pricingCovered in grace

Agent platforms get a public traces.insure profile and an embeddable badge.

Security & privacy

Insurance-grade telemetry, without handing over your transcripts

You decide how much content leaves your systems. Integrity is built in: sequence numbers and heartbeats expose gaps, and an agent describing its own controls is never counted as a control.

Redacted by default
The SDKs redact secrets and PII (card numbers with a Luhn check, e-mail addresses, SSNs, phone numbers, IBANs) before anything leaves your process.
Three privacy modes
full, redacted (the default) or features, which sends no content at all and still gives you outcomes, funnels, paths, cost and risk signals.
Content only where you allow it
Prompt and response text is kept on spans only in full mode. Redacted transcripts used for enrichment are deleted after a retention window.
Filter in your own network
Run an OpenTelemetry Collector to drop content and mask data before it reaches us. Loop detection still works from argument hashes.
Models that stay on the platform
Enrichment and its decision models run on Workers AI by default; external model providers are opt-in. We don't train models on your content.
Tamper-evident evidence
Platform-reported control outcomes, approvals and issue transitions are hash-chained per agent and anchored daily, so the record can be verified later.
Scoped API keys
Separate scopes for ingest, read and admin. Keys that can report controls are issued to an agent platform by us, never created through the API.
Built on Cloudflare
Ingest and the risk engine run as Workers and Durable Objects on Cloudflare's global network, close to your agents.

Give your agents a track record worth insuring

Start with analytics on the traces your agents already emit. Report the controls your agent platform enforces. Coverage follows the record.

Get started Talk to us

Pricing isn't public yet. Tell us about your agents and we'll walk you through it.

Understand, score and insure your AI agents

Works with what your agents already emit

Know what your agents do, and whether users got what they came for

What your agents actually do

Tool-call patterns

Loops and retries

Failure and escalation

Cost, latency and tokens

Version over version

Baselines and drift

Signals in plain language

From signal to issue

What users wanted, and whether they got it

Use cases, discovered

Outcomes you can trust

The verification gap

Business-event connectors

Funnels in plain language

Paths and pain points

End users and segments

Insights and Ask

The loop is the product

Observe

Your agent platform enforces. We verify, score and insure.

Enforced where the tool runs

Reported on the tool span

Trusted only from the platform

Adoption and bypasses

Suggested controls

Priced into coverage

Instrument in minutes. Report controls on the span.

Controls from your agent platform

OpenTelemetry Collector

CLI

Built for everyone who answers for an agent

For engineering

For product & CX

For risk & compliance

For leadership

Coverage that grows as the agent proves itself

First-party

Third-party

Insurance-grade telemetry, without handing over your transcripts

Redacted by default

Three privacy modes

Content only where you allow it

Filter in your own network

Models that stay on the platform

Tamper-evident evidence

Scoped API keys

Built on Cloudflare

Give your agents a track record worth insuring