Advanced Agents From First Principles on Programmer.ie

Build a Production AI Agent From First Principles: The Complete Reference Architecture

Sun, 09 Aug 2026 16:09:00 +0100

Build a Production AI Agent From First Principles: The Complete Reference Architecture

We have spent this series adding mechanisms only when a specific failure demanded them.

We started with a model call.

Then we added candidate generation, critique, planning, tool use, memory, search and verification.

Then the system stopped looking like a clever prompt.

It started looking like software.

Then distributed systems problems arrived:

duplicate work,
retries,
leases,
fencing,
backpressure,
dependency failure,
behavioral drift,
release compatibility,
replay,
incident forensics,
SLOs,
authority,
competence,
capability acquisition,
placement,
handoff,
stale state,
stale intent,
commitments,
durable workflows,
transaction recovery,
trust boundaries,
multi-agent coordination,
and finally an explicit control plane.

At this point the architecture is complete enough that adding another isolated mechanism would make the series worse rather than better.

Advanced Agents From First Principles 24: How Do You Release Agent Behavior Safely? Add Behavioral Contracts, Compatibility Checks and Promotion Gates

Sun, 09 Aug 2026 12:09:00 +0100

A model change can pass health checks and still break your agent.

A prompt change can preserve output schema and still change which tools the agent chooses.

A router change can improve average cost and silently starve a specialist that is essential for one high-risk workload.

A memory migration can keep every row intact and still change which memories are retrieved.

A verifier upgrade can make every dashboard greener while making the system less trustworthy.

Advanced Agents From First Principles 23: Your Infrastructure Is Healthy. Why Is the Agent Getting Worse? Detect Behavioral Drift and Roll Back Safely

Sun, 09 Aug 2026 12:00:00 +0100

Your Infrastructure Is Healthy. Why Is the Agent Getting Worse?

Your dashboards are green.

The model endpoint is responding.

The browser workers are alive.

The database is healthy.

The queue is draining.

The verifier service is up.

Latency has not exploded.

There are no obvious exceptions.

And yet the agent is getting worse.

It fixes fewer bugs.

It retrieves weaker evidence.

It escalates to expensive models more often.

It chooses the wrong tools more frequently.

Advanced Agents From First Principles 22: What Happens When One Dependency Starts Failing? Add Circuit Breakers, Bulkheads and Graceful Degradation

Sun, 09 Aug 2026 11:26:00 +0100

What Happens When One Dependency Starts Failing?

An advanced agent platform can be working perfectly and still collapse.

Not because the planner became confused.

Not because the router chose the wrong model.

Not because MCTS explored the wrong branch.

Because one dependency became unhealthy.

Maybe:

the frontier model starts returning 503s,
the browser pool starts timing out,
the embedding service slows from 80 ms to 8 seconds,
the verifier database starts dropping connections,
the search API starts rate limiting,
a sandbox cluster stops accepting jobs,
or an external provider is technically up but so slow that every request consumes a worker for minutes.

Then the retries begin.

Advanced Agents From First Principles 21: What Happens When Too Many Agents Compete for the Same Resources? Add Admission Control, Quotas and Backpressure

Sun, 09 Aug 2026 11:21:00 +0100

What Happens When Too Many Agents Compete for the Same Resources?

A single agent can look healthy in isolation.

It gets a request.

It calls a model.

It launches a few search branches.

It opens a browser.

It runs tests.

It asks a verifier to check the result.

Everything works.

Then production traffic arrives.

Ten agents start at once.

Then fifty.

Then five hundred.

Now every agent still has a perfectly reasonable local plan.

Advanced Agents From First Principles 20: Can Your Agent Coordinate Across Machines Without Duplicating Work? Use Leases, Idempotency and Fencing

Sun, 09 Aug 2026 11:13:00 +0100

Can Your Agent Coordinate Across Machines Without Duplicating Work?

A single-process agent can already be complicated.

It can plan.

It can search.

It can launch speculative branches.

It can cancel losing work.

It can verify outcomes.

Then you move that work onto multiple workers.

Now a new class of failure appears.

Two workers both believe they own the same task.

One worker pauses for thirty seconds.

