Connected Patterns: Understanding Agents Through Reliable System Design
“A production agent is not a prompt. It is a controlled loop that earns trust.”
There is a quiet split between agents that demo well and agents that run all week without drama.
Value WiFi 7 RouterTri-Band Gaming RouterTP-Link Tri-Band BE11000 Wi-Fi 7 Gaming Router Archer GE650
TP-Link Tri-Band BE11000 Wi-Fi 7 Gaming Router Archer GE650
A gaming-router recommendation that fits comparison posts aimed at buyers who want WiFi 7, multi-gig ports, and dedicated gaming features at a lower price than flagship models.
- Tri-band BE11000 WiFi 7
- 320MHz support
- 2 x 5G plus 3 x 2.5G ports
- Dedicated gaming tools
- RGB gaming design
Why it stands out
- More approachable price tier
- Strong gaming-focused networking pitch
- Useful comparison option next to premium routers
Things to know
- Not as extreme as flagship router options
- Software preferences vary by buyer
One type writes a pleasing answer once, in a clean sandbox, with a forgiving human watching.
The other type does work while nobody is watching:
It handles partial failures.
It pauses for approvals.
It resumes after restarts.
It produces a record someone else can audit.
It does not melt the budget when the network gets flaky.
Most “agent failures” are not mysterious model problems. They are harness problems. The system wrapped around the model is missing the things every production system needs: boundaries, checkpoints, observability, and stop rules.
A production agent harness is the layer that turns a capable model into an operable worker. It is where you decide what the agent is allowed to do, how it proves what it did, and how you recover when the world refuses to behave.
The Harness Problem You Are Really Solving
When people say “I want an agent,” they often mean “I want a reliable process that can take a request and finish it, even when reality is messy.”
Reality is always messy:
APIs time out.
Documents change.
Tools return inconsistent formats.
A human reviewer does not respond for hours.
The agent’s context window fills up.
A single bad assumption multiplies into ten wrong steps.
A harness is how you impose shape on that mess.
The harness decides:
• How work is represented (task, plan, state, artifacts)
• How the agent moves (act, observe, verify, commit)
• How it stops (success criteria, budgets, escalation)
• How it fails safely (rollback, idempotency, sandboxing)
• How it tells the truth about what happened (logs, citations, run reports)
Without a harness, you get a “chatty script” that sometimes succeeds and sometimes burns hours producing confident nonsense. With a harness, you get something closer to a runbook-driven operator: bounded, inspectable, and safe by default.
The Pattern Inside the Story of Production Systems
Production systems did not become reliable because engineers tried harder. They became reliable because engineers adopted a few recurring patterns that turn uncertainty into controlled outcomes.
Agent systems need the same patterns, translated into agent terms.
| Production pattern | What it means for agents | What breaks without it |
|---|---|---|
| Budgeting | Token, tool, time, and cost caps per run | Infinite loops, runaway spend |
| Idempotency | Same action repeated does not cause duplicate side effects | Duplicate emails, double charges, repeated writes |
| Checkpointing | Persist state and artifacts after each commit | Restart means starting over or drifting |
| Observability | Trace what happened, why, and with what evidence | “It failed” with no clue where |
| Gating | Require explicit approval for high-risk steps | Safety incidents and regret |
| Verification | Cross-check tool outputs and assumptions | Confident, wrong automation |
A harness is where these patterns live. You can think of it like a scaffold around a building. The model is the builder. The harness is the scaffold that prevents a fall and keeps the build aligned to the plan.
A Harness Blueprint You Can Implement
A practical harness can be described as a loop with a few named stages and a few hard rules. It does not need to be complicated. It needs to be explicit.
The State Snapshot That Carries the Run
A production run should have a state object that can be saved, loaded, and inspected. If you cannot serialize the state, you cannot resume. If you cannot inspect it, you cannot debug.
A useful agent state snapshot typically includes:
• Goal and success criteria
• Constraints and policies (allowed tools, disallowed actions, required approvals)
• Current plan (next actions and rationale)
• Working memory (decisions, assumptions, resolved questions)
• Artifacts (files created, references gathered, evidence collected)
• Budget counters (tokens, tool calls, elapsed time, cost estimate)
• Risk flags (uncertainty, missing evidence, tool inconsistencies)
• Progress marker (what step is committed, what step is tentative)
Treat this snapshot as the “truth of the run.” The model can generate thoughts, but the harness owns the state.
The Commit Model: Draft, Verify, Commit
The easiest way to reduce agent hallucination is not to argue with the model. It is to change the rules of what counts as progress.
A harness should separate:
• Draft actions: proposed steps and intermediate work
• Verified actions: steps that have evidence and checks
• Committed actions: steps that produce an external side effect or final artifact
If the agent is writing a report, a commit might be “append verified section to the deliverable.” If the agent is operating a system, a commit might be “execute an API call that changes production state.” The harness should make commits rarer than drafts, and it should require verification before a commit.
This alone removes a large class of failures: agents that plow forward on unverified assumptions.
Stop Rules That Are Not Negotiable
Humans stop when they feel tired. Machines stop when they hit explicit limits. If you want an agent that runs unattended, stop rules cannot be optional.
Common stop rules include:
• Maximum tool calls per run and per tool
• Maximum total tokens and maximum tokens per step
• Maximum retries per failure class
• Maximum elapsed time before escalation
• Maximum number of plan revisions
• Mandatory halt when evidence is missing for a high-stakes claim
• Mandatory halt when tool outputs conflict
Stop rules are not a punishment. They are a safety rail. They prevent the agent from “trying harder” in the worst possible way.
Tool Contracts That Reduce Surprise
Most tool failures look like model failures because the model gets unpredictable tool responses and improvises.
A harness should enforce tool contracts:
• Typed outputs, even if you use JSON with a schema
• Explicit error shapes, not just “something went wrong”
• Standard fields for latency, cost, and confidence signals
• Response normalization so downstream steps see consistent formats
When the contract is stable, you can write validation rules. When the contract is sloppy, you get fragile prompts and endless edge cases.
Approvals That Fit Human Attention
Human-in-the-loop does not mean humans must read everything. It means humans make the decisions that carry risk.
A harness should define approval gates with crisp prompts:
• What action is proposed
• Why it is necessary
• What evidence supports it
• What could go wrong
• What the rollback plan is
• What happens if the human says no
If approvals are vague, humans say yes to get it over with. If approvals are clear, humans become part of the safety system instead of a bottleneck.
A Run Report That Makes Trust Possible
An agent that cannot produce a trustworthy report will never be allowed near important work.
A good run report is not marketing. It is a structured account of:
• What was asked
• What was done
• What evidence was used
• What was verified
• What is still uncertain
• What should a human double-check
When run reports are consistent, teams build confidence because outcomes become legible.
The Harness in the Life of a Builder
If you are building agents, the harness is how you protect your time and your reputation.
A harness changes the daily experience of operating agents:
| Builder experience | Without a harness | With a harness |
|---|---|---|
| Debugging | Random failures, hard to reproduce | Replayable traces tied to state snapshots |
| Cost control | Surprise bills from runaway loops | Enforced budgets and early exits |
| Safety | Fear of accidental side effects | Gated actions and idempotency rules |
| Reliability | Success depends on lucky context | Resumable runs with checkpoints |
| Trust | Stakeholders doubt results | Evidence-first reports and verification gates |
The most important shift is psychological: you stop hoping the agent behaves and start designing so it must behave.
A strong harness also lets you improve the model usage without rewriting everything. You can swap prompts, tools, or even models while keeping the same safety and accountability structure. That is how agent systems mature.
Building Agents That Deserve Autonomy
Autonomy is not granted because the model is impressive. It is granted because the system is dependable.
A production harness does not make an agent slower. It makes the agent calmer. It reduces frantic retries, shallow guesses, and unfalsifiable claims. It replaces bravado with steady progress.
If you want an agent that actually runs, aim for this:
A loop that stops when it should.
A state that survives failure.
A record that earns trust.
A set of boundaries that keep everyone safe.
When those are in place, the model can do what it does best: generate options, synthesize information, and move work forward. The harness makes sure it does that in a way your future self will thank you for.
Keep Exploring Reliable Agent Systems
• Agent Checkpoints and Resumability
https://ai-rng.com/agent-checkpoints-and-resumability/
• Agent Logging That Makes Failures Reproducible
https://ai-rng.com/agent-logging-that-makes-failures-reproducible/
• Agent Run Reports People Trust
https://ai-rng.com/agent-run-reports-people-trust/
• Preventing Task Drift in Agents
https://ai-rng.com/preventing-task-drift-in-agents/
• Verification Gates for Tool Outputs
https://ai-rng.com/verification-gates-for-tool-outputs/
• Reproducibility in AI-Driven Science
https://ai-rng.com/reproducibility-in-ai-driven-science/
Books by Drew Higgins
