traceroot vs. Respan
Respan AI (formerly Keywords AI) vs. traceroot, compared at the source level: tracing, git context, production judges, root cause analysis and pricing.
On this page
Your agent told a customer something wrong, and the trace looks fine. traceroot and Respan, the company that was called Keywords AI until February 2026, will both record that run and both run a model over it. This post compares the two where they overlap: how traces get in, what each tool knows about your code, how production traffic is judged, what happens after a trace is flagged, and what it costs. traceroot is open source, so its side is checked against the code. Respan publishes its SDKs and CLI in respanai/respan, so its side is checked against that repository, the Respan docs and the pricing page, in November 2026.
TL;DR
Open source and self-hostable on every plan. The whole traceroot platform is open source and self-hostable, from the SDKs to the detector worker and the root cause analysis agent. Respan's SDKs and CLI are public, and its pricing page lists self-hosted deployment on the Enterprise plan. Both let you query spans with ClickHouse SQL, but only traceroot's ingest path, from the raw OTLP buffer to the ClickHouse span table, is in a public repository you can run.
Full GitHub context on every trace. The traceroot SDK records the repository and Git ref on every span, and the file, line and function for instrumented functions. The Respan SDK records sessions, customers, prompts and custom properties, and its attribute contract has no repository or commit keys.
Judged per trace, grouped into Signals. A traceroot detector judges each sampled trace about a minute after its last span arrives, and flagged traces with the same problem are grouped into Signals that reopen on regression. Respan scores every new span against its behaviors with span-02, a model Respan built that answers each behavior's question with a confidence score, on the Team plan and above.
Root cause analysis reads your code at the recorded commit. traceroot's agent clones your repository at the commit on the trace into a sandbox, returns the root cause with its code location, and can optionally open a pull request. Respan's Copy fix prompt hands the investigation to your own coding agent through the Respan MCP server.
About $169 a month less for the same agent. For an agent that runs 100 times a day with 10 spans per run, every run judged in production, traceroot Starter is $30 a month and Respan Team is $199 a month billed yearly, because behaviors need Team. At 1,000 runs a day it is $46 against $215, as worked out under Pricing and retention.
Choose traceroot if you want an open-source, self-hostable platform built to keep improving agents in production, for less at the same volume: from a judged trace to a Signal, to a root cause in your code, to an optional pull request, with a CLI your coding agent can drive.
Choose Respan if you want an AI gateway, prompt management and tracing on one hosted platform, with every new span scored against your behaviors by span-02 and fixes handed to your own coding agent through the Respan MCP server.
At a glance
| Respan | traceroot | |
|---|---|---|
| Open source | — SDKs and CLI | ✓ |
| Self-hosting | Enterprise only | ✓ |
| OpenTelemetry ingestion | ✓ | ✓ |
| Framework integrations | ✓ | ✓ |
| Cost and token tracking | ✓ | ✓ |
| Sessions | ✓ | ✓ |
| Datasets and experiments | ✓ | ✓ |
| SQL access to trace data | ✓ | ✓ |
| CLI | ✓ | ✓ |
| Repository and Git context on traces | Via custom properties | ✓ SDK Git context |
| LLM judge on production traces | ✓ Behaviors | ✓ Detectors |
| Recurring failures tracked with a status | ✓ Error groups | ✓ Signals |
| Reads your code at the traced commit | Via your coding agent | ✓ |
| Opens a pull request | Via your coding agent | ✓ Optional |
| Paid plans from | $199 a month, billed yearly | $30 a month |
Open source and self-hosting
Traces hold your prompts, your customers' words and every tool call your agent made, so where they live matters.
traceroot is open source and self-hostable. make prod in the repository brings up the full stack with Docker Compose: the web app, the API, the ingest worker, the detector worker, the root cause analysis agent and the databases (docker-compose.prod.yml). The code you self-host is the code behind traceroot Cloud. The SDKs and the CLI live in their own repositories (traceroot-py, traceroot-ts, traceroot-cli).
Respan's public repository is an SDK monorepo. Its architecture notes describe five layers: shared contracts, the tracing runtime, the respan facade package, instrumentation adapters and the operator CLI, in Python and JavaScript. The service that stores, scores and shows your traces is hosted at api.respan.ai. On the pricing page, Free and Team are cloud only, and Enterprise lists "Cloud, Self-hosted".
Architecture, from SDK to storage
Both products take OpenTelemetry spans. What differs is how much of the path you can read.
traceroot buffers OTLP batches in object storage, a worker writes spans to ClickHouse, a detector worker judges finished traces, and flagged traces become Signals that the root cause analysis agent investigates. The Respan SDK exports OTLP JSON to the hosted /api/v2/traces endpoint, spans are stored as logs, and every new span is scored against behaviors.
traceroot is split into services. The public traces endpoint stores each OTLP request body in S3 or MinIO exactly as received, then queues a task with a pointer to it (traces.py). A Celery worker decodes the batch and writes it to ClickHouse (ingest_tasks.py). Because the raw body is stored first, a batch that fails every attempt is moved aside where it can be inspected or replayed (ingest_quarantine.py). Spans live in a ClickHouse ReplacingMergeTree table ordered by project, trace and start time, with input, output and metadata compressed with ZSTD, and with first-class git_source_file, git_source_line and git_source_function columns (005_rebuild_spans_trace_id_order.sql).
On the Respan side, the public code ends at the exporter. RespanSpanExporter turns OpenTelemetry spans into OTLP JSON and posts them to /v2/traces under the Respan base URL (respan.py). Any OpenTelemetry app can send to the same endpoint in JSON or Protobuf (OpenTelemetry). Respan's SQL editor runs read-only ClickHouse SQL over a logs table with one row per span, plus traces, eval_results and annotations tables. How the hosted service is built behind that endpoint is not public.
| Dimension | Respan | traceroot |
|---|---|---|
| Ingest endpoint | OTLP JSON or Protobuf at /api/v2/traces |
OTLP protobuf, stored raw before processing |
| Span store | ClickHouse SQL over logs and traces; internals not public |
ClickHouse, readable in the repository |
| Background work | Hosted, not public | Celery and BullMQ workers on Redis, in the repository |
| Deployment files | Enterprise plan; not in the public repository | Docker Compose |
| Retention | 30 days by default, custom on Team | Per-project trace TTL, set with projects update --trace-ttl-days |
Tracing and git context
Both tools trace an agent step by step on top of OpenTelemetry, and both cover the common agent frameworks.
traceroot's Python SDK depends on the OpenInference instrumentors for OpenAI, Anthropic, LangChain, LlamaIndex, CrewAI, the OpenAI Agents SDK, Google GenAI and more (pyproject.toml), and the TypeScript SDK uses the @arizeai/openinference-* packages (package.json). On the server, traceroot maps openinference.span.kind to its own span types (otel_transform.py).
What traceroot adds on top is full GitHub context. When the client starts, it resolves the repository and Git ref from explicit settings first, then TRACEROOT_GIT_REPO and TRACEROOT_GIT_REF, then CI variables, then files written at build time, then the local .git directory (client.py). The span processor stamps traceroot.git.repo and traceroot.git.ref on every recording span (span_processor.py), and the observe decorator records the caller's file, line and function (git_context.py). For images without a .git directory, the repository and commit can be injected at build time.

