Zero-Trust Autonomous Engineering

The Zero-Trust Autonomous Engineering Team

Eliminating AI Reward Hacking and fake tests in Pull Requests. Competing models debate in an air-gapped sandbox with Red-to-Green machine proof. Zero unverified merges.

See How It Assembles
Elastic lineup per task
One team
One engineering team staffed per task — three, five, ten, as many as truly needed — then stood down. No fixed staff, no ceremony.
Context saved
70%+
You pay for the proof, not the words — TokenShield keeps long debates affordable because repeated context is not resent and routine output is compressed, with every saving visible in your usage report next to the proof.
Unverified merges
0
Nothing ships until an isolated sandbox executes the proof and the Critic withdraws its veto — no matter how confident the prose sounds.
Validation stage
Pre-MVP
The product is under active development — no finished release yet. We are proving the debate engine with a small number of teams on real work; this page states the plan, not traction.

Distributed Lock with Redlock

Three services race to elect a leader. The debate converges on a Redlock quorum with fencing tokens.

Planner

Plan: quorum, TTL, and fencing

Decompose into: 1) acquire a majority of five Redis nodes with a single TTL, 2) validate clock-drift bounds before use, 3) attach a monotonic fencing token to every guarded write so a stale holder cannot commit.

Round 1 of 5 · 18.4k tokens · 72% context saved

Staffed for Your Task, Then Stood Down

There is no standing army of agents. Each task synthesizes the team it needs and disbands it when done.

  1. Goal

    You state the objective in plain language from a mobile browser. One person in the loop — you.

  2. Chief of Staff

    Fast triage reads the task and drafts the lineup: which roles, how many agents, what proof each owes.

  3. PromptViewer

    The role foundry. It writes the prompt and knowledge pack for every required role — or reuses a versioned pack — adapted to the models at hand.

  4. Debate & Seal

    The team argues under the universal contract, and a human approves merges and anything public.

Every Result Survives Its Opponents

Whatever the task — feature, bugfix, refactor — each round runs the same adversarial loop with one rule: flattery is forbidden. Any role may raise a blocking objection, but the formal BLOCKER veto is the Critic's alone — and a veto can only be cleared with evidence.

  1. Planner

    Decomposes the goal

    Turns a goal into an explicit plan: scope, interfaces, edge cases, and acceptance criteria — before any artifact exists.

  2. Builder

    Proposes the artifact

    Produces the plan as a concrete, reviewable result — a diff, a brief, a campaign. Every claim has to be checkable by the roles that follow.

  3. Critic

    Attacks the artifact

    Hunts hidden defects, skewed sources, and silent assumptions. Holds an unconditional BLOCKER veto over anything unverified.

  4. Verifier

    Executes the proof

    Runs the check in isolation — tests, builds, source verification. Pass or fail is decided by the machine, not by debate rhetoric.

  5. Supervisor

    Seals the consensus

    Admits the result only when the Critic is satisfied and verification is green, then checkpoints it with full provenance.

Anti-sycophancy contract: agreement without evidence counts as a defect. The Critic is rewarded for finding the flaw everyone else missed.

Two Economies, One Predictable Bill

Models get cheaper; verification stays complete. You pay for the proof — never for words.

Cheap drafts

Drafts stay cheap by design. Rough work uses affordable capacity with limits, proving the mechanics — vetoes, sandbox, evidence — before anything consequential.

Affordable proof

Long debates stay affordable because you pay for the proof, not the words — repeated context is not resent, routine output is compressed, and every saving shows up in your usage report next to the proof.

Garage

Free forever, drafts only

Free with limits. Proves the mechanics — vetoes, sandbox, evidence — but never issues a final ACCEPT where the cost of error is high.

Boardroom

Paid, for consequential calls

Paid, for consequential merges. Independent multi-provider checks with SLAs and signed provenance for architecture and money decisions.

Fast Triage, Deep Debate

One fast triage for routing, one deep debate for thinking — and a human for the verdict.

  1. Micro reflexes

    Fast pre-triage picks team size and risk level before any expensive work. No heavy round-trips for yes-or-no questions.

  2. Deep reason

    Deep debate handles long diffs and contested decisions — then the adversarial loop takes over with full evidence.

  3. Accountable finish

    Triage only routes; it never approves and never overrules a veto. Low confidence escalates to deeper debate — and always to you.

One Team, Elastic Lineup

No fixed org chart. A Chief of Staff reads your task and staffs the engineering team it needs with exactly the roles required — three, five, ten, as many as truly needed. PromptViewer writes and adapts each role pack for the task at hand.

Proof, Not Confidence

An isolated sandbox executes every claim and reports machine facts — exit codes, assertions, test counts — never a model grading its own homework. A dedicated Critic holds a BLOCKER veto, and every sealed step is checkpointed to Git with full provenance.

Two Cost Economies

Drafts stay cheap and merges stay proven. TokenShield keeps rough work nearly free, and consequential merges are checked independently by multiple providers with no single vendor deciding.

Reflexes and Reason

Fast triage picks team size and debate depth before any expensive work; the debate does the thinking; a human seals the outcome. Fast reflexes, slow reason, accountable finish.

FAQ

A model never gets the last word. Every proposal must survive a dedicated Critic whose job is to break it, plus an isolated verifier that executes the proof — tests, builds, source checks. If either objects, the result does not ship — no matter how confident the prose around it sounds.