Four pillars
Coordinator
A single point of work distribution. Goals enter in one place, tasks go to the right workers with deadlines. Nobody grabs work out of thin air — which is also why nobody duplicates it.
CROWN — producer always has a verifier
Whoever produces cannot declare their own work verified. Every producer is permanently paired with a verifier on a different AI model — a different engine has different blind spots. Work without a verdict does not move forward.
SCOPE — a task list, not a role
Every agent has a closed list of duties: what it does and what it does not do. Agents reject and report out-of-scope tasks instead of improvising. Zero drift, zero stepping on each other's work.
GATE — irreversible only with operator consent
Three action classes: reversible (agent just does it), irreversible (publishing, deletion — one-time token from the operator only), prohibited (always refused). Every gate decision lands in a ledger.
The problem: AI works, but without structure
- Models lose context. After a restart the agent doesn't remember what it was doing — and often pretends it does.
- "Done" without proof. A model reports a success that doesn't exist. Without an enforced receipt you cannot tell completed work from hallucinated work.
- Tasks die silently. Something stalls, nobody raises an alarm, you find out after the fact.
- Agents step on each other. Two models do the same job or break each other's results because neither knows what belongs to whom.
- Instructions from content. A model reads a file and treats its text as a command — the simplest way for someone else's text to hijack your agent.
- You are the data bus. Without structure, the human manually carries results between chat windows and becomes the bottleneck.
The Coordination System turns several AI models into an orderly working crew: assignments go to the right workers, every answer carries proof, every result is checked by someone other than its author, and no piece of work disappears silently.
Nodes, not subagents — the key distinction
"Multi-agent" in practice usually means one thing: a single model spawning its own subagents — ephemeral offshoots of one context. A subagent inherits its parent's blind spots. When such a system "verifies itself", the same brain checks its own work — just in two windows.
What works here are independent nodes: separate sessions, often on separate machines and different AI models, each with its own identity and file-based memory. That's why verification means something here: the verifier is genuinely someone else, with different blind spots than the author.
Task lifecycle
- Assignment — coordinator assigns the task with a deadline.
- Acknowledgement — the worker confirms receipt before starting. The assigner knows immediately the task is "alive".
- In progress / blocked — the worker reports progress or a blocker before the deadline.
- Done — with proof. "Done" without proof does not exist. Proof is concrete: a working URL, a test result, a pointer to an artifact.
- Verification — the paired verifier issues a verdict: accepted or rejected with a reason.
- Deployment through the gate — an irreversible action requires the operator's consent.
- Post-deployment check — the cycle ends on "verified working", not "uploaded".
Step-by-step demo
One task goes through the full lifecycle: operator assigns, coordinator routes, producer builds with proof, verifier on a different model checks, publication passes the gate, one task stalls along the way — and the system loudly demands it back.
✓ Field-tested — July 2026
- 3 parallel work fronts, 11 AI nodes in 3 teams
- 130 articles published live, zero task conflicts
- Verifier caught an invented "fact" (non-existent virus) before it hit production
- Critical registration bug eliminated, CRM fixes in repository
Honest limits
⚠ This is discipline and audit, not a sandbox. The gate is a convention, a token and a ledger — not technical process isolation. The system assumes a trusted environment under operator supervision.
- Requires an operator. Strategic and irreversible decisions belong to the human — that's a feature, not a bug.
- Doesn't eliminate errors — eliminates silent errors. A model can still be wrong. The system ensures mistakes don't disappear quietly; they surface as explicit decisions.
Why we don't publish the code
We don't publish the repository. We share the concept and knowledge — how it works, what problems it solves, how to build your own. We don't publish a ready-to-run mechanism for commanding a team of AI agents, because it's a dual-use tool: in good hands it organizes work; in random hands — it's a framework for running AI at scale without oversight. We publish how to think, not what to click.
Who it's for
- Operators and companies that want to use multiple AI models at once — without chaos and without manually carrying results between chat windows.
- Processes where "probably done" isn't good enough: production content, system changes, customer support, analyses.
- Mixed human+AI teams where the same lifecycle and proof requirements apply to everyone.
- Local deployments: everything runs on plain files, on your hardware, under your supervision.
Honestly — if you need one chat to talk to, you don't need a coordination system.