WRITING · ESSAY 06 · 2026-10-25
Ideal agentic harness architecture
The harness is where context, tool schemas, memory, and permissions compete for the same budget. Architecture is the allocation policy.
The harness is where the budget lives
The thesis: the harness is where context, tool schemas, memory, and permissions compete for the same budget. Architecture is the allocation policy. Model capability is rented; the allocation policy is what you own, and it is the difference between a demo and a runtime.
This essay is the allocation policy of a harness that runs, with the measured numbers where numbers exist and the honest build state where they do not.
What a harness actually is
Strip the marketing from the word and a harness is a modular substrate that provides, by default, what an agent needs to self-heal and self-learn: a sensorimotor layer for acting on the world, memory that persists across sessions, web access that does not require a per-task browser, a learning kernel that turns repeated sequences into named capabilities, and cron automations with sub-agent hooks for work that happens on a schedule.
The composition matters more than the parts. Each component is replaceable (the memory engine was replaced wholesale in October after a measured reversal), and each one carries a budget line that the others feel. A harness is not a stack of features; it is a set of allocation decisions made once and enforced mechanically.
The context-cost inflection, measured
The number that drives the whole policy: a full-load agent session, one that loads every tool the fleet registers, carries roughly 21.8k tokens of schema surface (tool-surface audit, 2026-08-26; private host, so not independently reproducible, and the register says so). The audit's fleet-wide tool count is withdrawn in the register: one member server alone outgrew it, which is its own lesson about aggregates.
That number is the inflection. Below it, tool selection feels free; above it, every tool you register is a tool you pay for in every session whether or not the role needs it. The fleet's allocation policy answers with three mechanisms:
- Contextually relevant registration. A server exposes only the tools the session's role needs. The counterexample is named in the register: the agent-memory server registers 7 tools at roughly 121 tokens per tool, the audit's model to follow.
- The deferred catalog. The full surface stays reachable without loading: a deferred catalog serves an equivalent tool surface at roughly 1.8k tokens, loaded on demand. Registration is no longer binary; the session pays for what it uses.
- The dual face. Everything also ships as a CLI, where schema cost is zero because no model is in the loop. When a session does not need a tool, the operator (or a scripted path) still does.
The arithmetic is the architecture. Once schema cost is measured, "should this be an MCP tool?" stops being a taste question and becomes a budget question.
A session through the layers
The composition is easiest to see as one session walking through the layers, so here is what a scheduled autonomous run actually touches, in order:
Spawn. A routine fires an issue into a lane; the bridge picks it up and composes a session. Before any model call, the pre-tick smoke gate probes the substrate (harness reachable, stores mounted, scheduling truth current) and records a verdict; a BLOCK here ends the run before it costs anything, which is the fail-closed property.
Allocation. The session receives its policy: which tools register (role-scoped, schemas paid from the budget), what memory surface it reads (the single-writer store through its declared interface), what it may touch (explicit permissions, never ambient), and which lane reports back.
Work. The session plans in typed steps (preconditions, claims, artifacts), calls tools through the registered surface, and writes artifacts to the task's evidence trail. Sub-agent hooks are how it scales: a session may spawn children for parallelisable work, and the children inherit allocations rather than negotiating their own.
Settle. On completion the bridge releases the artifact, the lane digest carries the outcome, and the record (not the log) is what survives. On crash, the claim expires and the task returns to the queue with its context, which is the recovery property from Essay 3.
Every arrow in that walk is an allocation decision, and every one of them is enforced by something mechanical: the gate, the manifest, the claim machinery, the single writer. The harness is what you stop having to hope about.
Typed planning and governed execution
The planning layer is typed: plans are structured (steps, preconditions, claims, artifacts) rather than prose the model hopes to follow. Typing the plan is what makes execution governable, because a typed step can carry its invariants: what must be true before it runs, what it is allowed to touch, and what artifact proves it ran.
Governance is mechanical, in three layers that each earned their place through a named failure:
- Typed manifests. Every system declares its structure, prefixes, services, and pooled sub-systems; a linter validates the graph. A system that misdeclares itself fails validation rather than misleading the next agent.
- Fixture-proven gates. Every validation gate ships with a harness that shows it failing on an injected violation. The gate-gaming incident (agents modifying a gate to permit a capped backlog, told fully in Essay 7) is the proof that gates without fixtures are hopes.
- The fail-closed tick. Scheduled spawns pass a smoke gate with a verdict history (62 BLOCK verdicts on record); a failed check blocks the spawn. The gate's postmortem history is on this site with its SQL.
The permissions half of the budget
Context and schemas are the visible budget; permissions are the invisible one. The harness allocates them per session by role: what the filesystem surface allows, which credentials a tool may reach, whether the session may spawn sub-agents, and what happens when it tries to exceed any of those (the answer is a typed refusal, not a scolding).
Two rules keep the permission policy sane. Single-writer state: relational state has exactly one writer with the schema owned by one system, so parallel sessions cannot corrupt each other. And explicit over ambient: a session's capabilities are granted in its allocation, never inferred from its context, because inferred permissions are how an agent with good intentions becomes an incident.
The permission budget interacts with the schema budget more than most designs expect: a tool that is registered but not credentialed is a trap (the session plans around a capability that fails at call time), so the allocation is one decision, not two. The fleet's rule is that registration and permission are granted together or not at all, and the smoke gate is partly there to catch the sessions where they drifted apart.
Honest build state
The substrate described here is the intended realization, and it is under-resourced on operator time: the sensing layer's coverage is uneven across pools, and the replacement runtime's execution record is still being wired to the standard the postmortems set. I am stating that plainly because this essay's other readers are the ones evaluating whether to trust the claims, and the fastest way to lose them is a confident sentence where a measured one is owed. The numbers that exist are in the register with methods and dates; the ones that do not exist yet are named as gaps.
What to steal
Three things, in the order I would steal them. Measure your schema cost: one audit pass, one afternoon, and every tool-selection argument after it is arithmetic. Type your plans: the step that cannot carry its preconditions is the step that fails silently. And put the fail-closed gate between your scheduler and your agents before you have sixty-two reasons to, because you will have them anyway; the gate just makes them count.
The audience contract this was written under
Written for
- Deployment-First Architect
- Evaluating Technical Decision-Maker
Has to hit
- MCP infrastructure deep dives: proxy aggregation, tool selection, context budgets
- Typed planning and governed execution patterns
- Case studies with numbers
- Shipped-artifact evidence
Rejected if it
- Calculator-tier MCP examples dressed as tutorials
- Prompt-only engineering with no runtime architecture
- Demos without source or reproduction
Figures in this essay: 4, each linked inline to the measurement record with its method and date.