The Respan SDK is built on the OpenTelemetry SDK and the AI semantic conventions (pyproject.toml) and writes Traceloop (OpenLLMetry) attributes such as traceloop.span.kind. Its server also maps OpenInference attributes into the same fields, so OpenInference instrumentors work with Respan as well (OpenTelemetry). The @workflow, @task, @agent and @tool decorators give your own functions spans. The SDK's own attribute keys cover customers, sessions, threads, prompts, environment, metadata and properties (span_attributes.py). There is no repository, commit or source location key, so on Respan you send them yourself as custom properties.
| Dimension | Respan | traceroot |
|---|---|---|
| Instrumentation | Respan adapters on Traceloop conventions; OpenInference mapped on the server | OpenInference, wrapped by the traceroot SDKs |
| Repository and Git ref | Your own custom properties | Resolved by the SDK and stamped on every span |
| File, line and function | — | Recorded for instrumented functions, stored as columns |
| Trace export with git context | respan traces get and exports to CSV or JSONL |
traceroot traces export writes git_context.json next to the spans |
Judging production traffic: detectors and behaviors
traceroot is built for one job: helping you keep improving your agents in production. A detector is a plain-language description of one behavior you want to catch, such as a wrong answer or an unfinished task, that a judge model checks traces against.
The trigger path is in the open-source backend. The ingest batch that carries a trace's root span takes a Redis lock, checks the detector's filters and a deterministic sample, and enqueues one delayed job. The worker then waits until the trace has been quiet for 60 seconds before judging it (detector_tasks.py). The judge reads every span of the trace, rendered as text with each span kept in its place (judge-input.ts), and each sampled trace gets one verdict.
When a detector says yes, the trace is flagged and grouped into a Signal. For most detectors, traceroot embeds the judge's summary, shortlists the nearest existing Signals, and lets a model decide whether the trace joins one or starts a new one. A Signal is Open, Resolved or Dismissed, and a Resolved Signal reopens by itself when a trace that started after the fix shows the problem again.

