Latitude

What is Latitude?

Latitude is an open-source AI agent observability and monitoring platform designed to monitor every step made by Claude Code. It captures detailed traces of an agent session—such as prompts, tool calls, command output, and files touched—so teams can understand failures in production and verify that fixes worked.

The core purpose of Latitude is to make agent behavior observable end-to-end. It helps you detect possible issues, investigate what actually happened during a session, and track session-level costs and usage.

Key Features

• Session traces for each turn: Latitude records what Claude Code runs during a session, including the prompts involved in each step, tool calls, Bash output, and the files the agent touched.
• Runtime capture of system prompt and tool schemas: Traces include the real system prompt and the tool schemas Claude Code composes at runtime, not just what you expected to be sent.
• Failure detection and issue monitoring: The platform surfaces monitoring signals for what fails in production so you can investigate underlying issues.
• Cost per session visibility: You can view cost at the prompt, session, and workspace levels, based on the captured session activity.
• Usage statistics and expense regulation: Latitude tracks token usage to help regulate expenses over time.
• Live traffic capture for evaluation: It can capture real inputs, outputs, and context from live traffic to support failure discovery, eval-style analysis, and human feedback workflows.

How to Use Latitude

1. Install the telemetry locally: Run the provided command to install Latitude telemetry for Claude Code (the site shows an npx -y @latitude-data/claude-code-telemetry install command).
2. Set up the hook/preload and agent launcher: The installer configures a hook, preload, and a launchctl .plist as part of setting up monitoring on your machine.
3. Create a free Latitude account: Sign up to Latitude to monitor agent behavior across projects.
4. Start monitoring and review traces: Once set up, use the traces and monitoring views to inspect turns, tool calls, outputs, and related files, and to track usage and costs.

Use Cases

• Debugging an agent failure in production: When Claude Code fails, use Latitude’s captured traces (prompts, tool calls, Bash output, and touched files) to identify what went wrong during the specific session.
• Verifying that a fix worked: After changes to prompting, tools, or workflows, compare the resulting session traces to confirm the new system prompt/tool schemas and the subsequent tool calls behaved as intended.
• Auditing what the agent actually did: Investigate compliance- or safety-adjacent concerns by reviewing the precise files the agent touched and the exact command outputs recorded for each turn.
• Managing token spend: Use cost-per-session visibility and token usage statistics to understand what each task costs at prompt/session/workspace levels and to regulate expenses.
• Building evals from real traffic: Capture real inputs, outputs, and context from live sessions to support human feedback, failure discovery, and evaluation workflows.

FAQ

Is Latitude specific to Claude Code? Latitude is described as monitoring Claude Code behavior, including the system prompt and tool schemas it composes at runtime.

What data does Latitude collect during a session? The page states it captures prompts, tool calls, Bash output, and files the agent touched, and also records the system prompt and tool schemas that are used at runtime.

How do I start monitoring? The site indicates you install Latitude telemetry locally using an npx installer command, then sign up to Latitude to monitor behavior across projects.

Does Latitude provide cost visibility? Yes. It lists “Cost per session,” with visibility described at the per-prompt, per-session, and per-workspace levels.

Does Latitude support evaluation and feedback workflows? The page mentions capturing real inputs/outputs/context from live traffic to support “human feedback,” “Failure discovery,” “Playground,” and “Evals.”

Alternatives

• OpenTelemetry-based instrumentation for LLM apps: If you want an observability stack centered on OpenTelemetry, you may build custom traces around your agent runs. Latitude positions itself as an agent-focused observability layer for Claude Code behavior.
• General application monitoring (logs/metrics/traces): Tools focused on system health (logs/metrics/APM) can help detect failures, but they may not capture agent-specific context like system prompts, tool schemas, and per-turn tool call details.
• Agent evaluation frameworks: Evaluation-focused tools can help test prompts and agent behavior against datasets, but they often require synthetic inputs; Latitude emphasizes capturing from live traffic for real inputs and outputs.