A weekly email for people who build AI agents. Each issue takes one agentic architecture pattern, shows where it breaks in production and what to put around it. Free, once a week, in English or Polish.
You'll get one email to confirm. Unsubscribe with one click. Privacy policy
An agentic architect decides who is in control at every step. Some steps belong to the model, because they need judgment. Others belong to code, because they need to be right every time. A few belong to a person, because a mistake there is expensive or cannot be undone.
Most agent projects fail at that line, not in the prompt. The model gets a decision it should not have, or code tries to handle ambiguity it cannot. This newsletter is about drawing the line well.
A fixed workflow or a model that chooses its next step. The most expensive decision to change later.
What the agent may call, with which arguments, and what it may never touch.
Who checks the output. The model that wrote it is the worst possible judge.
Which actions wait for a person: payments, deletions, anything a customer sees.
What the agent remembers between steps and what it has to be told again.
How many steps, tokens and euros a run may use, and the record of what it did.
Most production systems are built from six shapes. The first five are workflows: code fixes the path and the model fills in the steps. The sixth is an agent: the model chooses the path. The taxonomy comes from Anthropic's Building effective agents. The failure modes and controls are what production adds to it.
A task split into fixed steps, each model call working on the previous one's output.
The task splits cleanly into steps that are the same every time: draft, then check, then translate.
An error in step one travels all the way to the end, and a gate that only checks the format lets wrong content through.
A deterministic check between steps that tests content, not shape: required facts present, numbers match the source.
A classifier sends each input to the path built for its kind.
Inputs fall into distinct kinds that deserve different handling, like FAQ, refund and bug report.
A wrong route is silent: the model classifies with full confidence and the ticket lands in the wrong queue.
Measure routing accuracy on labeled examples, and send anything risky to a person no matter what the router says.
Several model calls run at once, on separate parts or on the same task, and code merges the results.
The work splits into independent parts, or you want several independent answers to vote on.
Votes from the same model share its blind spots, and an aggregator that averages hides the disagreement you needed to see.
An explicit merge rule in code, and disagreement treated as a signal to escalate, not to average away.
Get the next pattern by email
One pattern, one case study and the AI news that matters, once a week.
You'll get one email to confirm. Unsubscribe with one click. Privacy policy
One model breaks the task down at run time and hands the pieces to workers.
You cannot know the subtasks in advance, like a change that touches an unknown number of files.
The plan grows without limit, workers get too little context, and nobody checks a worker's result before it is merged.
A cap on workers and spend, explicit context for each worker, and a check on every result before synthesis.
One model writes, another judges, and the draft loops until it passes.
You can state what good looks like, and a second pass measurably improves the result.
When the judge is the same model as the author, it approves its own work. Without a limit the loop never ends.
A judge that is a different model or plain code, criteria fixed before the loop starts, and a maximum number of rounds.
The model plans, calls tools, reads the result and decides the next step itself, in a loop.
The path cannot be known in advance and the environment is safe to experiment in.
Silent failures, cost with no ceiling, and irreversible actions taken with confidence.
A tool allowlist, a human gate on anything irreversible, a budget per run and an append-only log of every action.
Start from the top of the table and move down only when the simpler flow cannot do the job. Each row down buys flexibility and pays for it in predictability.
| Flow | Who picks the next step | Predictability | Cost and latency | Debugging | Pick it when |
|---|---|---|---|---|---|
| Prompt chaining | Code | High | Low | Easy | the steps never change |
| Routing | Model once, then code | High | Low | Easy | inputs come in distinct kinds |
| Parallelization | Code | High | Medium | Easy | parts are independent or need a vote |
| Orchestrator and workers | Model | Medium | Medium to high | Harder | subtasks appear at run time |
| Evaluator and optimizer | Model inside limits set by code | Medium | Medium to high | Medium | quality can be judged against fixed criteria |
| Autonomous agent | Model | Low | High, capped only by a budget | Hardest | the path is unknowable and the guardrails are in place |
Whatever the flow, the model only proposes. Code, a second checker and sometimes a person decide what actually happens. That idea runs through every issue. It is also the backbone of the Agent Engineering Radar, which sorts these techniques into production, pilot, experiment and silent-failure trap.
A draft, a tool call, a classification. Never an action by itself.
Schema, types, allowlists, limits. Cheap, fast and right every time.
A different model, a test or a rule. Never the author judging itself.
Only where a mistake costs money, trust or cannot be reversed.
Append-only, so a silent failure leaves a trace you can find.
Deeper dives on the blog:
One agentic architecture pattern with a flow diagram: when it fits, where it breaks and what to put around it.
A real failure or fix from production, anonymized. What happened, why, and the change that stopped it.
Only the releases and papers that change how you would build something this week. The rest is skipped.
No tracking pixel: opens are not counted. Unsubscribe with one click in any issue.
One pattern, one case study and the AI news that matters, once a week.
You'll get one email to confirm. Unsubscribe with one click. Privacy policy
Ex-CTO with a startup exit. I have shipped more than ten AI agents and systems to production and I write about what works in them and what breaks. The newsletter continues the blog: shorter, weekly, and with the diagrams.
More about me →The person who designs how an AI agent is put together: which steps a model decides, which steps code decides, which tools the agent may call, how its output is checked and where a person signs off. The newsletter is written for anyone doing that job, whatever their title.
Engineers, tech leads and CTOs who build AI agents into products or internal tools, and technical founders who have to decide how much to trust them.
Once a week. Nothing in between.
No. The newsletter is free.
There are two editions. You get the language of the page you signed up on. To switch, subscribe on the other language version and unsubscribe from the first.
No. The issues carry no tracking pixel, so opens are not counted.
Every issue has an unsubscribe link at the bottom. One click and the emails stop.
Join The Agentic Architect. Free, once a week, and you can leave with one click.
You'll get one email to confirm. Unsubscribe with one click. Privacy policy
