OpenClaw Ships Yet Another Release — How to Track Every Second of Its Spend in Real Time and Open the Agent "Thinking" Black Box
OpenClaw has shipped yet another release. This 2026.3.22-beta.1 version looks like a “complete overhaul”: major changes to the plugin system, a reworked SDK path, a rewritten messaging mechanism, a changed run mode, consolidated tool capabilities, and rebuilt browser and large-model strategies.
This update gives developers more power when building complex AI applications, but it also brings a new challenge: when multiple Agents run in parallel and tasks span several days, how do you precisely grasp the compute consumption and state changes at every stage?
From our small-scale survey, developers report these frustrations when running complex tasks with OpenClaw: a task suddenly slows down halfway through, but they can’t tell whether the model is thinking deeply or has stalled; at the end of the month they get an API bill far exceeding expectations but can’t trace the specific consumption; or worse, the context gets silently compacted, causing the Agent to “forget” key decisions and breaking task continuity.
This “black box” development experience is exactly the core pain point the new open-source tool ClawProbe sets out to solve. As a real-time monitoring tool designed specifically for OpenClaw, it lets developers precisely control every bit of compute spend amid today’s fierce model price war.
clawprobe doesn’t change your Agent logic and injects no performance overhead; it just silently reads OpenClaw’s local state files and uses a differential algorithm to compute everything you want to know in real time. It’s like running strace on the Agent, but the output is a human-readable dashboard.
This release is an internal beta: github.com/seekcontext/ClawProbe. We warmly invite you to try it, file PRs, or post suggestions in the “Q&A” board of the OceanBase community.
Two-Minute Onboarding: Even Simpler Than Configuring Prometheus
Don’t rush to set up a Grafana dashboard. For most OpenClaw users, deploying a full monitoring stack only adds complexity. clawprobe’s philosophy is: a monitoring tool itself should not become a new thing to monitor.
1 | npm install -g clawprobe |
No YAML config, no API key management, no Docker containers. The tool automatically probes the ~/.openclaw directory, watches session-file changes via fs.watch(), and uses under 30MB of memory. Node.js 22+’s native file system API ensures cross-platform efficiency, with latency under 100ms on macOS and Linux. As for Windows users, for now it runs perfectly only under WSL2.
Core Features: A Complete Toolchain from status to top
clawprobe status: The Agent’s “CT Scan Report”
This isn’t a simple status query but a complete data collection and analysis. The instant you run it, the tool will:
- Read the current session’s
session.jsonfor metadata - Parse
conversation.logto compute token throughput - Scan the
context/directory to estimate window usage - Query the built-in pricing database (auto-updated daily) to compute cost
- Run heuristic rules to detect anomalies
The output is a diagnostic report of extremely high information density:
1 | 📊 Agent Status (active session) |
Note the Compacts: 2: it tells you the context has been compacted twice, and part of the historical conversation has been lost. If you notice the Agent behaving oddly, this is usually the first clue.
clawprobe top: An htop Designed for Long-Horizon Tasks
When debugging Claude 3.7’s agentic tasks, you need to observe continuously. The top command provides a real-time dashboard with a 2-second refresh, drawing the live picture in ASCII characters:
1 | clawprobe top refreshing every 2s (q / Ctrl+C to quit) 03/18/2026 17:42:35 |
The key insight is in the Recent turns table: a compact happened at turn 23, and input surged by 20.4K tokens at turn 25. If the Agent behaves abnormally at this point, you’ll know it’s a context break caused by compaction. This replayable debugging ability is worth its weight in gold when troubleshooting in production.
clawprobe cost: A “Real-Time Audit” of the API Bill
Claude 3.7’s 200K context window is powerful, but both input and output are priced per 1M tokens. One careless move and a single day’s cost can exceed $50. The cost command offers multidimensional cost analysis:
1 | 💰 Weekly Cost 2026-03-12 – 2026-03-18 |
The built-in pricing database syncs daily from official APIs, covering 30+ models across OpenAI, Anthropic, Google, Moonshot, DeepSeek, and more. For privately deployed models, you can define custom pricing in ~/.clawprobe/models.json. We also plan to integrate the pricing-metadata standard of MCP (Model Context Protocol); once the protocol matures, we’ll enable automated model-cost discovery.
clawprobe context: Catching the Culprit Behind Silent Truncation
This is the most technically deep feature. When OpenClaw loads tool definitions, if TOOLS.md exceeds the bootstrapMaxChars limit, it silently truncates. The Agent can’t see the full tool description, which may cause call failures, but it won’t tell you “I can’t see this.”
1 | 🔍 Context Window agent: main |
clawprobe precisely computes the truncation ratio through static analysis of the injected files under the workspace/ directory. This check runs once at Agent startup and alerts immediately if truncation is found. Last week we just helped a user pinpoint the cause of Claude 3.7’s repeated call failures, his TOOLS.md was 40% truncated, and the model simply couldn’t see the key parameter definitions.
clawprobe compacts: Auditing Context “Forgetting” Events
Every compact is an instance of information loss. This feature lets you see the detailed medical record of the Agent’s “amnesia”:
1 | $ clawprobe compacts |
You can use --save to archive key conversations to ~/.clawprobe/archive/ for later recall via RAG in subsequent sessions. We’re experimenting with integration with vector memory libraries like mem0 to achieve automatic semantic archiving of compaction events.
Intelligent Suggestions: A Rule Engine, Not AI Alerts
The suggest command runs a set of hard-coded rules, avoiding the extra cost of LLM introspection:
- tools-truncation: detects tool-definition truncation
- high-compact-freq: more than 2 compactions within 30 minutes
- context-headroom: usage >90%
- cost-spike: today’s cost > 2x the weekly average
- memory-bloat: MEMORY.md >10K tokens
The rules file lives at ~/.clawprobe/rules.js and supports hot reload. You can define custom business rules in JavaScript, for example, “alert when dangerous_tool is called more than 5 times.” This is simpler than using PromQL and more reliable than LLM judgment.
Self-Monitoring: The Agent’s “Introspection” Ability
clawprobe’s most radical feature is support for Agent self-monitoring. Installed as a Skill, the Agent can read its own status --json output:
1 | { |
Based on this data, the Agent can:
- Proactively ask for user confirmation when cost is >$5
- Automatically start compaction when context is >80%
- Refuse to execute and report when a tool is truncated
This is the first step toward building self-aware Agents. The code is open-sourced in the skills/clawprobe directory; PRs to improve the decision logic are welcome.
Performance and Resources: Lighter Than a systemd Service
The clawprobe daemon is based on Node.js’s fs.watch() and setInterval(), with extremely low resource usage:
- CPU: <1% (triggered only on file changes)
- Memory: ~28MB (caches the last 1,000 conversation turns)
- Disk I/O: only reads OpenClaw logs, writes no temp files
- Network: zero traffic (except for pricing-database updates)
For comparison: to monitor OpenClaw with Prometheus + Grafana, you’d need to:
- Modify the OpenClaw source to inject metrics
- Deploy node-exporter
- Configure Prometheus scrape rules
- Design a Grafana dashboard
clawprobe solves this in 200 lines of code.
Open Source and the Future: A Community-Driven Roadmap
The project uses the MIT license, GitHub: github.com/seekcontext/ClawProbe. Everyone is welcome to try it, file PRs, or post suggestions in the “Q&A” board of the OceanBase community.
v1.2.0 will support:
- Multi-session monitoring: track multiple Agent instances at once
- WebSocket real-time push: for self-built dashboards to consume
- MCP protocol integration: fetch metadata from the Model Context Protocol
- Plugin system: support custom metric collection
We especially welcome two kinds of PRs:
- Adding new model pricing data (especially for privately deployed models)
- Optimizing the differential algorithm to lower CPU usage when parsing large files
A Final Thought: Transparency Is the Agent’s “Moral Foundation”
Frequently updated large models are pushing Agent capabilities to new heights, but the greater the capability, the greater the risk of losing control. An Agent that can autonomously call tools, read and write files, and consume resources is, without transparency, essentially a black-box process with unlimited permissions. The arrival of clawprobe isn’t just meeting a technical need; it’s an ethical requirement of AI engineering, any autonomous system must be observable, auditable, and constrainable.
Now, close that anxiety-inducing OpenClaw terminal and open a new tab:
1 | npm install -g clawprobe |
Let your little lobster swim in a glass tank, not struggle in ink. Transparency starts with this one command.
This Saturday (3.28), come to Zhongguancun for an on-site install party and hear frontline founders reveal their operating logic and profit models live (extremely high-value content!).
