Multi-Agent Systems on AIBussin — AI applications, systems and books

The Architecture of Agent Behavior

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

Chapters 1 and 2 introduced the working style of agent systems: conversation, variation, feedback, revision, and human direction. Now we need to look underneath that experience.

An agent does not become capable because a class is named Agent or because a prompt says “you are a researcher.” The behavior comes from the arrangement of parts around the model:

goal
  ↓
role + instructions
  ↓
context + state
  ↓
model proposes
  ↓
runtime validates
  ↓
tool / memory / message
  ↓
environment observation
  ↓
state update
  ↓
continue, revise, coordinate, or stop

That is the architecture of agent behavior. The model supplies interpretation and generation. The prompt and context shape what the model sees. The runtime owns state, tool execution, permissions, memory retrieval, orchestration, and stopping rules. The human operator supplies purpose, constraints, judgment, and responsibility.

Architecting Agent-Based Systems

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

The previous chapters built up one agentic workflow: roles, tools, memory, reflection, revision, and versioning. This chapter changes scale.

An agent-based system is not one large assistant with a bigger prompt. It is a collection of components that divide responsibility, communicate through explicit channels, use shared or separate state, and preserve enough identity that you can tell which part did what.

The design question is:

Which responsibilities belong together,
which should be separated,
and how should the separated parts coordinate?

Architecture begins when those boundaries have to be chosen deliberately.

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 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 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.

Episteme: Distilling Knowledge into AI

Fri, 03 Oct 2025 11:24:58 +0100

🚀 Summary

When you can measure what you are speaking about… you know something about it; but when you cannot measure it… your knowledge is of a meagre and unsatisfactory kind. Lord Kelvin

Remember that time you spent an hour with an AI, and in one perfect response, it solved a problem you’d been stuck on for weeks? Where is that answer now? Lost in a scroll of chat history, a fleeting moment of brilliance that vanished as quickly as it appeared. This post is about how to make that moment permanent, and turn it into an intelligence that amplifies everything you do.