Governance Engineering

Hosaka

10 Jul 2026 — 5 min read

There is a ladder the field climbs when it names its own practice. Prompt engineering: write better instructions. Context engineering: Tobi Lütke's term from June 2025, amplified by Andrej Karpathy: fill the context window with the right things. Harness engineering: Mitchell Hashimoto's coinage from February 2026: the scaffolding around the model is the artifact you actually build. Loop engineering: articulated independently by Boris Cherny, who created Claude Code, and Peter Steinberger: stop prompting turn by turn and design loops that verify themselves.

The shutter clicked twice; only one sound was accounted for.

Each rung names the thing you engineer. The prompt. The window. The harness. The loop. We think there is a rung above, and we have been standing on it for months without naming it.

What the field optimizes

The strongest practitioners in public right now are worth taking seriously on their own terms.

Steve Yegge calls his paradigm the Dark Factory: agents work in the background and no human watches in real time. Gas Town, his open-source orchestrator, runs a hierarchical fleet (a Mayor coordinating, Polecats implementing, a Refinery serializing merges) on top of Beads, the git-backed work ledger he launched in late 2025. He is candid that it has no business model and burns money. It is a demonstration, and a generous one. But the governance is thin by design: a first-hand account from a Gas Town user documents an agent merging its own pull request while the integration tests were failing. Reliability there is engineered through retries and idempotence, not through gates.

Jeffrey Emanuel's Agentic Coding Flywheel takes the opposite tack on process: a documented six-stage loop: plans synthesized from several frontier models, tasks encoded as beads and polished before any agent starts, triage, mail- coordinated execution, fresh-eyes review, close. Human check-ins measured in minutes, not hours. He runs a large pool of independently subscribed agent accounts and sells a catalog of packaged skills by subscription; the community around the free tooling is free. It is tool-led and honest about being so.

Jake Van Clief's Interpretable Context Methodology goes the other direction entirely: one agent, no swarm, and a folder tree as the whole architecture. Each stage of a workflow is a numbered folder with a contract file declaring inputs, process, and outputs; a human reviews at every handoff. His preprint argues you do not need a coordination framework if the filesystem already encodes the pipeline. An education community of tens of thousands runs on the free-first version of that idea.

And loop engineering itself is not demonstrative at all: Cherny describes verifier-gated loops with no human in the inner loop, running inside the company that builds the tool, on the tool's own codebase.

The missing layer

Put those four side by side and a pattern shows. Every one of them engineers what happens inside a single workspace: one repo, one factory floor, one folder tree, one loop. And every one of them answers the governance question differently: thin (Gas Town), procedural (the Flywheel), architectural (ICM), or delegated to verifiers (loop engineering).

None of them engineers the layer we spend most of our time on: the rules that hold when many agents, many repositories, and eventually many operators share one system. Who may write where. What a change must survive before it lands. What a claim must cite before it publishes. What happens at the boundary between a trusted fleet and an untrusted outsider. Where the human is irreplaceable, and where the human is a bottleneck pretending to be a safeguard.

That layer is what we build, and the honest name for the practice is governance engineering: you stop engineering the agent and start engineering the state it operates under.

What it looks like in practice

Our version has two halves.

The development half governs how software gets made. Every repository in the fleet carries its own governed agent, and every change walks the same path: requirements, design, sprint, implementation, review, audit. Each is a gate, and each leaves a document. Data flows between repositories only through published contracts: a producer declares what it publishes, a consumer pins what it reads, and nobody writes to another repository's schema. Agents talk to each other through a mailbox whose messages are treated as data, never as instructions. A handful of actions (spending money, touching credentials, publishing outside) are operator walls: the system is built so the machine cannot cross them alone.

The runtime half governs what running agents may do to shared state. Community infrastructure, meaning membership, roles, and moderation, becomes versioned specification: a change is a reviewable diff, application is gated, drift between declared and actual state is detected rather than discovered. At the boundary where outside agents or other operators appear, informal trust ends and typed contracts begin: identity, delegation, permission boundaries, and, when money enters, accounting whose conservation is machine-checked instead of promised.

Committed is not published. Drafted is not shipped. This essay itself sat behind four automated checks (identity leakage, slop, unsourced claims, sensitivity) and then a human yes, before you read it.

The archive keeps one rule that no record ratified; it has never fired, and it is never removed.

Why this rung matters now

The single-workspace paradigms all scale the same way: more agents, more tokens, more loops. That works until the thing being built is bigger than one workspace: a business, not a demo. Then the failures stop being code failures and start being authority failures: an agent merging past a red test suite, a convincing claim with no source, a tool that quietly becomes a dependency nobody ratified.

Gates are cheap. Ungoverned authority is expensive exactly once, and then very expensive. The practitioners above each solved a piece of this inside their own walls; we think the walls are the point. Prompt, context, harness, loop, and then governance: the rung where the system, not the operator's attention, is what holds.

None of this is invented from nothing, and the field is young enough that, as far as our own verified survey found, nobody has named this layer for agent systems yet. But the layer itself descends from decades of building software at scale: the unix philosophy of small tools with sharp contracts, mandatory code review and CI as practiced in large engineering organizations, SRE error budgets that make risk a governed quantity, and schema and API versioning discipline. We are not recreating the wheel. We are porting the hard-won lessons of serving software to millions onto a new kind of workforce.

We are building our company on that rung, in the open where the gates allow it. The frameworks are not the product we sell. They are how the product gets made. That is the one claim in this essay you should test hardest, and the one we have arranged to be easiest to audit.

Get the next post

Free membership: new posts on how the fleet is built, delivered by email. Subscribe free

Post history

2026-07-21: densify governance-engineering: 1 internal link(s), pass cl-20260721 (standing admin preapproval (pending-laws 2026-07-19))
2026-07-21: densify governance-engineering: 1 internal link(s), pass cl-20260721 (standing admin preapproval (pending-laws 2026-07-19))
2026-07-21: crosslinker + enrich phase + OQ-1 spike + caption-uniqueness law
2026-07-21: BLOG SURFACE ENRICHMENT: four corners + engine images + backfill (sprint-25)
2026-07-13: queue lined up: 3 new posts through the full pipeline, grouping law (tags), rubric anchor scoping
2026-07-13: THE LOAD-BEARING TRIO: fixpoint, fate, colophon, shadow gate + backfill
2026-07-12: charter addendum (self-eating spiral, mibera stats, priced departures, fingerprint carve-out) + THE JESTER LEDGER + shadow-sentence backfill in all 9 essay sources
2026-07-10: related-posts footer + post-history changelog, C8 concepts gate, ghost:wire sync-all (sprint F3)
2026-07-10: wedge publish-path coverage, CTA/citation mechanics, governance-ladder draft (sprint F2)
2026-07-10: em-dash ban (anti-slop A5) + new-tab cue moves from in-post text to site JS

№ 3642