Respan's equivalent is behaviors: "a plain-language definition of something your agent does", which Respan scores "every new span against". Five are built in (Refusal, Instruction miss, Incomplete answer, Structured output and Task complete), and you can write your own. Each behavior is an Issue, a Win or Info, fires when the model's confidence is above 65%, and is scored by span-02, Respan's own decision model. Behaviors need the Team plan or higher, and only new spans are scored, so editing a behavior does not rescore old ones. Respan's signals panel, a different thing from a traceroot Signal, charts spans, errors and behavior counts over time, with a change against the previous period (Signals and errors).
| Dimension | Respan | traceroot |
|---|---|---|
| Unit that is judged | Each new span | The whole trace, after it has been quiet for 60 seconds |
| Judge model | span-02 | traceroot's hosted model, or your own key on every plan |
| Sampling and filters | Every new span, while the behavior is on | Per detector |
| Recurring failures | Behaviors: counts, share of spans and change per period. Error groups: Resolve, Ignore or Reopen | Grouped into Signals: Open, Resolved or Dismissed, reopened automatically on regression |
| Alerts | Monitors on behaviors and error groups | Email and Slack digests for new and reopened Signals |
| Plan | Team and above | Every plan, 100 detector runs a month on Free |
From a flagged trace to a fix
With automatic root cause analysis on, a new or reopened Signal starts an investigation. You can also run one by hand.
A root cause is only as good as the context behind it. traceroot's agent is a coding agent, powered by pi-mono, that runs in an isolated sandbox. It clones your repository at the commit recorded on the trace, reads the traces behind the Signal and the file and line on the failing span, and returns a root cause, the code location and a recommended fix. The sandbox can read trace data and source code, but not your production databases or APIs. In docker-compose.prod.yml, the agent is its own service, with Docker or Daytona as the sandbox provider.

