nool code is not trying to be a better chat-with-tools loop than Claude Code. The difference is where the work goes when the model stops typing. In nool code, every change lands through a governed, replayable change system. Most of what matters to an enterprise comes from that, not from the terminal UI.
What the demo shows
The goal was to build charts and tables from Claude usage metrics. The agent wrote four files, an HTML dashboard, a Markdown report, a README and a test script, and then told us it was "Fully Complete and Committed."
Look at the side panel. It says check failed.
The work had reached main outside the session's try branch, so there was nothing left on the branch for Nool to checkpoint and verify. Nool did not take the model's word for it. The session stopped at 80% of a $2.00 budget, said exactly why it was blocked, and handed the decision to a person. The panel also shows that one secret was redacted before the model ever saw it.
That is the product. A harness that trusts the model's "done" would have reported success here.
The rest of the video tours the screens: Changes shows each file's diff with the checkpoint it belongs to, UML draws how the session's work is going to land, and the slash commands switch the approval mode, the model, the playbook and the goal mid-session.
What a developer gets that other harnesses do not
Agent work is isolated and leased before it starts. A session opens a try branch, declares its scope, and takes a lease on the files or symbols it will touch. Two agents, or an agent and a person, cannot silently overwrite each other. Conflict discovery and the fleet planner give each agent a separate footprint up front. In Claude Code, Codex and Cursor, agents share one working tree and find collisions after the fact.
Landing needs evidence, not the model saying "done". Each checkpoint is a nool propose that runs:
- a ghost run: the build plus the affected tests, in a private worktree;
- the policy gate and the blast-radius check;
- the task's acceptance criteria as a completion check, with a cited verdict.
A refusal names the failing tests. Other harnesses hand you a diff and wish you luck with CI.
The "why" survives. Intent, scope, test selection, savings, redactions, approvals, the landing packet (testing, risk areas, how to revert) and the attestation are signed knots, mirrored to git. nool why, nool debug blame and nool audit verify work on agent work exactly as they do on human work. The UML screen in the demo is drawn from those records. Nothing extra was instrumented for it.
Context comes from the repository, not grep. Outline and read-symbol tools, context queries by stable node id, test selection by dependency closure, and budgeted priming all come from the semantic graph. The Savings line in the side panel shows the measured effect: tokens avoided, tests skipped and validation reused.
Multi-agent is built in. nool code --fleet plans a goal into tasks that run as child sessions, each with its own worktree and lease, judged by a reviewer quorum and landed in dependency order behind one integrated check. In other tools, "subagents" means several processes in one tree with nothing coordinating them.
The trust surface is honest. Secrets are redacted before the model sees tool output. Read-deny lists, request_access grants (once, session or persistent) and a tool jail limit what the agent can touch. nool.toml stays editable, but an agent cannot switch verification off.
Why it matters to an enterprise
Admission control and provenance. Governance is policy as code: deterministic WASM policies, role-gated authority, signed receipts, and an audit you can verify from a fresh clone with nool audit verify. A compliance team can prove what an agent changed, under which approval and with which tests, without trusting a vendor's logs. See AI code governance.
The harness is portable. Swap models and providers freely: Anthropic, OpenAI, Google, Azure, xAI, Bedrock, Mistral, Cloudflare, OpenRouter and Ollama. Skills, hooks, plugins, agents and MCP servers use Claude Code's formats, so nothing you built for Claude Code is lost, and nothing ties you to one model vendor. The governance stays the same when the model changes.
Cost limits are enforced, not advisory. Budget, max rounds, doom-loop detection, classified retries and a runway figure stop a session before it burns money. Spend is attributed by purpose: main work, review, criteria checks and compaction. In the demo, the session warned at 80% of its budget and told the model to stop exploring.
It scales without a shared-tree free-for-all. The hub, leases and replication let many agents across a team or an organisation land into one history with deterministic convergence, and nothing lands outside the gate. We measured it: in a pre-registered benchmark with 35 agents and 60 tickets, the coordinated fleet landed with zero merge conflicts.
Try it
nool code "add rate limiting to the public API" # opens the TUI
nool code --exec "fix the flaky checkout test" --budget 2 # headless, for CI
nool code --fleet "split the billing module into services" # plan, run and land as a fleet--exec exits 0 only when the work is verified and landed, so CI can trust the exit code. The nool code docs cover providers, permissions, playbooks and hooks, and using nool code effectively covers goals, budgets and recovering a blocked session. To start, set Nool up on your repository; teams can compare plans and pricing.