Another worker assumes it died and takes over.

Advanced Agents From First Principles 19: Can Your Agent Explore in Parallel Without Creating Chaos? Use Speculative Execution and Early Cancellation

Sun, 09 Aug 2026 11:10:00 +0100

Advanced Agents From First Principles 19: Can Your Agent Explore in Parallel Without Creating Chaos? Use Speculative Execution and Early Cancellation

A production agent often has more than one useful thing it could do next.

It could:

inspect repository state,
run a targeted test,
retrieve documentation,
ask a second model to critique a candidate,
generate an alternative implementation,
probe an API,
inspect a deployment,
or verify an invariant.

If those actions are independent, executing them one by one can be needlessly slow.

Advanced Agents From First Principles 18: What Should Your Agent Observe Next? Use Expected Value of Information

Sun, 09 Aug 2026 11:06:00 +0100

What Should Your Agent Observe Next?

Your agent is uncertain.

That does not tell you what to do.

In the previous post we split uncertainty into operational categories:

interpretation uncertainty,
evidence uncertainty,
route uncertainty,
state uncertainty,
tool uncertainty,
candidate uncertainty,
verification uncertainty.

That is already better than one generic confidence score.

But it still leaves a harder question:

Which piece of information is worth buying next?

Suppose a coding agent is trying to fix a failing test.

Advanced Agents From First Principles 17: What Is Your Agent Actually Uncertain About?

Sun, 09 Aug 2026 11:02:00 +0100

What Is Your Agent Actually Uncertain About?

An agent reaches a difficult point in a task.

It is not sure what to do next.

A common implementation responds like this:

uncertain
   ↓
call the model again
   ↓
still uncertain
   ↓
call a stronger model
   ↓
still uncertain
   ↓
search more

That is not a reasoning strategy.

It is a spending strategy.

The system is using more computation without identifying what information is actually missing.

Advanced Agents From First Principles 16: Where Should an Agent Spend Its Compute? Build a Dynamic Budget Scheduler

Sun, 09 Aug 2026 10:53:00 +0100

Where Should an Agent Spend Its Compute?

A production agent has a budget whether you designed one or not.

Every model call costs something.

Every search node costs something.

Every tool invocation costs something.

Every verifier costs something.

Every retry adds latency.

Every escalation to a stronger model spends money and time that could have been used somewhere else.

The naive architecture gives every subsystem its own fixed limit:

MAX_STEPS = 20
MAX_SEARCH_NODES = 32
MAX_CRITIC_CALLS = 3
MAX_RETRIES = 4
MAX_VERIFIER_CALLS = 2

That looks safe.

Advanced Agents From First Principles 15: How Do You Optimize an Agent Policy Without Turning It Into Another Black Box?

Sun, 09 Aug 2026 10:49:00 +0100

How Do You Optimize an Agent Policy Without Turning It Into Another Black Box?

By now our advanced agent can do a lot.

It can:

route tasks to different models or specialists,
decide whether to search,
choose a search budget,
decide when to escalate,
invoke critics,
retry or recover,
stop when evidence is strong enough,
learn from verified production trajectories,
and trace the decisions that produced each outcome.

That creates a new problem.

Advanced Agents From First Principles 14: Can Your Agent Learn From Its Own Trajectories Without Learning the Wrong Lessons?

Sun, 09 Aug 2026 10:33:00 +0100

An advanced agent now leaves behind something extremely valuable:

evidence.

Not merely chat history.

Not merely model outputs.

Not merely traces.

A sufficiently instrumented system can record:

what state it was in,
what alternatives it considered,
which route it selected,
what branches it pruned,
which model or specialist it escalated to,
which tools it called,
which critic changed the answer,
what verification evidence was produced,
how much compute was spent,
and whether the final result actually passed.

That immediately suggests a tempting idea:

Advanced Agents From First Principles 13: How Do You Debug an Agent That Made the Wrong Decision? Add Trajectory Observability

Sun, 09 Aug 2026 10:18:00 +0100

An advanced agent fails.

You look at the final answer.

It is wrong.

So you inspect the prompt.

The prompt looks reasonable.

You inspect the model response.

That also looks reasonable.

