6 best coding agent observability tools for session insights

---

What to look for in coding-agent session insights

Coding-agent observability helps you identify repeated problems in developers' sessions and decide whether to change shared instructions or skills. Suppose an agent repeatedly edits the wrong configuration file because the repository's instructions omit a naming convention. One trace helps you diagnose that task. Similar traces across developers give you a reason to update the instructions and check later sessions for the same mistake.

Raw traces show what happened in a session, and adoption dashboards show who uses an agent. To improve shared guidance, you also need to identify recurring failures and check whether a revised instruction or skill changes later behavior.

The comparison examines which coding-agent sessions each tool captures, how you can investigate failures, whether it identifies recurring patterns, and how findings can inform changes to instructions or skills.

1. Braintrust

Best for engineering teams that want recurring session analysis tied to evidence-backed changes to agent instructions and skills. Braintrust's Coding Agent Insights recipe connects recorded coding sessions to classifications and a daily investigation. You can use repeated problems as evidence for a change to a shared instruction or skill. Then use later traces or evaluations to check whether the agent's behavior changed. Coding Agent Insights is in public preview.

Tracing

Braintrust records coding-agent sessions as traces you can inspect when an agent repeats a tool call, makes a failed edit, or finishes without completing the task. The bt tracing integration covers Claude Code, Codex, Cursor, OpenCode, Pi, Antigravity, and Grok. The evidence depends on which sessions your instrumentation records: the dashboard reports trace coverage as a count such as 4 / 12, meaning four of twelve human members sent matching model calls, not a complete measure of agent adoption.

Topics

Topics classify recorded sessions with three facets: Coding agent context debt, which identifies reusable knowledge or access the agent lacked and you had to supply; Primary failure mode, which labels the main problem in a session, such as an unresolved test failure or editing the wrong files; and Skills analysis, which labels problems caused by a skill the agent loaded. Those categories help you separate a one-off failed edit from a recurring problem that a repository instruction or agent skill might address. You still need to inspect the underlying sessions before changing guidance.

Loop investigation

A daily Loop automation, Coding Agent Improvements Discovery, reviews a rolling 30-day window, checks facet classifications against raw evidence, and creates or updates recurring findings. The scheduled review helps you find patterns across developers' sessions without searching every trace manually. Loop needs collected traces and configuration, and its findings still require engineering judgment.

Patterns

Patterns retain supporting evidence for a finding, so you can inspect the affected sessions before deciding on a fix. Braintrust also supports follow-up investigation and scoring. You can use that workflow to test whether revised instructions address the observed failure rather than treating the revision itself as proof of improvement.

Pros

• Braintrust connects recurring findings to the session evidence you need to propose a change, then lets you check later behavior through traces or evaluations.

Cons

• Confirm public-preview access and which developers' sessions your instrumentation records before rollout.
• Shared credentials can obscure individual attribution: if teammates share one API key, all of their sessions appear under the key's owner. Members in overlapping permission groups count toward each group, so group rows can exceed the summary totals.
• Traces can include private prompts and source code. Span plugins can remove values on each computer before bt transmits them; ingestion redaction is separately in private preview.

Pricing

Braintrust pricing lists Starter at $0/month and Pro at $249/month, with usage charges beyond included allowances. Confirm access to the preview workflow for your plan. These platform charges are separate from the model costs estimated in session dashboards.

2. Paper Compute

Best for teams that want to turn successful coding-agent sessions into reusable skills and evaluate those skills before wider use.

Paper Compute's console stores captured sessions as searchable history, with prompts and tool activity alongside cost, duration, and completion status. Its team dashboard helps you locate expensive or unsuccessful runs for investigation.

Suppose one developer resolves a repository setup problem that keeps blocking other agents. Paper Compute can generate a skill from the captured session, giving the team a versioned instruction based on the work that succeeded. Its skill evaluations check a saved revision against explicit criteria and session evidence. When an evaluation identifies a failure, you can review a proposed rewrite before publishing a new version.

Pros

• Session-derived skills give teams a documented path from useful agent work to shared guidance.
• Skill evaluations retain criterion-level reasoning and support reviewing proposed improvements.
• No per-seat fees on any plan.

Cons

• The CLI overview lists Claude Code, Codex, and Pi as supported agents, each launched with paperctl start <agent>. Cursor is not on that list, so teams using it should confirm a capture path before choosing Paper Compute.
• Evaluations need relevant session evidence and meaningful criteria; a passing skill evaluation alone does not prove better outcomes across the team's future tasks.

Pricing

Paper Compute pricing lists Start at $64/month and Scale at $256/month, with no per-seat fees. Start includes weekly skill suggestions, skill evals, and dashboard digests; Scale adds unlimited skill generation and evaluations, deep insights and trends, and session chat. Digests are generated on demand rather than delivered automatically: when a period has no digest, anyone on the team clicks Generate. The 24-hour "Today" digest requires Start or above, while the 7-day "This week" digest is available on all plans. Enterprise offers custom pricing and single-tenant deployment. The open-source tapes capture layer is free to self-host; that is separate from the hosted console plans.

3. Langfuse

Best for engineering leads who want an open-source, self-hosted tracing layer across multiple coding-agent integrations. Langfuse helps you investigate a developer's session by reconstructing recorded activity, showing tool calls, and letting you search traces for sessions worth reviewing. Its coding-agent tracing guide documents several integration paths, so you can choose one that fits the agents your developers use.

Capture depth depends on the integration. Langfuse notes that traces may not show the full context assembled for an agent, and locally disabled hooks leave activity unrecorded. You should check a sample session before treating missing tool calls or context as evidence that the agent never saw them. Langfuse's MCP access lets an agent query application data, but that access does not capture the agent's own coding session.

