A specification language for human-agent boundaries. Define modes, validators, and disagreement policies. The tooling enforces them for every agent on the team.
The open-source engine enforces the rules. snodo cloud is where you steer the work: state an intent, watch it become waves of small tasks that are checked against your own decisions, and step in only when a gate halts.
Describe the outcome and the evidence you expect. Plans split into small waves, and tasks that touch the same files run one after another.
Every spec and every result is reviewed by independent validators for architecture, security, access control and your own ADRs. A blocker stops the task; the reason is written down.
Lint, tests and type checks run on each task in its own worktree. A clean pass merges on its own; anything else waits for you, and the fix is queued behind it.
Send the same question to several agents independently and see where they converge. Useful for understanding a codebase or settling a design before any code is written.
Running, merged and halted work in one view, with the blocker and its reason up front.
Runners attach from your own machines over an authenticated tunnel or a WebSocket channel. Source stays where it lives; the cloud coordinates. Opt in to a public address when an outside client needs to reach a runner.
Each organisation enables its own models and brings its own provider keys. The orchestrator, the coder and the validators can each run on a different one.
Dispatch is a chat that knows your projects: ask what is blocked, scope a change, turn the answer into an intent. Claude Code and other MCP clients can drive the same projects directly.
Analysis of AI-generated code finds consistent security weaknesses across Python and JavaScript — persistent across model generations, not a temporary capability gap.
Newer models produce code that fails to perform as intended but runs without syntax errors or obvious crashes. Hidden costs accumulate through delayed discovery.
Autonomous code generation introduces audit complications that go beyond code quality into regulatory territory. What decisions were made? What validation occurred?
Single agents reviewing their own output validate against the same flawed model that produced the implementation. Independent review requires structural separation.
Operational stages with defined tool sets, enforced at the MCP boundary. The solo protocol runs one producer mode that merges on a clean pass; in team setups the producer cannot merge and the reviewer cannot edit (WF1).
Independent evaluators with orthogonal criteria — security, architecture, quality. Each assesses without seeing others' verdicts. Pre- and post-execute phases declared in the protocol.
Unanimous, majority, quorum, or any. Turns variable validator outputs into deterministic decisions: proceed, escalate, or halt. Any blocker is non-overridable — INV3.
JWT-backed single-use credentials issued on validator quorum. MCP tools require a valid token for any mutating operation. Validation cannot be skipped, drifted, or bypassed.
Full governed task path vs. representative LLM inference latency. Structural enforcement is essentially free.
At a 5-stage pipeline, behavioural compliance fails 45% of the time as corrupted state compounds. Structural enforcement: 8%.
The gap widens past an order of magnitude as validators diversify. Even at 20 stages — where behavioural failure hits 91% — structural enforcement holds at 32%.
Two human-in-control roles plus N specialized agents. Producer mode cannot merge; reviewer mode cannot edit. The minimum of two humans derives from Separation of Duties: a single human cannot independently validate their own work, no matter how many agents are on the team.
The language places no upper bound on modes. Enterprise teams typically add planning, deployment, and operations modes. The 2+N pattern is the minimum viable structure.
Prompts are flexible but cannot be enforced; workflow formalisms can be enforced but do not model autonomous agents. We give a domain-specific language that specifies AI-SDLC processes as protocols, with formal syntax, well-formedness conditions, operational semantics and enforcement invariants, and a clear split between policy (declared intent) and mechanism (structural enforcement). Well-formed protocols keep their invariants on every execution trace, including under composed orchestration loops, so a step cannot be skipped. A failure-rate analysis shows structural enforcement limiting silent failures and turning the rest into visible, auditable stalls. On SWE-bench Verified, the same bug-fix method gave no gain as prose instructions and a replicated 14 to 22 point gain when run as a validated, self-correcting process.
Three layers: unit, integration, and end-to-end CLI journeys driven through real subprocess invocation.
Property-based tests over the enforcement invariants, such as token unforgeability, audit-chain integrity, mode separation and policy halt, run against randomized inputs.
Ready-made reference protocols, from solo to team to the 2+N pattern, all written in the same DSL.
Every invariant in the specification maps to a mechanism in the code: signed single-use tokens, separate tool sets for each mode, a hash-chained audit log. An agent can't skip a step, because the tool that would let it isn't available to it.
The system is built under its own rules: it extends its own codebase through a protocol written in the same language, with the same validators and gate — dogfooded end to end.
Apache-2.0, developed in the open. Install from PyPI; the full source, protocol templates, and test suite are public.
As foundation models commoditize, the durable engineering asset becomes process design. The protocol is institutional memory; models are commodity infrastructure.