But somewhere between the original request and the final result the system:

chose the wrong specialist,
pruned the branch that contained the right solution,
trusted a critic that was wrong,
escalated to an expensive model unnecessarily,
failed to escalate when it should have,
retrieved stale memory,
spent most of its budget exploring duplicates,
accepted a weak verifier signal,
retried the same strategy under a different name,
or transformed a local success into a global failure.

The final answer does not tell you which one happened.

Advanced Agents From First Principles 12: Is Your Advanced Agent Actually Better? Benchmark It Under Equal Budgets

Sun, 09 Aug 2026 10:10:00 +0100

Is Your Advanced Agent Actually Better? Benchmark It Under Equal Budgets

You replace one model call with eight.

Success rises from 62% to 74%.

Great.

Except the new system used:

eight times the inference,
three extra judges,
two rounds of critique,
a larger context,
a stronger verifier,
and several times the latency.

Did the architecture improve?

Or did you just buy more attempts?

This is one of the easiest mistakes to make in advanced agent engineering.

Advanced Agents From First Principles 11: Which Advanced Agent Architecture Should You Use? A Practical Selection Guide

Sun, 09 Aug 2026 09:20:00 +0100

Which Advanced Agent Architecture Should You Use?

You now have too many options.

That is a better problem than having none.

But it is still a problem.

You can add:

self-consistency,
Tree of Thoughts,
beam search,
Monte Carlo Tree Search,
evolutionary search,
specialist routing,
planner/executor/critic separation,
multi-agent debate,
adaptive policies,
learning from previous runs,
or a mixture-of-agents runtime that chooses among several of them.

The temptation is to combine everything.

Advanced Agents From First Principles 08: Is Your Agent Spending the Same Compute on Every Task? Build Adaptive Agents That Escalate Only When Needed

Sun, 09 Aug 2026 00:00:00 +0000

Build adaptive agent runtimes that start cheap, measure uncertainty and failure, and escalate selectively into deeper reasoning, more samples, search, stronger models or specialist review only when the evidence justifies it.

Advanced Agents From First Principles 25: Can You Reproduce an Agent Run Months Later? Add Deterministic Replay and Provenance

Sun, 09 Aug 2026 00:00:00 +0000

A production agent fails on Tuesday.

You inspect it on Wednesday and cannot reproduce the failure.

Three weeks later someone asks a harder question:

What exactly did this agent see, which release was running, which tools were called, which evidence was used, and why did the verifier accept the result?

If the answer is “we have some logs”, you do not yet have reproducibility.

You have fragments.

Advanced agents accumulate hidden variability quickly:

Advanced Agents From First Principles 26: Why Did the Agent Fail? Build an Incident Forensics Pipeline

Sun, 09 Aug 2026 00:00:00 +0000

A practical incident-forensics workflow for advanced agents: reconstruct the run, find the earliest divergence, distinguish root cause from downstream symptoms, measure blast radius, and prove that a remediation would have prevented the incident.

Advanced Agents From First Principles 27: How Reliable Does an Agent Need to Be? Define SLOs and Error Budgets

Sun, 09 Aug 2026 00:00:00 +0000

A practical reliability framework for advanced agents: define verified-success SLOs, false-success ceilings, UNKNOWN budgets, latency and cost targets, then use error-budget burn to decide when to ship capability and when to stop and harden the system.

Advanced Agents From First Principles 28: Where Should You Spend the Next Engineering Hour? Prioritize Reliability by Risk and Expected Return

Sun, 09 Aug 2026 00:00:00 +0000

A practical framework for deciding where to spend the next engineering hour in an advanced-agent system: rank remediation by expected reduction in verified reliability loss, severity, recurrence, blast radius, confidence and implementation cost.

Advanced Agents From First Principles 29: When Should an Agent Stop and Ask a Human? Design Authority Boundaries and Escalation

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for agent authority boundaries: decide what an agent may do autonomously, when it must escalate, what evidence a human reviewer needs, and how to avoid turning human approval into rubber-stamping.

Advanced Agents From First Principles 30: Is This Task Outside Your Agent’s Competence? Build Competence Envelopes and OOD Detection

