Know what every agent, model, session and end user costs you, and see the traces, evals and agent graph that explain why. Add three environment variables and the numbers start arriving. Nothing of ours runs inside your agent: no SDK, no registration, no rewrite.
14-day trial · no credit card · self-host if you prefer
Your ADK agent already reports everything we need. Switching it on is a setting, not a code change, so there is no pull request to review, no release to wait for, and nothing to undo if you stop.
# agent.py: you edit your agent
from vendor_sdk import Tracer, Plugin
tracer = Tracer(api_key=...)
app = App(
agent=root_agent,
plugins=[Plugin(tracer)], # <- code change
)
# ...and again for every agent you own# agent.py: untouched export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=\ https://api.traptureiq.com/v1/traces export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=\ https://api.traptureiq.com/v1/logs export OTEL_EXPORTER_OTLP_HEADERS=\ "x-api-key=tiq_your_key" # pip install opentelemetry-exporter-otlp-proto-http # that's it, cost and traces start flowing
Verified end to end against real Vertex AI Gemini calls on both Cloud Run and Agent Engine, deployed agent to deployed server, correctly priced, with no edit to the agent in either case.
The same three variables work on your laptop. Run adk web, talk to your agent, and the dashboards fill in, no deploy, no staging environment, no separate “instrumented” build. Most teams discover what an agent costs a month after shipping it. This moves that to the moment the prompt is still cheap to change.
A reasoning model that thinks for 3,000 tokens per turn is a different product decision than one that thinks for 300. Thinking tokens bill at output rates and are routinely the largest single line: in a measured four-call run, 3,042 of 5,044 tokens.
A multi-agent pipeline fans one question into many priced calls. Cost is broken out per sub-agent and per model automatically, so you can see which branch of the graph is expensive rather than guessing from a total.
Tag local runs with deployment.environment and development, staging and production stay separable everywhere, instead of load tests quietly inflating the number you report.
Works with adk web and adk api_server. Not adk run, which does not initialise OpenTelemetry at all.
Not how you drew them on a whiteboard. TraptureIQ works the structure out from what really happened: which agents ran, in what order, in parallel or not, and how long each branch took. You declare nothing and it never goes stale.
A ParallelAgent degraded to serial execution returns the right answer and raises no error. It just runs three times slower than you designed it to. The concurrency ratio is that bug, and nothing else you run reports it.
A multi-agent pipeline fans one question into many priced calls. Spend is broken out per sub-agent and per model, so you can name the expensive branch instead of inferring it from a total.
Derived from the same spans the cost numbers come from. No graph to define, no decorators, no registration step that goes stale the next time someone adds a sub-agent.
Traces, evals and runtime config run off the same ingested spans, so they agree with the cost numbers by construction, not because you reconciled three tools by hand.
Spend attributed per sub-agent, model, session and end user.
Traces, agent topology, user journeys, logs and tool errors.
Eval sets, LLM-as-judge scoring and load tests.
Token analysis, prompt library, parameter store, MCP debug.
Google sign-in. The key is shown once, at creation.
That is the whole integration. No SDK inside your agent, no decorators, no edit to agent.py, and nothing to unpick if you stop. On another framework? You can send us data directly; the no-code-change path is ADK's.
Cost, traces, journeys, logs and the agent graph appear as calls happen. Nothing to register, no agent inventory to maintain. An agent name is just a label.
Tenant data is physically separated, not filtered by a WHERE clause. Prompt and response bodies live in their own database per tenant.
A call's cost is computed once, when it arrives. Editing pricing later never rewrites history.
One FastAPI service and a Postgres database. Point DATABASE_URL at your own instance and run it yourself.
Free for 14 days. Instrumenting takes about as long as reading this page.