Notes from the architecture desk.
How we design, build and maintain agent teams that hold up in production: patterns, checklists and the trade-offs behind them.
Designing the agent team: roles, scope and handoffs
Before any code is written, an agentic system is a set of decisions about roles: which agents exist, what each one may read and change, where it must stop, and how work moves between them. This is the method we use to turn a real process into an agent team.
Read → ArchitectureHub-and-spoke agent architecture: how to build multi-agent systems that stay explainable
A hub-and-spoke architecture puts one orchestrator in charge of planning, routing and verification, and gives every specialist agent, tool and human reviewer a bounded job. Here is how the pattern works, when to use it, and the design rules that keep it safe in production.
Read → ArchitectureAgent team topologies: which hierarchy to build, and when
Hub-and-spoke is a good default, not the only shape. Single agents, two-level hierarchies, pipelines, blackboards and swarms each solve a different problem and fail in a different way. Here is how to choose the topology before you commit to it.
Read → MCP & toolsDesigning MCP servers and tools that agents can use safely
MCP gives agents a standard way to call tools, but a badly designed tool is still a badly designed tool. These are the rules we use for tool contracts, permissions, error handling and logging when we build Model Context Protocol servers for company systems.
Read → IntegrationConnecting agents to your APIs: identity, idempotency and the failures nobody plans for
An agent team is only as good as its connection to the systems that hold the work. These are the integration rules we apply when agents start calling a company's CRM, ERP, helpdesk and internal APIs: who they act as, what happens on a retry, and how failures are made legible.
Read → BuildAgent skills: packaging repeatable expertise so agents stop improvising
A tool is something an agent can do. A skill is how your company does it. Skills capture the procedure, the exceptions and the house rules as versioned, testable artefacts, so the same case does not get handled three different ways.
Read → Human in the loopDelegate to human: making escalation a first-class capability
Approval gates are planned. Delegation is not: it is what happens when an agent meets a case it should not resolve alone. Treating "hand this to a person" as a real tool, with a payload, an owner and a return path, is what separates an agent team that degrades gracefully from one that guesses.
Read → Human in the loopHuman-in-the-loop for agentic systems: where people belong, and where they only slow things down
"Keep a human in the loop" is easy to say and usually done badly: either every step waits for someone, or nothing does. This is how we decide which decisions get a human checkpoint, how the checkpoint is built so it is actually used, and how the loop shrinks over time without losing control.
Read → Operate & maintainOperating agentic systems: what maintenance actually means
A live agent team is not a finished project. Models change, APIs change, and the business changes its own rules without telling anyone. This is what ongoing maintenance of an agentic system involves, what to monitor, and what a sensible cadence looks like.
Read → Process designFrom manual process to automated flow: an architecture playbook
Most automation projects fail before the first model call, in the mapping and the boundaries. This is the sequence we use to take a process like invoice intake or support triage from hours of manual work to a running system with humans only where they matter.
Read →