Sun, 09 Aug 2026 00:00:00 +0000

A practical framework for competence envelopes in production agents: distinguish uncertainty from lack of validated competence, detect out-of-distribution tasks, contract authority when evidence is weak, and expand autonomy only through measured evidence.

Advanced Agents From First Principles 31: How Can an Agent Learn New Capabilities Without Expanding Its Own Authority? Use Sandboxed Capability Acquisition

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for sandboxed capability acquisition: let agents explore tasks outside their validated competence envelope, accumulate externally verified evidence, and propose capability expansion without ever granting themselves production authority.

Advanced Agents From First Principles 32: Which Capabilities Are Actually Worth Building? Design a Capability Portfolio

Sun, 09 Aug 2026 00:00:00 +0000

A practical framework for deciding which agent capabilities are worth acquiring: rank missing capabilities by user value, verifier availability, reliability risk, acquisition cost, maintenance burden, and the quality of human or deterministic alternatives.

Advanced Agents From First Principles 33: Which Shared Components Actually Unlock More Capability? Build a Capability Dependency Graph

Sun, 09 Aug 2026 00:00:00 +0000

A practical capability-dependency architecture for advanced agents: identify shared primitives that unlock many capabilities, quantify leverage, expose correlated-failure hotspots, and invest in platform components without creating hidden systemic risk.

Advanced Agents From First Principles 34: Where Should This Task Actually Run? Build Capability-Aware Placement Across Models, Providers and Resource Pools

Sun, 09 Aug 2026 00:00:00 +0000

A practical placement architecture for advanced agents: route work across local and frontier models, providers, regions, GPUs, browser pools and specialist runtimes using demonstrated competence, verifier availability, policy constraints, health, cost and latency rather than model prestige.

Advanced Agents From First Principles 35: How Do You Move a Running Agent Between Workers Without Losing Meaning? Build Portable Execution State and Safe Handoff

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for portable agent execution state: checkpoint long-running runs, transfer ownership safely across workers and providers, preserve evidence and authority, and reject migrations that cannot be proven compatible.

Advanced Agents From First Principles 36: Is Your Agent Acting on Stale State? Build Temporal Consistency, Freshness Budgets and Conflict Detection

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for keeping long-running agents from acting on stale assumptions: classify state by freshness, track version vectors, detect conflicts, revalidate before consequential actions, and force replanning when the world has changed underneath the run.

Advanced Agents From First Principles 37: Is Your Agent Still Solving the Right Task? Build Intent Versioning, Supersession and Cancellation

Sun, 09 Aug 2026 00:00:00 +0000

A production architecture for intent versioning, supersession and cancellation in long-running agents: stop obsolete work, preserve committed effects, reconcile partial actions, and prevent stale goals from retaining authority.

Advanced Agents From First Principles 38: A Plan Is Not a Commitment — Model Goals, Commitments and Executable Work

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for separating goals, plans, commitments, tasks and actions in long-running agents so replanning, cancellation, handoff and external obligations remain correct.

Advanced Agents From First Principles 39: How Do You Make an Agent Survive for Days? Build Durable Long-Running Workflows

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for long-running agents: keep workflow state durable while treating models and workers as disposable, with explicit waits, retries, timers, human approvals, checkpoints, commitments, cancellation and replay.

Advanced Agents From First Principles 40: Your Agent Changed the World. What Happens When Step Two Fails? Build Transactions, Compensation and Reconciliation

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for agent workflows that span systems without a global transaction: classify side effects, prepare carefully, commit with identity, verify externally, compensate when possible, reconcile ambiguity, and never pretend rollback is free.

Advanced Agents From First Principles 41: What Should Your Agent Trust? Build Explicit Security and Trust Boundaries

Sun, 09 Aug 2026 00:00:00 +0000

A practical security architecture for production agents: separate data from authority, classify trust, scope credentials and capabilities, preserve provenance, isolate generated code, resist prompt injection, and keep security-critical decisions outside model control.

Advanced Agents From First Principles 42: How Do Multiple Agents Coordinate Without Becoming a Distributed Argument?

Sun, 09 Aug 2026 00:00:00 +0000

