# OpenTelemetry and Analytics for Claude Code, Codex and Cursor

URL: https://developertoolkit.ai/en/ecosystem/observability/agent-telemetry/
Description: Send Claude Code and Codex telemetry to a local Grafana stack, read the analytics dashboards' limits, and trace commits to sessions with Entire CLI.

Coding-agent telemetry comes in three layers: OpenTelemetry export to a collector you run, vendor analytics dashboards for adoption and pull request attribution, and per-commit provenance from Entire CLI. The claude.ai dashboard shows no per-user cost; that comes from OpenTelemetry, the spend report or, on Enterprise, the Analytics API. Cursor had no verified OpenTelemetry export on 2026-09-26.

This page is for the **developer** who wants to see what their agent sessions cost and do, and the **tech lead** who has to answer "is the agent rollout working?" at the next planning meeting. You have 12 seats, an invoice, and a dashboard that says 70% of people were active last week. Nobody can tell you which models the money went to, which merged pull requests the agents wrote, or whether those changes survived.

The canonical page for production telemetry pipelines, audit retention and join keys is [observing the agents](/en/workflows/operate/agent-observability/). The [observability and quality overview](/en/ecosystem/observability/) places this page among the cost, review, security and eval tools. This page is the tool shelf: what each product emits, a local stack you start with one command, and the monthly adoption review built on it.

## What this telemetry setup gives you

- A working local stack: Claude Code and Codex exporting OpenTelemetry into Grafana on your laptop, verified with a single query.
- PromQL for the six Claude Code panels a tech lead asks for: cost by model, tokens by type, active users, sessions, edit accept rate, and commits and pull requests.
- A clear map of what the Claude Code analytics dashboard shows, what it hides (per-user cost), and when it goes dark (Zero Data Retention).
- Entire CLI set up per tool, so any commit leads back to the prompts and session that produced it.
- A monthly adoption review in four steps, and three copy-paste prompts that automate it.

## Which telemetry does each tool give you?

Start by knowing which layer answers which question. Telemetry answers "what did the sessions do and cost?"; analytics answers "who uses it and how much merged code came from it?"; provenance answers "why was this commit written this way?".

| Layer | Claude Code 2.1.283 | Codex CLI 0.157.1 | Cursor |
| --- | --- | --- | --- |
| OpenTelemetry export | Metrics and log events; traces in beta (`CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1`) | Logs, traces and metrics from `[otel]` in `config.toml` | None verified on 2026-09-26 |
| Cost signal | `claude_code.cost.usage` (USD) with `model`, `effort`, `query_source` | `codex.turn.cost_microusd` | Not verified |
| Delivery signal | `claude_code.commit.count`, `claude_code.pull_request.count`, `claude_code.lines_of_code.count` | No commit or pull request metric in `codex-rs/otel` at `rust-v0.157.1` | Not verified |
| Vendor dashboard | `claude.ai/analytics/claude-code` (Team, Enterprise); `platform.claude.com/claude-code` (Console) | Enterprise analytics dashboard and Analytics API (secondary: OpenAI help pages seen only in search extracts) | Team/Enterprise analytics dashboard and Analytics API; AI Code Tracking API (Enterprise only, per its docs page, checked 2026-10-12) maps AI-generated lines to commits (secondary: cursor.com docs seen only in search extracts; endpoints unverified) |
| Per-session view on your machine | `/usage` (`/cost` and `/stats` are aliases); `/insights` writes an HTML report on recent sessions | `codex exec --json` events per run | Not verified |
| Commit provenance | Entire CLI (`entire enable --agent claude-code`) | Entire CLI (`--agent codex`) | Entire CLI (`--agent cursor`) |

