One developer starts Claude Code in the morning, Codex CLI after lunch and Gemini CLI at night. Nobody can say what those sessions cost, or why one of them ran for twenty minutes. AI Observer coding assistants support is the answer the open source repository tobilg/ai-observer offers: a local observability backend that receives their telemetry and shows it in a dashboard.

I start from an operations decision rather than from the tool: should this telemetry go to a company platform, or stay on the developer’s machine? Then I cover what the project offers, how to run it and, above all, how to protect it. Everything comes from the repository and its README, read on 9 November 2026. I have not installed the tool myself, so the screenshots below come from the repository.

The problem: assistant sessions nobody measures

A coding assistant burns tokens, calls tools and sometimes fails quietly. Without measurement, you find the spend on the provider’s invoice. For a platform team the question has two parts: what do you want to know (cost, latency, errors) and where should the data live?

This telemetry often contains prompts, code and tool output. For a solo developer or a small team, keeping it local avoids building a pipeline. For a whole fleet, a centralised approach fits better. AI Observer clearly targets the first case.

AI Observer: what it is, according to the repository

The project describes itself as a self-hosted, single-binary, OpenTelemetry-compatible observability backend. It targets Claude Code, Gemini CLI, OpenAI Codex CLI, GitHub Copilot and OpenCode. Facts read on the repository on 9 November 2026:

  • MIT licence (the repository’s LICENSE file);
  • about 291 stars and 26 forks shown on the GitHub page that day;
  • latest commit on 6 November 2026, which ships version 0.7.0 (MCP server, price updates, fixes); the v0.7.0 tag exists, but the GitHub page listed no formal release;
  • storage in DuckDB, OTLP ingestion over HTTP/JSON and HTTP/Protobuf, dashboard updates over WebSocket;
  • a binary of about 54 MB with the interface embedded, and a Docker image advertised at about 97 MB for linux/amd64 and linux/arm64 (README figures, not measured here).

The project is young and driven by one main author. For a convenience tool on a laptop that is acceptable. For anything critical, weigh that risk first.

The dashboard in pictures

The README’s « All Tools » dashboard gathers totals (traces, logs, metrics, error rate), then cost, active time and tokens per tool.

AI Observer All Tools dashboard with traces, logs, metrics, cost and token usage per tool

Source : github.com

The Traces view shows a task’s span tree. In the README capture, a Codex CLI task of 371 spans shows reasoning and function-call steps with their durations.

AI Observer Traces view: span tree of a Codex CLI task with the duration of each step

Source : github.com

Running AI Observer coding assistants step by step

The README recommends Docker. Both ports are published on 127.0.0.1 only, which is the right default, and a volume keeps the database.

  1. Start the container:

    docker run -d \ -p 127.0.0.1:8080:8080 \ -p 127.0.0.1:4318:4318 \ -v ai-observer-data:/app/data \ --name ai-observer \ tobilg/ai-observer:latest

  2. Open http://localhost:8080: the dashboard waits for data. Port 8080 serves the interface and the API, and 4318 receives OTLP.

  3. For Claude Code, the README asks for these environment variables, to go in your shell profile:

    export CLAUDE_CODE_ENABLE_TELEMETRY=1 export OTEL_METRICS_EXPORTER=otlp export OTEL_LOGS_EXPORTER=otlp export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318

  4. Restart the assistant, run a session, then watch the counters climb.

Terminal showing the AI Observer docker run command and the OTEL variables for Claude Code, taken from the README

Source : github.com

Without Docker, the README also lists Homebrew (Apple Silicon macOS), a binary from the Releases page, or a build with make setup then make all. I have not checked those routes.

No OTLP exporter needed: watch mode

For Claude Code, Codex CLI and Gemini CLI, the ai-observer watch command reads the local session files and imports them as they grow. On first start it only records the current position; the --backfill option loads the history. The import command does the same in one pass, and export writes Parquet files.

One documented trap: watch and serve (OTLP ingestion) are mutually exclusive, or you get duplicate data. GitHub Copilot and OpenCode only work through OTLP.

Security: the real operations decision

The README is blunt: AI Observer has no authentication by default, and the database can hold prompts, code and tool output. The binary therefore listens on 127.0.0.1. Beyond that, the project describes:

  • a shared token, AI_OBSERVER_AUTH_TOKEN, required on OTLP and the API;
  • Host and origin checks, against DNS rebinding and web pages writing fake telemetry;
  • redaction before storage, AI_OBSERVER_REDACT, which replaces secrets (API keys, tokens, passwords) by default; all adds personal data;
  • retention, AI_OBSERVER_RETENTION_DAYS, which deletes older data;
  • an optional MCP endpoint, off by default, that lets an agent search your past conversations. What it returns goes to the model provider, so enable it knowingly.

I have not audited these protections. Do not take them for granted: test them on your own data.

Going further

AI Observer stays a workstation tool. To correlate these signals with the rest of production, see tracking agent cost with OpenTelemetry or shipping AI traces to a platform with OpenInference and the Collector. On the open source storage side, OpenObserve plays in a broader field.

Limits and open questions

  • Recent project, one apparent maintainer: read the release notes before upgrading.
  • No authentication by default; never expose it to the network without a token and HTTPS.
  • Prices are embedded in the binary, so a displayed cost remains an estimate to reconcile with the invoice.
  • No independent performance study is cited here.

Best practices

  • Publish ports on 127.0.0.1 and keep the database in a named volume.
  • Leave redaction on and set a short retention.
  • Pick one mode, watch or serve, per database.
  • Reconcile the displayed cost with the invoice once a month.

Frequently asked questions

Does AI Observer send my data to a third party?

The README presents it as local, with no external service required. The only exit is one you enable yourself, such as the MCP endpoint towards an agent.

Which coding assistants does AI Observer support?

Claude Code, Gemini CLI, OpenAI Codex CLI, GitHub Copilot and OpenCode. The first three can also be read from files.

Can I deploy it for a whole team?

Technically yes, with a token, an allowed host name and HTTPS. The project aims at the local workstation first: for a fleet, a central platform is safer.

Conclusion

First decide where your assistants’ telemetry should live, then install AI Observer if the answer is « on the workstation ». Start with Docker, check that the counters move, and treat security as the core of the rollout. For what comes next, read the official repository and its CHANGELOG.

span.observer is an independent community blog, not affiliated with Dynatrace LLC. Brands mentioned belong to their owners. Tools change quickly: check commands and options in the project’s README.

Originally published on span.observer. French version: https://span.observer/fr/ai-observer-assistants-de-code-observabilite-locale/.