Nool is designed to sit beside the tools developers already use. Claude Code can run terminal tasks. Cursor can handle IDE-native authoring. Codex can inspect and edit a repository. Git can transport source. Nool governs the transition around all of them.
That matters more as agent tooling moves upmarket. Anthropic documents Claude Code access through Pro and Max plans, and the Max plan is explicitly priced for heavier usage at $100 or $200 per month on its support page. If a premium agent session spends its first ten minutes rediscovering what the last premium agent session already learned, the workflow is leaking money.
flowchart TD
A[Human task] --> B[nool task pick]
B --> C[nool announce intent]
C --> D{Implementation tool}
D --> E[Claude Code]
D --> F[Cursor]
D --> G[Codex]
E --> H[nool learn]
F --> H
G --> H
H --> I[nool debug blast-radius]
I --> J[nool propose]
J --> K[nool solidify]
K --> L[Git-compatible history]
A simple workflow starts with `nool status --compact`, then `nool task pick --id <id> --solidify`. If the work is part of a multi-session effort, inspect or create a thread with `nool thread list --compact`, `nool thread create --name ...`, and `nool thread show <name> --full`.
Use the agent you like for implementation. During the run, store reusable lessons with `nool learn --about <subject> --kind finding --content "..."`. Before accepting the result, run `nool debug blast-radius <path> --compact`. Then bind the change to intent with `nool propose --all --intent "..." --fast` and seal it with `nool solidify --fast` or `nool solidify --full`.
The point is not tool tribalism. The point is continuity. Agents can change. Pricing can change. IDEs can change. The repository still needs a durable, queryable memory of why it evolved.
This is also a hedge against vendor churn. If one agent becomes too expensive, too rate-limited, or simply less useful for a task, another agent can take over from Nool state. The handoff does not depend on one vendor's chat transcript. It depends on tasks, threads, findings, blast-radius checks, and solidified transitions that live with the repository workflow.
That is the quiet advantage of Git-compatible governance: the AI tool can be swapped, but the operational record remains. Teams should own that record.