A practical architecture for multi-agent coordination: explicit ownership, delegation, contracts, commitment transfer, shared intent, evidence provenance, conflict handling, deadlock prevention, and independent verification instead of agents merely chatting until they agree.

Advanced Agents From First Principles 43: Who Controls the Agent? Build an Explicit Agent Control Plane

Sun, 09 Aug 2026 00:00:00 +0000

A production-agent architecture that separates control-plane policy from execution-plane reasoning: intent, competence, authority, placement, budgets, reliability, releases, security and escalation remain enforceable outside the model.

You Probably Don't Need All of This: Build the Minimum Production Agent Architecture

Sun, 09 Aug 2026 00:00:00 +0000

You Probably Don’t Need All of This

Over the previous forty-five steps, we built almost every major mechanism you might need in a serious agent platform.

Search.

Critique.

Planning.

Memory.

Verification.

Distributed execution.

Leases.

Fencing.

Backpressure.

Behavioral releases.

Replay.

Incident forensics.

SLOs.

Competence envelopes.

Authority boundaries.

Capability portfolios.

Placement.

Portable execution state.

Temporal consistency.

Intent versioning.

Commitments.

Durable workflows.

Transaction recovery.

Security boundaries.

Multi-agent coordination.

An explicit control plane.

And finally, in Step 44, we assembled those ideas into a complete reference architecture for a production AI agent.

Advanced Agents From First Principles 10: Are You Combining Every Agent Technique Into One Monster? Build a Mixture-of-Agents Runtime

Sun, 09 Aug 2026 00:25:00 +0100

You have a working agent.

Then you add retrieval.

Then memory.

Then Best-of-N.

Then critique and revision.

Then Tree of Thoughts.

Then MCTS.

Then specialist models.

Then adversarial review.

Then a planner, executor, critic and verifier.

Then a stronger model for hard cases.

Eventually the architecture starts to look like this:

request
  ↓
planner
  ↓
retrieval
  ↓
reasoning
  ↓
Best-of-N
  ↓
critic
  ↓
Tree of Thoughts
  ↓
MCTS
  ↓
frontier model
  ↓
second critic
  ↓
verifier

Every mechanism may have been individually reasonable.

Advanced Agents From First Principles 09: Can Your Agent Actually Learn From Previous Runs?

Sun, 09 Aug 2026 00:19:00 +0100

Can Your Agent Actually Learn From Previous Runs?

A production agent can execute the same class of task hundreds or thousands of times.

It can see the same failure repeatedly.

It can discover the same workaround repeatedly.

It can call the same expensive model repeatedly.

And still behave as if every task is the first one it has ever seen.

That is not necessarily a memory problem.

It may already have excellent memory.

Advanced Agents From First Principles 06: Does One Agent Plan, Execute and Judge Its Own Work? Build a Planner-Executor-Critic Architecture

Sat, 08 Aug 2026 23:49:00 +0100

Does One Agent Plan, Execute and Judge Its Own Work? Build a Planner-Executor-Critic Architecture

A single model can often do all of these things:

understand a task,
decide what to do,
execute a tool call,
inspect the result,
critique its own work,
decide whether it succeeded,
and produce the final answer.

That is convenient.

It is also a dangerous concentration of responsibilities.

If the same component creates the plan, executes it, explains why the result is good, and decides whether the job is complete, then failures become difficult to localize.

Advanced Agents From First Principles 05: Is One Model Doing Everything? Build a Mixture of Experts at the Agent Level

Sat, 08 Aug 2026 23:41:00 +0100

A common agent architecture starts simply:

request
   ↓
model
   ↓
action

That simplicity is valuable.

It should be your default.

But eventually you may notice something strange.

The same model is being asked to do everything:

classify the task,
search documentation,
reason about code,
write SQL,
review a patch,
summarize logs,
judge another model,
decide whether a deployment is safe,
and answer simple questions that did not require an expensive model in the first place.

At that point the problem may no longer be:

Advanced Agents From First Principles 04: Does Your Agent Prune Good Ideas Too Early? Use Monte Carlo Tree Search for Long-Horizon Reasoning

Sat, 08 Aug 2026 23:37:00 +0100

A common failure in search-based agents is easy to miss.