A pull request is optional. If you ask for one, the agent writes the fix and opens a pull request on a new branch through the GitHub App, linked to the trace, for an engineer to review. It never pushes to main.
In Respan, the step after a flagged span is a prompt for your own coding agent. An open behavior or error group has Copy fix prompt, which "asks the agent to investigate through the Respan MCP server and propose the smallest safe fix" (Behaviors). For an error group, the prompt carries the fingerprint, status code, time range, filters, counts, a sample span ID and the error message (Signals and errors). Your coding agent then reads the spans through the MCP server and works in your checkout. Respan's in-app agent answers questions about your data and setup (Get help).
| Dimension | Respan | traceroot |
|---|---|---|
| Started by | You, by copying the prompt | A new or reopened Signal, or by hand |
| Who investigates | Your coding agent, through MCP | traceroot's agent, in a sandbox |
| Code it reads | Whatever checkout your coding agent has open | A clone of your repository at the commit on the trace |
| Output | Depends on your coding agent | Root cause, code location, recommended fix |
| GitHub | Through your coding agent | Optional pull request on a new branch |
A CLI your coding agent can use
Both tools ship a CLI and skills for coding agents.
traceroot setup signs you in, writes a project API key into your env file, has Claude Code or Codex add the SDK, and waits for the first trace. After that, the CLI is built around the improvement loop. An agent can list flagged traces, read one with its root cause analysis, and export a trace with its git context into the repository it is editing. It can run project-scoped, read-only SQL over spans and traces, and create, update and delete detectors, alerts, dashboards and projects. Every command takes --json, and exit codes are documented.
The Respan CLI, @respan/cli, lists and reads logs and traces, filters them with --filter field:operator:value, and calls the same tools as the MCP server with respan tools call. Its source also has commands for datasets, evaluators, experiments and prompts (commands), and the repository carries plugins and skills for Claude Code, Cursor and ChatGPT.
| Dimension | Respan | traceroot |
|---|---|---|
| Guided setup | "Set up Respan for me" prompt for your coding agent | npx -y traceroot-cli@latest setup, with --resume |
| Health check | respan setup doctor |
traceroot doctor and traceroot setup doctor |
| Judged traces | respan tools call over MCP tools |
traceroot findings list and findings get, with root cause analysis |
| Trace export | respan traces get, --json or --csv |
traceroot traces export, with git_context.json |
| Read-only queries | SQL editor in the app | traceroot sql, SQL over spans and traces |
Evaluation as the verify step
A fix is done when it is checked. Both tools run offline evaluations over datasets.
traceroot evaluations run your system over a dataset, and each case runs as a trace, so the cost and span views you use in production work for the eval too. Scorers can be code or an LLM judge. Label a run with the pull request's commit, compare it with the current version on the same immutable dataset version, and merge when it holds. traceroot evals runs get shows the pinned dataset version and per-scorer means from the terminal.
Respan's November 11 release added dataset versions, which run a prompt or model configuration against a dataset and compare versions row by row, and lets you score dataset rows with behaviors; experiments became read-only (changelog).
Pricing and retention
traceroot Cloud is priced by events, where a trace and each of its spans count as one event, in blocks of 50k (usage metering). Respan prices by logs, and a log is one span (SQL editor). Plan details are from the traceroot pricing page and the Respan pricing page.
| Dimension | Respan | traceroot |
|---|---|---|
| Free | $0: 100k logs, 1k scores, 30-day retention | $0: 50k events a month, 15-day retention, 2 seats, 100 detector runs |
| First paid plan | Team, $199 a month billed yearly: 100k logs, 10k scores, 5 members | Starter, $30 a month: 150k events, 30-day retention, unlimited seats, unlimited detector runs |
| Next plan | Enterprise, custom | Pro, $200 a month: 90-day retention |
| Overage | $8 per 100k logs, $1 per 1k scores | $4 per 50k events |
| LLM judge on production traffic | Behaviors from Team | Every plan |
| Self-hosting | Enterprise only | ✓ |
A worked example: an agent that runs 100 times a day, with 10 spans per run, and you want every run judged in production. Over 30 days that is 3,000 traces and 30,000 spans.
| Dimension | Respan | traceroot |
|---|---|---|
| Plan that judges production traffic | Team, $199 a month billed yearly, since behaviors need Team | Starter, $30 a month, unlimited detector runs |
| Retention | 30 days | 30 days |
At 1,000 runs a day, traceroot meters 330,000 events: Starter's 150k plus four extra blocks of 50k, or $46 a month. Respan meters 300,000 logs: Team's 100k plus two extra blocks of 100k, or $215 a month billed yearly.
Which should you choose
Choose traceroot if you want an open-source, self-hostable platform built to keep improving agents in production. Detectors judge whole traces on the server, flagged traces become Signals with full GitHub context, the root cause analysis agent reads your repository at the recorded commit, and a pull request is one optional step away, with a CLI your coding agent can drive. For the same traffic it costs less, $30 against $199 a month at 100 judged runs a day and $46 against $215 at 1,000, and the whole stack, from the raw OTLP buffer to ClickHouse, is code you can run yourself.
Choose Respan if you want an AI gateway, prompt management and tracing on one hosted platform, with behaviors scored per span by Respan's own model and fixes handed to your own coding agent through the Respan MCP server.
Both speak OpenTelemetry, so the easiest way to decide is to send one agent's traces to traceroot next to what you run today.
Switching from Respan
You do not have to switch in one step.
- Run
npx -y traceroot-cli@latest setupin the repository of one agent. It adds the traceroot SDK and checks that the first trace arrives. - Keep Respan running while you compare. OpenTelemetry lets one tracer provider export to more than one endpoint, so the same spans can reach both.
- Write a detector for one failure you already track as a Respan behavior, and connect the GitHub App so root cause analysis can read your code at the recorded commit.
- Compare what each tool tells you about the same failures for a week or two, then move your datasets when you are ready.
Get started
Install the CLI and run traceroot setup in the repository of one agent. Pick one failure you have already worked through by hand, so you know what a correct diagnosis looks like, then write a detector that describes it in plain language. The code is on GitHub.
FAQ
Is traceroot an open-source Respan alternative? Yes. traceroot is open source and self-hostable. It judges production traces with detectors, groups flagged traces into Signals, investigates them against your repository at the recorded commit, and can optionally open a pull request for review.
What is Respan AI? Respan is the new name of Keywords AI, announced on February 20, 2026. In March 2026 it announced $5M in funding from Gradient, Y Combinator and others.
Is Respan open source? Respan's SDKs, CLI and coding-agent plugins are public in respanai/respan. The service that stores and scores your traces is hosted, with self-hosted deployment listed on the Enterprise plan.
Does Respan record the commit on a trace? Not by itself. The Respan SDK's attribute keys have no repository or commit fields; you can send them as custom properties. traceroot's SDK resolves the repository and Git ref and stamps them on every span.
How is a traceroot Signal different from a Respan behavior? A behavior scores each new span with span-02 and shows how often it fires. A traceroot detector judges the whole trace once it is quiet, and flagged traces are grouped into Signals that you resolve and that reopen on regression.
Can I keep my OpenInference instrumentation? Yes. traceroot's SDKs are built on the OpenInference instrumentors, and its ingest worker reads OpenInference span kinds.
Do I need to give traceroot access to my repository? Only for root cause analysis and pull requests. Tracing works without it.
All Respan facts were checked against Respan's public docs, pricing page and the respanai/respan repository in November 2026. If something has changed, tell us on GitHub.