Agent Architecture, Under the Hood

The Harness

The model is the engine — one combustion stroke per call, nothing more.

The harness is the loom bolted around it: fuel line, ignition map, governor, actuators, dashboard. Everything that turns a single stroke into a running vehicle.

Engine plus loom, wired together, is what “agent” means.

Ask a raw model a question and it fires once — no memory of the last stroke, no way to touch anything outside the cylinder. An agent isn’t a different model. It’s the same engine bolted into a car — and the wiring that makes it run is the harness.

Fuel line — memory & context, re-fed into the engine each stroke.
Ignition map — the system prompt, the tune it fires to.
Governor — the guardrails that keep a bad stroke from firing.
Actuators — the tools that turn a decision into motion.
Wiring loom — the copper that routes every signal and pipes the exhaust back to the tank.

That loom is the harness. Engine plus harness, wired together, is what “agent” means. Every part below carries its engineering name — and, so it sticks, its part number under the hood.

One cycle, four strokes

One turn, four strokes:
Intake — draws memory into the engine.
Compression — the forward pass.
Ignition — sparks the power stroke: the proposed action runs the governor, then fans out through the actuators onto the road.
Exhaust — instead of venting, piped back into the tank and spinning up a turbo that boosts the next intake.

The dashed outline is the agent: the engine plus everything wired around it. The engine (blue) only ever sees the top row; every copper line is the harness.

And the human is in it, not just at the end: above the loop they steer the tune and set the destination; in the loop they release a consequential action before it fires. The driver isn’t just reading the dashboard — hand on the wheel, foot on the brake.

Engine vs. harness

Attribute	Model — the engine	Harness — the wiring loom
State	None — same weights, same forward pass, every single call.	Holds the conversation, files, and task state between turns.
One call does	Fires once — intake, compression, one stroke — then it’s spent.	Keeps the crank turning: strokes the cycle again, and again, and again.
Can it act?	Only proposes an action in text; can’t execute anything itself.	Actuates the tool call against the real world and hands the result back.
Limits	No concept of permissions, budgets, or what’s off-limits.	The governor — enforces guardrails, sandboxing, and rate limits before anything fires.

What’s in the wiring

ECU map

The system prompt — standing instructions the model is re-shown every call, the tune it fires to, saying who it’s being right now and what matters.

Actuators

Tools — usually more than one: search, code execution, a filesystem. Each is a function definition plus the code that actually runs it and returns a result.

Fuel tank

Memory & context — the transcript and task state the harness assembles and re-feeds each stroke, since the engine itself remembers nothing.

The road

Sandbox / environment — the actual place actions happen, kept separate from anything the harness doesn’t want the actuators touching.

Governor

Guardrails — permission checks, rate limits, and approval gates enforced before a proposed action is allowed to fire.

Wiring loom

Orchestration — scheduling and coordination across calls or subagents. This is the harness itself: the loom routing signals between every part above.

The name isn’t a metaphor stretched thin. Pop the hood on an actual engine and the wiring harness is exactly this: the bundle of copper that carries fuel data, ignition timing, and governor signals between every part, then routes the exhaust back around.

Swap engine for model, driver for user, and the analogy holds all the way down. No wiring, no car — no matter how good the engine is.