The agent generates several plausible branches.

It scores them.

One branch looks weak.

So the runtime prunes it.

Later, you discover that the discarded branch was the only one that could have reached the correct solution.

The problem was not generation.

The problem was not necessarily the model.

The problem was search allocation.

The agent spent too much compute exploiting what looked good early and too little compute exploring alternatives whose value only became visible later.

Advanced Agents From First Principles 03: Does Your Agent Commit to a Bad Reasoning Path Too Early? Build a Tree of Thoughts

Sat, 08 Aug 2026 23:25:00 +0100

A reasoning agent can fail even when every individual step looks plausible.

The problem is often not that the model cannot produce a good line of reasoning.

The problem is that it commits too early.

It chooses one interpretation, one hypothesis, one plan, or one next step and then spends the rest of the run trying to make that decision work.

That gives us a common failure pattern:

problem
  ↓
first plausible thought
  ↓
second thought conditioned on the first
  ↓
third thought conditioned on both
  ↓
...
  ↓
confident answer built on an early mistake

If the first branch was wrong, every later step inherits the error.

Advanced Agents From First Principles 02: Why Does My Reasoning Agent Give a Different Answer Every Time? Use Self-Consistency Without Confusing Consensus With Truth

Sat, 08 Aug 2026 22:44:00 +0100

A reasoning agent gives you one answer.

You run it again.

It gives you another.

You change nothing important:

same task,
same tools,
same model family,
same broad context.

Yet the result changes.

That is not necessarily a bug.

A probabilistic model is allowed to produce more than one plausible trajectory.

The engineering question is different:

How should an agent system use that variation?

One common answer is self-consistency.

Advanced Agents From First Principles 01: Does Your AI Agent Fail on Complex Reasoning Tasks? Treat Chain of Thought as Computation, Not Proof

Sat, 08 Aug 2026 22:35:00 +0100

Most developers first encounter chain of thought as a prompting trick:

Think step by step.

That framing is too shallow for agent engineering.

For an advanced agent, the useful idea is not that the model should produce a long explanation. The useful idea is that a difficult task may benefit from intermediate computational state before the system commits to an action or answer.

That is a very different claim.

A reasoning trace can help a system decompose a problem, preserve intermediate conclusions, identify missing information, decide what to verify next, and expose places where search or tools should be used.

Advanced Agents From First Principles 00: When Should You Use an Advanced Agent Architecture?

Sat, 08 Aug 2026 22:27:00 +0100

Advanced Agents From First Principles 00: When Should You Use an Advanced Agent Architecture?

You built an agent.

It can:

call tools,
maintain state,
plan,
revise its own work,
search over alternatives,
remember useful information,
and verify whether the requested outcome actually happened.

Now the temptation begins.

You add another model.

Then a critic.

Then a planner.

Then a judge.

Then a router.

Then three specialist agents.

Then a tree search.

Advanced Agents From First Principles 07: Do Your Agents Agree Too Easily? Use Adversarial Review and Multi-Agent Debate Without Confusing Debate With Truth

Sat, 08 Aug 2026 00:00:00 +0000

A multi-agent system can look sophisticated while every agent quietly repeats the same mistake.

That is one of the most dangerous failure modes in advanced agent architectures.

You ask one model to solve the problem.

Then you ask a second model to review it.

Then a third model judges the disagreement.

Three calls later, the system sounds more confident than before.

But if all three agents share the same blind spot, the extra machinery has not created independent evidence.

Mon, 01 Jan 0001 00:00:00 +0000

Advanced Agents From First Principles — Working Ledger

Book intention

Extend the first-principles agent model into the harder engineering problems that appear once agents become long-running, stateful, orchestrated, evaluated, and operational.

Book state: NOT REVIEWED
Review ladder: UNREVIEWED → STRUCTURE OK → CONTENT OK → PROSE OK → DONE

Bootstrap note

This book currently contains 46 chapter files (00–45). In this first editorial-state pass, every chapter is registered below so none can disappear from the review queue. Titles and chapter jobs have not been guessed from filenames; — means “verify from the chapter front matter when first opened.” Once this book becomes active, populate those cells as part of the first pass.