Sources: Claude Code [monitoring](https://code.claude.com/docs/en/monitoring-usage) and [analytics](https://code.claude.com/docs/en/analytics) docs; Codex source (`codex-rs/config/src/types.rs` and `codex-rs/otel/src/metrics/names.rs` at `rust-v0.157.1`); the `entireio/cli` README; all read 2026-09-26.

The shared OpenTelemetry vocabulary for agents (`invoke_agent`, `execute_tool`) lives in `open-telemetry/semantic-conventions-genai` and was still **Status: Development** on 2026-09-26, so each tool uses its own names. Build dashboards per tool now and expect renames later.

## What does the Claude Code analytics dashboard show, and what does it hide?

The Team and Enterprise dashboard at `claude.ai/analytics/claude-code` is the fastest adoption view, and it has four limits that change how you use it:

- **No per-user cost.** It shows lines accepted, suggestion accept rate, daily active users, sessions, contribution metrics, and a top-10 leaderboard with a CSV export of all users. Per-user tokens and cost come from OpenTelemetry or from the spend report in your organization's analytics settings.
- **Contribution metrics need GitHub and are a public beta.** An Owner enables analytics and the **GitHub analytics** toggle at `claude.ai/admin-settings/claude-code`, and a GitHub admin installs the app at `github.com/apps/claude`. Data typically appears within 24 hours. Only users in your claude.ai organization count; Console API usage does not.
- **Zero Data Retention turns contribution metrics off.** A ZDR organization sees usage metrics only, so pull request attribution has to come from your own labels or Entire trailers.
- **Attribution is deliberately conservative.** A merged pull request counts when Claude Code sessions from 21 days before to 2 days after the merge match its added lines; code rewritten by more than 20% is not attributed, and lock files, build output and snapshots are excluded. Credited pull requests get the GitHub label `claude-code-assisted`.

That label is the cheapest attribution query you have. In GitHub search, `is:pr is:merged label:claude-code-assisted` lists every merged pull request the engine credited, without API access. On Enterprise, the Claude Enterprise Analytics API returns per-user engagement, usage and cost reports with a key that has the `read:analytics` scope; the Team plan does not get the API. Console customers use the Claude Code Analytics API with an Admin API key, and the Console notes that its spend figures are estimates, not billing.

## Send Claude Code and Codex telemetry to a local Grafana stack

This is the full example: one container, two agents, one query that proves data arrives. It runs on your laptop and costs nothing but disk. The `grafana/otel-lgtm` image bundles an OpenTelemetry Collector, Prometheus, Loki, Tempo, Pyroscope and Grafana; Grafana describes it as intended for development, demo and testing, not production.

1. **Start the stack.** In a terminal:

    ```bash
    docker run --rm --name lgtm \
      -p 3000:3000 -p 4317:4317 -p 4318:4318 -p 9090:9090 \
      grafana/otel-lgtm
    ```

    Port 3000 is Grafana (log in as `admin` / `admin`), 4317 is OTLP over gRPC, 4318 is OTLP over HTTP, and 9090 is Prometheus, which the prompts below query directly.

2. **Point each agent at the collector.** The settings differ per tool.

      **Claude Code**

        Export the variables in the shell that starts `claude`, or put the same keys under `env` in `~/.claude/settings.json`. Claude Code ignores exporter variables in a repository's `.claude/settings.json` and `.claude/settings.local.json`, so a repository cannot turn telemetry on or redirect it.

        ```bash
        export CLAUDE_CODE_ENABLE_TELEMETRY=1
        export OTEL_METRICS_EXPORTER=otlp
        export OTEL_LOGS_EXPORTER=otlp
        export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
        export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
        export OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=cumulative
        export OTEL_METRIC_EXPORT_INTERVAL=10000
        export OTEL_METRICS_INCLUDE_REPOSITORY=true
        claude
        ```

        Claude Code has no default OTLP protocol, so `OTEL_EXPORTER_OTLP_PROTOCOL` is required. Temporality defaults to `delta`; the docs say to switch to `cumulative` when the backend needs it, and a Prometheus-backed stack stores cumulative counters. The 10-second interval is for testing; the default is 60 seconds. `OTEL_METRICS_INCLUDE_REPOSITORY=true` (v2.1.269 and later) adds `vcs.repository.name` and related attributes, so you can filter by repository.

        Prompt text, tool input and responses stay redacted unless you set `OTEL_LOG_USER_PROMPTS`, `OTEL_LOG_TOOL_DETAILS` or `OTEL_LOG_ASSISTANT_RESPONSES`. Leave them off here.

      **Codex**

        Add an `[otel]` table to `~/.codex/config.toml`. The field names come from `OtelConfigToml` in the Codex source, and this block loads without error in codex-cli 0.157.1. A misspelled key name is silently ignored in 0.157.1 and leaves that exporter at its default; a misspelled exporter name such as `otlp-grcp` fails at startup with `Error loading config.toml: unknown variant`:

        ```toml
        [otel]
        environment = "dev"
        log_user_prompt = false
        exporter = { otlp-grpc = { endpoint = "http://localhost:4317" } }
        trace_exporter = { otlp-grpc = { endpoint = "http://localhost:4317" } }
        metrics_exporter = { otlp-grpc = { endpoint = "http://localhost:4317" } }
        ```

        Set all three exporters. In 0.157.1 the log and trace exporters default to `none` and `metrics_exporter` defaults to `statsig`, a Codex-internal destination. For an HTTP collector, use `otlp-http = { endpoint = "...", protocol = "binary" }` with the full signal path (for example `http://localhost:4318/v1/logs`). Headers for an authenticated collector go in an inline `headers = { ... }` table in plain text, so write that file from a secret store and never commit it.

        Metric names to look for include `codex.thread.started`, `codex.turn.token_usage`, `codex.turn.cost_microusd`, `codex.tool.call` and `codex.api_request`.

      **Cursor**

        No OpenTelemetry export for Cursor could be verified on 2026-09-26, so Cursor does not send anything to this stack. Two verified routes give you part of the picture:

        - **Entire CLI** records Cursor sessions per commit through `.cursor/hooks.json` (see [trace a commit back to its session](#trace-a-commit-back-to-its-session-with-entire-cli) below).
        - **Cursor hooks** receive agent events as JSON over stdio (verified 2026-08-28), so a hook can append events to a file your collector tails. Cursor's hooks page lists event names such as `sessionStart`, `preToolUse`, `postToolUse`, `beforeShellExecution`, `afterFileEdit`, `stop`, `subagentStart` and `subagentStop` (checked 2026-10-12); check it again before you build panels on them.

        For team usage and spend, Cursor has a Team/Enterprise analytics dashboard and Analytics API, and an AI Code Tracking API (Enterprise only, per its docs page, checked 2026-10-12) that maps AI-generated lines to commits (secondary: cursor.com docs seen only in search extracts; endpoints unverified). Check what your plan actually exports before you promise anyone a number.

3. **Prove data arrives.** Run one short session in each agent, then open Grafana at `http://localhost:3000`, go to **Explore**, pick the Prometheus data source, and run:

    ```promql
    {__name__=~"claude_code_session_count.*|codex_thread_started.*"}
    ```

    You should see one series per session start within about 10 seconds for Claude Code. Dots in OpenTelemetry names become underscores in Prometheus, and Prometheus can append a unit or `_total` suffix, which is why every query here matches on a name prefix. For events, pick the Loki data source and search for `user_prompt`. If nothing arrives, run `claude --debug-file /tmp/claude-otel.log` and search that file for `[3P telemetry]`; lines tagged `[Anthropic telemetry]` are Anthropic's own operational telemetry and do not indicate a problem.

4. **Build the six Claude Code panels.** Create a dashboard with one panel per query, each over a 7-day range:

    ```promql
    # Cost by model (USD, client-side estimate)
    sum by (model) (increase({__name__=~"claude_code_cost_usage.*"}[7d]))

    # Tokens by type: input, output, cacheRead, cacheCreation
    sum by (type) (increase({__name__=~"claude_code_token_usage.*"}[7d]))

    # Active users (count only; never chart per person)
    count(count by (user_email) (increase({__name__=~"claude_code_session_count.*"}[7d]) > 0))

    # Sessions by start type: fresh, resume, continue, agents_view
    sum by (start_type) (increase({__name__=~"claude_code_session_count.*"}[7d]))

    # Edit accept rate: Edit, Write, NotebookEdit decisions
    sum(increase({__name__=~"claude_code_code_edit_tool_decision.*", decision="accept"}[7d]))
      / sum(increase({__name__=~"claude_code_code_edit_tool_decision.*"}[7d]))

    # Commits and pull requests the agent created
    sum(increase({__name__=~"claude_code_commit_count.*|claude_code_pull_request_count.*"}[7d]))
    ```

    The accept-rate panel counts every decision, including edits that settings, the permission mode or a hook accepted without a person (`source="config"` or `source="hook"`), so in permissive modes it drifts toward 100%. For a human accept rate, add `source=~"user_.*"` to both the numerator and the denominator.

    With per-session series, `increase()` misses each series' first sample, so short sessions undercount. For totals you reconcile against the invoice, use `sum by (model) (max_over_time({__name__=~"claude_code_cost_usage.*"}[7d]))`, or set `OTEL_METRICS_INCLUDE_SESSION_ID=false` for dashboard metrics.

    If a label such as `user_email` is missing, open the metric in Explore and use the label name your stack shows. Add Codex panels the same way once `codex_` series appear.

5. **Move from laptop to team.** When the panels answer real questions, replace the container with a production collector and push the Claude Code variables through [managed settings](/en/org/managed-policy/), which override developer-set exporter variables. For a rotating collector token, point `otelHeadersHelper` in settings at a script that prints the headers as JSON; Claude Code reruns it every 29 minutes by default. The production pipeline (pseudonymized analytics stream, identified audit stream, retention) is on the [agent observability page](/en/workflows/operate/agent-observability/).

Two open reference stacks save you the dashboard work if you want more than six panels. As of 2026-09-26 (GitHub stars, read through the GitHub API for the site's research catalogue): `ColeMurray/claude-code-otel` (506 stars) is a Docker Compose stack of collector, Prometheus, Loki and Grafana with prebuilt cost, tool, user and session dashboards (`make up`); `anthropics/claude-code-monitoring-guide` (370 stars) is Anthropic's ROI guide with a `docker-compose.yml`, `otel-collector-config.yaml`, Grafana dashboards and a report-generation prompt. Neither covers Codex.

**What telemetry costs in context**

OpenTelemetry export is configured through environment variables and `config.toml`, so it adds no tokens to the agent's context. If you connect the agent to Grafana through the Grafana MCP server (`uvx mcp-grafana`, covered on the [observability MCP page](/en/ecosystem/mcp/observability-mcp/)), its tool schemas do sit in context: run `/context` in Claude Code before and after adding it.

## Trace a commit back to its session with Entire CLI

Metrics tell you that 40 commits came from agent sessions last week. They do not tell you why a specific line in `billing/retry.ts` looks the way it does. Entire CLI (Entire Inc., MIT, `entireio/cli`) fills that gap: it installs git hooks plus per-agent hooks, captures prompts, transcript, tool calls, files touched and token usage while the agent works, and on commit condenses them into a checkpoint linked by an `Entire-Checkpoint: <id>` commit trailer. Entire never creates commits on your branch.

Popularity as of 2026-09-26: 5.1k GitHub stars; latest stable v0.11.3, published 2026-09-25 (GitHub API and releases page). It is a Go binary; the npm package `entire` is an unrelated project.

**Claude Code**

    ```bash
    brew install --cask entireio/tap/entire
    cd your-project
    entire enable --agent claude-code   # hooks land in .claude/settings.json
    entire status
    ```

**Codex**

    ```bash
    brew install --cask entireio/tap/entire
    cd your-project
    entire enable --agent codex         # hooks land in .codex/hooks.json
    entire status
    ```

**Cursor**

    ```bash
    brew install --cask entireio/tap/entire
    cd your-project
    entire enable --agent cursor        # hooks land in .cursor/hooks.json
    entire status
    ```

Add a second agent later with `entire agent add codex`. Team settings go in `.entire/settings.json`; personal overrides go in the gitignored `.entire/settings.local.json`. Other install routes in the README are an install script, Scoop on Windows and `go install`.

Reviewing an agent-written pull request then looks like this:

```bash
git log -1 --format=%B                        # message ends with: Entire-Checkpoint: <id>
entire checkpoint explain <CHECKPOINT_ID>     # prompts, transcript, files touched, tokens
entire search "rate limiter retry"            # search across checkpoints, commits and sessions
```

`CHECKPOINT_ID` is the value after `Entire-Checkpoint:` in the commit message. Checkpoints are stored as git refs under `refs/entire/checkpoints/` and pushed with your normal `git push`; the older single `entire/checkpoints/v1` branch is the legacy backend.

**Entire stores transcripts in your repository**

Anyone who can read the repository can read the checkpoints. Secret redaction runs before a checkpoint is written but is best effort, and the short-lived shadow branches hold raw working-tree snapshots that must never be pushed by hand. On a public repository, send checkpoints to a private one with `entire enable --checkpoint-remote github:your-org/checkpoints`. Entire sends anonymous usage telemetry to PostHog by default; turn it off with `--telemetry=false`.

## Run the monthly adoption review: usage, attribution, outcomes

Telemetry pays off only when it feeds a decision. The review below runs monthly and is owned by the tech lead. It follows the utilization, impact and cost split that DX's AI Measurement Framework uses (secondary: DX research page seen in a search extract), with the metric definitions from the site's [metrics frameworks page](/en/org/metrics-frameworks/).

1. **Usage: who uses which agent, on which models, at what cost.** Pull active users, sessions and cost by model from the Grafana panels (Claude Code and Codex) and from the vendor dashboards (all three tools). Compare active users with paid seats. Report cost by model and by repository, never by person.

2. **Attribution: which merged changes involved an agent.** Combine three sources, strongest first: your own `agent-assisted` pull request label or template checkbox, the `claude-code-assisted` label from the Claude Code dashboard, and `Entire-Checkpoint` trailers in merged commits. A pull request with any of them counts as agent-assisted. The vendor label alone undercounts, because it ignores Codex and Cursor and is deliberately conservative.

3. **Outcomes: did those changes survive.** For the agent-assisted cohort and the rest, compute accepted change rate, 14-day follow-up fix rate and review time, as defined on the metrics page. Divide the month's agent spend (seats plus usage) by accepted agent-assisted changes to get cost per accepted change.

4. **Decide and record.** Pick at most two changes for next month (a model switch, a context file fix, a training session for a repository with low adoption) and write down which number should move. The tech lead signs off the review; the next review checks whether the number moved.

**Copy-paste prompt: set up and verify local agent telemetry**

```text
Set up local OpenTelemetry for my coding agents and prove it works. Do not change any repository files.

1. Check whether Docker is running. Start grafana/otel-lgtm with ports 3000, 4317, 4318 and 9090 published, container name lgtm.
2. Print the shell exports I need for Claude Code: CLAUDE_CODE_ENABLE_TELEMETRY=1, OTLP metrics and logs exporters, protocol grpc, endpoint http://localhost:4317, cumulative metrics temporality, a 10-second metric interval, OTEL_METRICS_INCLUDE_REPOSITORY=true. Keep prompt, tool-detail and response logging off.
3. Show the [otel] block for ~/.codex/config.toml with exporter, trace_exporter and metrics_exporter all set to otlp-grpc at http://localhost:4317. If ~/.codex/config.toml already has an [otel] table, show a diff instead of overwriting it.
4. After I run one session in each agent, query Prometheus at http://localhost:9090/api/v1/label/__name__/values and list every metric name starting with claude_code_ or codex_.
5. If a list is empty, tell me the most likely cause from this checklist: missing protocol variable, exporter variables placed in project settings, metrics_exporter left at its default, wrong port.
```

**Copy-paste prompt: draft the monthly agent adoption review**

```text
Draft this month's agent adoption review for the repository in the current directory. Read-only: use gh and the Prometheus HTTP API at http://localhost:9090 only, and write nothing to GitHub.

Usage: from Prometheus, report 30-day increase of claude_code cost by model, token usage by type, distinct active users (a count only) and sessions. List any codex_ metrics present with their 30-day totals.

Attribution: list merged PRs from the last 30 days. Mark a PR agent-assisted if it has the label agent-assisted or claude-code-assisted, or if any of its commits has an Entire-Checkpoint trailer. Report counts per source and the combined cohort size.

Outcomes: for the agent-assisted cohort and the others, compute median time from open to merge, and the share of PRs reverted or referenced by a later PR whose title starts with "fix" within 14 days. Mark each heuristic.

Output one Markdown page: a table per section, three observations, and two proposed changes for next month with the number each should move. Never report any metric per individual engineer. Before finishing, spot-check five PRs by hand against your cohort assignment and show the comparison.
```

**Copy-paste prompt: explain an agent-written commit**

```text
Explain why the most recent commit that touched src/billing/retry.ts was written the way it was.

1. Find the commit with git log -1 -- src/billing/retry.ts and read its message.
2. If it has an Entire-Checkpoint trailer, run entire checkpoint explain on that id and summarise: the original prompt, what the agent tried first, which tests it ran, and anything it left open.
3. If there is no trailer, say so, and fall back to the pull request description and review comments through gh pr list --search <sha> --state merged.
4. End with one sentence: is the current behaviour intended by the prompt, or an agent side effect that needs a test?
```

## How do you know the telemetry numbers are right?

A dashboard nobody has checked is an opinion. Verify it once when you set it up, then monthly, without reading any agent diff:

- **Reconcile cost with the invoice.** `claude_code.cost.usage` and `codex.turn.cost_microusd` are computed on the client, and the Console states that its own spend figures are estimates. Compare the month's telemetry total with the invoice; the invoice is the number you report, and telemetry is the breakdown.
- **Smoke-test every machine image.** One session per laptop image and CI image, followed by the step 3 query. A CI image without the variables is a silent hole in every total.
- **Spot-check attribution.** Take five merged pull requests: confirm each label or Entire trailer against the session that produced it. Record the error rate on the review page.
- **Alert on silence.** A Grafana alert on "no `claude_code_session_count` data for 24 hours on a working day" catches a broken exporter before the monthly review does.
- **Keep identity out of analytics.** The review counts users; it never ranks them. The [career ladders page](/en/org/career-ladders/) explains why per-person token or PR counts turn into targets people game.

**Traps: telemetry settings that look right and are not**

- `CLAUDE_CODE_TELEMETRY=1` does nothing; the variable is `CLAUDE_CODE_ENABLE_TELEMETRY=1`, and nothing is exported until `OTEL_METRICS_EXPORTER` or `OTEL_LOGS_EXPORTER` is set.
- Exporter variables in a repository's `.claude/settings.json` are ignored by design.
- `/cost` is not a separate command; it is an alias of `/usage`, as is `/stats`.
- The Claude Code dashboard has no per-user cost view; use OpenTelemetry or the spend report.
- Codex `metrics_exporter` left unset means `statsig` in 0.157.1, not "off".
- A typo in a Codex `[otel]` key name does not error in 0.157.1; the exporter just stays at its default.
- `npm i entire` installs an unrelated package; Entire CLI is the Homebrew cask `entireio/tap/entire`.
- `grafana/otel-lgtm` is a development image; do not make it the team's system of record.

## What breaks when you collect agent telemetry, and how to recover

**Claude Code runs but no metrics arrive.** The usual cause is a missing `OTEL_EXPORTER_OTLP_PROTOCOL` or variables placed in project settings. Recovery: set the protocol, move the variables to the shell, user settings or managed settings, and check the debug file for `[3P telemetry]` errors.

**Metrics arrive but the panels stay empty or jump.** Delta temporality against a cumulative backend. Recovery: set `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE=cumulative` and restart the session.

**Codex telemetry is missing.** Either a key name is misspelled (Codex ignores it silently) or `[otel]` sits in another `CODEX_HOME` than the one the session reads. Recovery: confirm `CODEX_HOME`, then diff your keys against `exporter`, `trace_exporter` and `metrics_exporter`. A reported issue (openai/codex#12913, status unverified on 0.157.1) says `codex exec` emits no OpenTelemetry metrics, so confirm headless runs separately before you build panels on them.

**Prometheus storage grows fast.** `session.id` is on every Claude Code metric by default, so each session is a new series. Recovery: in a large team, set `OTEL_METRICS_INCLUDE_SESSION_ID=false` and keep session IDs on log events, where cardinality is cheap.

**The adoption review shows Claude Code winning and Codex invisible.** The vendor label only credits Claude Code, and Codex 0.157.1 emits no commit metric. Recovery: attribute through your own `agent-assisted` label and Entire trailers, which cover all three tools.

**A secret appears in the log store.** Someone turned on `OTEL_LOG_TOOL_DETAILS` or `OTEL_LOG_USER_PROMPTS`. Recovery: rotate the secret, purge the records, and route content only to the audit pipeline described on the [agent observability page](/en/workflows/operate/agent-observability/).

**PR attribution disappears after a contract change.** Zero Data Retention switches contribution metrics off. Recovery: keep your own label and Entire trailers as the primary attribution, so the review does not depend on one vendor feature.

## Where to go next with agent telemetry

- [Measuring agentic engineering](/en/ecosystem/observability/) — The overview of telemetry, cost, review, security and eval tools, and what to switch on first.
- [Observing the agents](/en/workflows/operate/agent-observability/) — The production pipeline: collector with split streams, join keys to pull requests, audit retention.
- [Metrics frameworks](/en/org/metrics-frameworks/) — Canonical definitions of accepted change rate, follow-up fix rate and cost per accepted change.
- [What did the agents cost?](/en/ecosystem/observability/agent-cost-tracking/) — ccusage, /usage and gateway budgets for per-developer and per-team spend.
- [Observability MCP servers](/en/ecosystem/mcp/observability-mcp/) — Let the agent query Grafana, Sentry, Datadog and PostHog read-only.
- [The evidence bundle](/en/workflows/ship/evidence-bundle/) — The pull request contract whose provenance fields carry the session ID.
- [Privacy and data handling](/en/org/privacy-data-handling/) — Vendor data terms, Zero Data Retention and what telemetry may contain.
