Original article: Meterbility: The Open-Source Debugger That Lets You Pause, Rewind, and Fork AI Agent Runs
This is a cross-post of the original article on TekMag.
Meterbility is an open-source debugger for AI agents that lets developers pause, rewind, inject commands, and fork agent runs, bringing Chrome DevTools-style observability to tools like Claude Code, Cursor, and Codex CLI. For anyone who has watched an AI coding agent silently overwrite a critical file or spiral into a recursive bug-fix loop, the missing layer has always been inspection mid-flight. Standard logging captures what happened after the fact. Meterbility intercepts each step as it happens and stores it in a local SQLite database so you can rewind to any point, branch off into an alternate trajectory, or pause the agent and inject new instructions on the fly.
Key Takeaways:
- Meterbility v0.5 ships full-fidelity Bash capture. File changes made outside the agent are now observable too.
- Supports Claude Code, Codex CLI, Cursor, Anthropic and OpenAI proxies, plus TypeScript and Python SDKs for custom agents.
- The Live Probe feature lets you pause, inject, and resume agent execution at any step.
- Local-first storage at ~/.meterbility/meterbility.db means no cloud dependency or data leakage risk.
- Released under MIT (core) and Elastic License 2.0 (enterprise extras), with a Postgres backend option for team-scale operators.
Why AI Agents Need a Debugger Rather Than Just Logs
Traditional software debugging assumes determinism. Same input produces the same output along the same code path. As a GitHub topic listing positions the category, time-travel debuggers have long helped developers replay program execution step by step. AI coding agents break that assumption entirely. According to researchers at Augment Code in their 2026 survey of developer tooling, non-determinism persists even at temperature zero, meaning two identical prompts can produce completely different action sequences, and replaying the first request never reproduces the failure.
This is where Meterbility's value proposition becomes concrete. Rather than leaving developers to grep through scattered log files or transcripts, it captures every decision an agent makes. Model calls, tool invocations, file edits, shell commands, all stored in a structured, queryable format. A project with 83 commits across multiple branches and published npm and PyPI packages represents active development, not a prototype. According to the project's own documentation, version 0.5 marks the first release with full Bash-side-effect capture, meaning file modifications made by scripts or shell commands outside the agent's direct knowledge now land as structured rows in the inspector.
How Meterbility Works and the Five-Panel Mental Model
Meterbility maps the browser DevTools metaphor directly onto agent debugging, borrowing from an interface designers already know intuitively. The project defines five panels, each corresponding to a different dimension of agent behavior. The Elements panel shows the agent's resolved context. What files, variables, and environment state it sees at any given moment. The Sources panel acts as the step inspector where you can fork a run into an alternate trajectory. The Network panel exposes input and output for every tool call. The Performance panel renders a cost, token, and latency timeline. And the Console panel houses the Live Probe operator surface for real-time pause, inject, and resume.
Installation takes roughly ten seconds for a working inspector. Run npm install -g @meterbility/cli followed by meter doctor to verify the connection surface, then meter ingest claude-code --limit 5 to pull your last five runs into the local database. From there, meter list shows all captured sessions and meter web launches a local web UI at http://127.0.0.1:4317. According to the README documentation, this flow works on any machine running Node 24+ without additional server configuration.
The Python SDK counterpart, available on PyPI as meterbility-agent, follows the same pattern. One pip install and any Python LLM agent can be instrumented to capture one Step per model call, writing directly into the same local SQLite store. Sessions appear instantly in meter list and the web UI without a separate ingestion step.
Live Probe and Mid-Run Intervention
The most immediately useful feature is Live Probe, which lets you halt an agent at any step, inspect its current state, inject arbitrary instructions, and resume. Think of it as pressing pause during a Git rebase, making a manual edit, and continuing. For an agent that has started down a wrong path, this eliminates the need to abort and restart from scratch.
According to the official README, Live Probe support spans both the TypeScript and Python SDKs and is available through the meter probe CLI and the web panel. The companion spool system at github.com/HoneycombHairDevelopers/Spool provides the underlying message queue that makes this interrupt-and-resume pattern possible without dropping in-flight steps.
What Has Shipped and What Is Coming
Meterbility v0.5 has already delivered several foundational features. The agent adapter support table confirmed in the project's README shows capture is fully operational for Claude Code, Codex, Cursor, Anthropic proxies, OpenAI proxies, and Bash side-effects. Markdown-aware pretty printing in both the CLI and web step cards detects markdown in messages, thinking blocks, tool results, and decisions, rendering headings, bold, code, lists, and links in place rather than showing raw text.
Security-conscious teams will note that credential store writes are tracked but never stored verbatim. According to the project's changelog notes, file edits to .env, SSH keys, and credential stores record the metadata of the change, including the path, operation type, and size, but never the contents themselves.
Roadmap items visible in the repository include adapters for LangChain and the Vercel AI SDK, with a team tier reserved for the enterprise-licensed extension under Elastic License 2.0. A Postgres backend for multi-machine operator setups sits alongside the default local-first SQLite approach.
| Feature | Status | Details |
|---|---|---|
| Claude Code adapter | Shipped (v0.4) | Diffs in Files tab; Live Probe pause/inject/resume |
| Codex CLI / Cursor adapters | Shipped (v0.4 to v0.5) | Step capture + file change tracking |
| Anthropic / OpenAI proxy passthrough | Shipped | Agent-agnostic via proxy mode |
| Bash side-effect capture | Shipped (v0.5) | Full-fidelity FileChange rows for shell ops |
| Markdown-aware pretty printing | Shipped (v0.5) | CLI and web UI step cards |
| Python SDK (pip) | Shipped | Captures one Step per model call |
| TypeScript SDK (npm) | Shipped | Instrument custom agents programmatically |
| LangChain / Vercel AI SDK | Roadmap | Adapters in progress |
| Postgres backend | Enterprise (EE) | Multi-machine operator deployments |
How It Compares to Existing Observability Tools
The AI agent observability space is crowded. Tools like Langfuse, Arize Phoenix, and Galileo provide cloud-based tracing, dashboards, and eval harnesses for LLM applications. Meterbility takes a fundamentally different approach. It is local-first, terminal-native, and built around the specific workflow of debugging agent runs inside an IDE or session rather than monitoring production inference pipelines.
According to editorial coverage cited by Braintrust in their 2026 roundup of AI agent debugging tools, Meterbility fills a gap between basic transcript logging and heavy enterprise observability platforms. Where Langfuse asks you to instrument your application code and send traces to a hosted backend, Meterbility attaches to existing agent sessions without modification. It reads what the agent is already doing.
For developers already deep in the Claude Code or Cursor ecosystem, this distinction matters. AgentBox, another project TekMag has covered, focuses on sandboxing parallel agent workflows. CalcFleet tackles deterministic, verifiable math in agent outputs. Meterbility doesn't try to solve either of those problems. It answers a narrower question: what did my agent actually do, and can I see it before it finishes?
Who Should Use Meterbility
The primary audience is developers who run AI coding agents interactively, using Claude Code, Cursor Composer, or Codex CLI for extended tasks like feature implementation, refactoring, or integration work. If you have ever lost hours watching an agent slowly degrade a codebase because it misunderstood an earlier instruction, the ability to rewind and fork that exact trajectory at the point of divergence saves time you could not otherwise recover. For context on how deep this ecosystem runs, projects like Moonshot AI's Kimi Work already manage hundreds of concurrent sub-agents on a single desktop.
Secondary users include security and compliance teams evaluating external-facing AI agents, where understanding exactly what credentials, keys, or secrets an agent touches without storing those secrets in the tool itself provides auditability without exposure. According to the project's security policy page, Meterbility includes a formal SECURITY.md and contributes through standard vulnerability reporting channels.
Meterbility does not replace dedicated observability platforms for production LLM systems. If you need distributed tracing across hundreds of microservices, automated eval pipelines, or managed dashboards for client-facing AI products, tools like Langfuse or Arize Phoenix remain the right choice. The single-developer debugging workflow tells a different story. According to Agentic.ai's 2026 coding agent report, most developers still run agents locally through a single session. For that use case, Meterbility offers something heavier platforms cannot: instantaneous inspection at the speed of thought.
Getting Started
Setting up requires only Node.js 24+, no Docker containers, no API keys, and no cloud accounts. The core CLI installs globally via npm, and verification is a single command (meter doctor). For developers interested in instrumenting their own agents, the TypeScript SDK (npm install @meterbility/agent) and Python SDK (pip install meterbility-agent) provide clean API surfaces. All data remains on your machine in ~/.meterbility/meterbility.db unless explicitly exported. Teams that prefer open-source terminal agents will find parallels with xAI's Grok Build, which also prioritizes local-first execution over cloud-hosted pipelines.
The project is also listed on BetaList as an emerging startup, which signals early-stage community momentum behind the tool.
Conclusion
Meterbility addresses a clear gap in the AI agent toolchain: the inability to inspect, pause, and redirect an agent's reasoning in real time. By borrowing the familiar DevTools metaphor and keeping everything local and open-source, it offers a lightweight alternative to heavyweight observability platforms for the developers who need it most. The v0.5 release with Bash capture and markdown-aware rendering demonstrates a mature foundation, and the roadmap suggests steady expansion into the broader LLM framework ecosystem.
Frequently Asked Questions
Is Meterbility free to use?
Yes, the core Meterbility CLI and SDK are released under the MIT license, which allows free use, modification, and distribution. An enterprise edition (ELv2) adds team-tier features like the Postgres backend for multi-machine operator deployments.
Which AI coding agents does Meterbility support?
Meterbility currently supports Claude Code, Codex CLI, Cursor, and both Anthropic and OpenAI proxy connections. The TypeScript and Python SDKs allow developers to instrument custom agents beyond these built-in adapters. LangChain and Vercel AI SDK adapters are listed on the public roadmap.
Where does Meterbility store captured data?
All data is stored locally in an SQLite database at ~/.meterbility/meterbility.db by default. This means no cloud dependency and no data leaves your machine. Enterprise deployments can opt for a Postgres backend for multi-machine setups.
References
- HoneycombHairDevelopers, Meterbility GitHub repository, primary project page, source code, and release history.
- HoneycombHairDevelopers, Meterbility README documentation, install instructions, adapter matrix, and feature status table.
- meterbility-agent · PyPI, Python SDK package listing and installation details.
- time-travel-debugger · GitHub Topics, category placement alongside related tools.
- HoneycombHairDevelopers/Spool, companion message queue repository.
- Braintrust in their 2026 roundup of AI agent debugging tools, editorial roundup placement.
- Augment Code in their 2026 survey of developer tooling, market analysis of the observability landscape.
Top comments (0)