Pros

• Self-hosting gives you control over where session data lives.
• Searchable traces support investigations across recorded sessions and tool activity.

Cons

• The documented hooks do not capture the complete assembled context, and developers can disable them locally.
• Teams need to choose how to turn trace findings into changes and evaluate the result; the tracing integration alone does not define that process.

Pricing

Langfuse Cloud offers a free Hobby plan with 50,000 units per month and two users. Core starts at $29/month with 100,000 units and unlimited users. A unit is any tracing data point — a trace, an observation, or a score — so a single coding session consumes many units. Self-hosting is available, with infrastructure costs to account for.

4. LangWatch

Best for engineering leads who need tool-level traces and token accounting to investigate costly coding-agent sessions. LangWatch's Claude Code documentation describes traces that connect model turns with tool spans, so you can inspect repeated calls alongside token and cache usage. Its MCP access lets an agent query historical sessions during an investigation. LangWatch also documents other coding-agent integrations, though you should check the capture depth of the agent you use.

Pros

• Tool spans and token accounting help locate expensive turns and repeated work.
• Historical-session queries let an agent investigate patterns across multiple traces.

Cons

• API-equivalent estimates for subscription sessions do not represent per-session invoices.
• The evidence available for an investigation depends on the coding agent's integration and capture settings.

Pricing

LangWatch pricing lists a free Developer plan with 50,000 events per month, two users, and 14-day data access. Growth starts at €29 per core seat per month with 200,000 events included and additional usage charges. These are the EUR prices displayed on the pricing page, not USD amounts.

5. Opik

Best for Claude Code users who want to inspect sessions and subagent activity.

Opik's official Claude Code plugin records session traces, tool spans, and nested subagent relationships. You can follow a delegated task into its subagent trace rather than treating the parent session as one uninterrupted run. The plugin provides project-level and global tracing controls, so you can choose where to collect that evidence.

Pros

• Nested spans help you investigate which subagent ran a tool or took an unproductive path.
• The official plugin provides project-level and global tracing controls.

Cons

• This plugin targets Claude Code; coverage for another coding agent requires a separate integration check.
• Session tracing and Opik's Cost Intelligence offering use different capture paths. Their recorded content and cost information should not be assumed equivalent.

Pricing

Opik pricing lists free open-source self-hosting and a Free Cloud plan with 25,000 spans per month for up to 10 members. Pro Cloud starts at $19/month with 100,000 spans and up to 50 members. A session can contain many spans, so estimate volume from representative sessions.

6. Datadog Agent Console

Best for engineering leads who want to find repeated waste in developers' coding-agent sessions and address its causes in repositories.

Datadog Agent Console connects session cost attribution with findings about wasted agent work. It detects waste patterns such as skipped tests, retry loops, and file rereads, and its Fix Library supplies vetted remediations that can be deployed as pull requests across one or many repositories. That gives you a way to investigate recurring patterns and make repository-level changes, rather than stopping at an adoption dashboard.

Pros

• Agent Console connects recurring waste-pattern analysis to repository remediation through the Fix Library.
• Session-level cost attribution helps identify expensive sessions for investigation alongside team, user, and repository context.

Cons

• Agent Console is in Preview; availability and integration coverage need confirmation for your rollout.
• Usage and engineering-output correlations help guide investigation but do not establish that an agent caused a productivity improvement.

Pricing

Confirm Agent Console preview terms and pricing with Datadog. The general pricing page does not establish a standalone Agent Console price; rates for Agent Observability should not be substituted.

How the six tools compare

Choosing a tool for ongoing session improvement

Braintrust is our recommendation when your team wants a scheduled process for identifying recurring session problems and following up on the evidence. Paper Compute deserves consideration when your priority is building and evaluating a shared skill library from captured work. Datadog Agent Console also deserves consideration when repository remediation and organization-wide waste analysis are central to the decision. For teams prioritizing self-hosted trace investigation, Langfuse offers a documented alternative.

Start with the Coding Agent Insights recipe if Braintrust fits that workflow. Choose a recurring problem from your own sessions and compare its frequency after changing the relevant instruction or skill.

FAQs

Can we observe several coding agents in one platform? Yes, with integration-specific coverage. Braintrust's dashboard documentation lists Claude Code, Codex, Cursor, OpenCode, Pi, Antigravity, and Grok. Langfuse's guide documents several integrations, including Claude Code, Codex, Copilot, and Cursor. A supported-agent list does not mean every integration captures identical fields.

How do we know whether a session insight led to an improvement? Choose a specific behavior from the evidence and record when the relevant instruction or skill changed. For repeated failed edits, establish whether the cause is a stale path, ambiguous file selection, or a replacement that no longer matches. For repeated context requests, identify the repository fact developers keep supplying and confirm the revised guidance is available to the agent.

A small pilot can use the following scorecard. These are suggested measures to define for your tasks, not claims that every platform calculates them automatically.

Keep the task mix and agent/model versions comparable, and check that trace coverage has not fallen. Report the underlying session counts with each rate, separating Claude Code and Cursor results before drawing a team-wide conclusion. A useful change reduces the targeted failure without lowering task completion; fewer tokens alone could mean that the agent gave up sooner.

For a more controlled check, use an affected session to define a repeatable task with a known repository starting state and acceptance criteria. Run that task with the old and revised guidance under otherwise comparable conditions. A saved trace provides evidence for designing the task; it is not itself an executable replay. Check fresh developer sessions afterward to see whether the improvement carries over to ordinary work.