Writ

Agents don't need instructions. They need terms.

You wouldn't manage a senior engineer with a flowchart. You'd give them a goal, a budget, access to what they need, a few hard lines, and a definition of done — then let them work, and hold them to it. That arrangement has a name. It's a contract.

Writ is agent orchestration as contract enforcement. Instead of authoring control flow — nodes, edges, retry branches — you author a writ: a declarative document stating a mandate (the goal as a condition on the world), grants (what the agent may touch), bounds (what it may spend), invariants (what must stay true throughout), satisfaction (what provably counts as done), and remedies (what follows a breach). A runtime — the registrar — supervises every action against those terms and enters everything into an auditable record.

writ: bug-fixer
mandate: "Failing test {failing_test} passes without breaking others."

grants:
  - read:    { paths: ["**/*"] }
  - shell:   { commands: ["pytest *"] }
  - edit:    { paths: ["src/**"] }
  - open_pr: { requires: assent }

bounds:     { iterations: 40, cost: $2.50, edits: { max_changed_lines: 200 } }

invariants:
  - { layer: letter, untouched: "{failing_test_file}" }

satisfaction:
  - { layer: letter,   run: "pytest -x -q", exit: 0 }
  - { layer: judgment, clause: "The diff fixes the cause, not the symptom." }

The model plans; the writ governs. Every clause declares how it's checked — by letter (machine-verified, every action), judgment (model-evaluated at checkpoints), or assent (you). Cycles never appear in what you author: satisfaction is a fixpoint, and the registrar reconciles toward it the way Kubernetes reconciles toward declared state. Agents can delegate by issuing sub-writs — but only ever weaker ones: grants attenuate, budgets are carved and conserved, invariants inherit. Authority flows down the chain; it is never minted along the way.

Writ never gets smarter. That's the point. It confers no intelligence and contains none. Hand-drawn control flow encodes the how, and models keep absorbing the how — every release makes your graphs a little more embarrassing. What remains durably human is the what and the within-what-limits: the mandate, the authority, the lines, the proof. Writ is a language and runtime for exactly that residue, which means it's the one layer of your stack whose value grows with model capability instead of eroding against it.

writ issue bugfix.yaml        engage an agent under contract
writ record bug-fixer         the record: every action, check, and attestation
writ amend bug-fixer ...      renegotiate terms — narrowing freely, widening by assent

Name. Writ lives at writ.build. The command is writ; the installable package is writctl — so npm i -g writctl, then run writ.

Writ governs mandates, not pipelines — if your process can be fully written down in advance, a workflow tool will serve you better, and we'll say so. Open source, model-agnostic, spec-in-your-repo. The founding design paper, including the open problems we haven't solved, is in DESIGN.md.

The standing challenge: show us an agent that can't be expressed without authoring a step. We designed against three adversarial cases and the paradigm held — but the cheapest thing anyone can contribute right now is the counterexample. Open an issue.