The Harness Series: What We Read, What We Took, What We're Trying to Do

The last month was a lot of reading. Anthropic shipped their harness-design post. Lex Christopherson's GSD-2 crossed 59K stars. Garry Tan's GSTACK crossed 71K. Jesse Vincent's Superpowers kept being passed around. Brian Suh wrote a piece on agents needing control flow. The Pulumi blog compared three of the four head-to-head.

Reading all four in sequence does something useful to your head. You stop thinking about each project as "the right answer" and start thinking about them as bets — different teams looking at the same failure modes and choosing different layers to put the constraint.

We wrote four side-by-side comparisons of H·AI·K·U against each.

This post is the anchor — where we ended up on the methodology, what we took from whom, and what we're trying to do.

The methodology, named

H·AI·K·U is a workflow engine that hands an agent one action at a time from a plan kept on disk. The agent is stateless between calls. The cursor is the persistent thread. The artifacts on disk are the memory. Every move the agent makes is a single tool call returning one structured action, which the agent then executes — and that's it for that turn. Next tick, fresh subagent, next action.

The load-bearing claims:

That's the engine. The shape of work it runs is up to the studio.

The surface, and why it matters

A workflow engine without a surface is a CLI for one user — the developer who installed it. That's not the work H·AI·K·U is built for.

Every intent boots a local SPA the engine drives. Review sessions render the diff, the spec, the feedback annotations, and the gate verbs (approve, leave feedback, submit files for drift, tick) in a browser tab. Questions the agent needs to ask route there. Direction requests for design route there. The browse view shows every intent in the repo with its current stage, current gate, current open feedback — a portfolio across an entire team's work, not just the one you're sitting on.

The surface is graded by mode. Same intent, same studio, same engine. The dial is per-stage, set at elaborate time.

The other half is backpressure that flows the other direction. A non-developer leaving a comment on a rendered design isn't filing a ticket into a queue someone reads later — they're adding a feedback file the engine treats as a first-class input at the next tick. The fix-loop dispatches against it. The earliest unaddressed stage gets revisited. A PM dropping a paragraph in the question modal pauses the agent until the answer lands.

Drift is the same mechanism pointed at the agent. The pre-tick gate hashes every file the agent stamped as a premise and compares against the agent's recorded premise. If a file changed out-of-band — a designer edited a mockup, a teammate fixed a typo, a script touched the schema — the agent is told before the next instruction fires. The premise is reconciled or the unit reroutes through elaborate. Long-running agents lose their footing; ours has to re-find it on every step.

Superpowers has a surface. Most don't. We think ours stands above for the work it's aimed at — multi-skilled teams where the designer, the PM, the QA lead, and the engineer all have something to weigh in on, and none of them should have to learn the CLI to do it.

What we're trying to do

If we had to write the H·AI·K·U mission in one sentence, it would be the same one we wrote in April:

Dark factory is the ceiling, not the mandate. Per-stage gates let you keep a human in the loop as much as the work calls for — interactive discovery, auto-advancing build, external sign-off security gate, all in the same intent. The point isn't to remove the human; it's to put the human's effort where it pays back — in the spec, not in babysitting the build.

We're betting the structural pattern holds across 24 domains, not just software. The studios share the engine; only the domain shape differs.

So far: we think it can do it all. The shape holds. The four comparison posts are us pressure-testing that belief against four serious projects working on the same problem with different bets. None of them broke the belief; some of them showed us where we have packaging work to do.

What we owe

We didn't get here in a vacuum. Specific debts:

Anthropic's harness post. Confirmed two things we'd already built (context resets, external evaluators) and named one structural gap we addressed differently. Their post is candid that "some problems remained persistent" — context drift on long tasks, self-evaluation bias — and that their patches add complexity and latency. Reading that paragraph and recognizing it as a downstream symptom of the open-loop the agent runs was the clearest articulation we'd seen of why our single-step design pays off. We didn't invent that framing in response to their post; we'd shipped the cursor model first. But their post is what let us name the difference.

Jesse Vincent's Superpowers. Three concrete things. First: loud framing is load-bearing. <EXTREMELY-IMPORTANT> and <HARD-GATE> aren't theater; they're what survives the agent rationalizing past calm guidance. We adopted that defensive envelope at the orchestrator layer so every studio inherits it. Second: skill files as orientation aids — we don't ship flowchart files but the orchestrator renders the workflow shape on demand for the same reason. Third: the six-platform install matrix is a packaging discipline we don't yet match. The MCP protocol work is done; the one-click entry points for Cursor / Codex / Copilot CLI / Gemini / OpenCode are work-in-progress.

Lex Christopherson's GSD-2. The atomic-plan-per-fresh-window pattern is the cleanest articulation we've read of context-rot mitigation. We solve the same problem by never giving the agent the loop in the first place, but reading GSD's design reinforced that the per-step boundary is where the structural answer lives. The crash-recovery + stuck-loop detection patterns are also worth studying — our on-disk state survives crashes by construction, but GSD's explicit recovery paths show what an orchestrator-agent has to do when state isn't all on disk.

Garry Tan's GSTACK. The 23-role library is the strongest articulation of "roles as legibly distinct lenses" we've seen in the prompt-layer approach. Our hats embody the same intuition; reading GSTACK confirmed that the lens metaphor scales across domains, not just engineering. The next batch of studio cleanup we have queued (cross-stage consistency, FM-interpretation refactors) directly borrows the legibility discipline from GSTACK's role definitions.

Brian Suh's piece on agents needing control flow. Already linked from One Instruction at a Time. The line "if you've ever resorted to MANDATORY or DO NOT SKIP, you've hit the ceiling of prompting" is the clearest one-sentence justification for moving from prompts-as-runtime to engine-as-runtime that we've read.

AI-DLC, our predecessor. We built it. We watched it walk over its own MUSTs in production. The decision to rewrite it as H·AI·K·U with the agent-as-tool model came directly from those failure logs. The credit there is to the seven of us who kept hitting the same context-drift wall and finally said "the agent can't hold the plan; stop making it." That was the foundational bet — everything since follows.

What we still don't know

We think Haiku can do it all. The belief survived reading the four projects above. It hasn't survived running at scale yet — the reflection loop is wired but hasn't actually fired on a real intent. The studio audit we just commissioned found ~94 EXECUTION.md files describing a stale pre/post review model; that's drift we have to clean up. The "trim scaffolding as models improve" thesis from Anthropic and Superpowers lands on us too; we have hat-internal anti-pattern walls that we suspect are belt-and-suspenders on current frontier models.

So: we think the shape is right. We're less sure each layer is sized correctly. The next quarter is mostly cleanup work — let the reflection loop fire on real intents, watch what it surfaces, accept the trims, push back on the additions.

If you're choosing a harness today, read the comparisons before you choose us. We're not the right tool for every shape of work.

The harness conversation is bigger than any one of us. The space is better for having four well-argued options. Read the comparisons. Pick the bet that matches your work.