Free · no account needed
The patterns production agents keep converging on, drawn as the one pipeline they compose into — with a weekly end-to-end synthesis and forecasts you can grade us on.
10 patterns · 1 synthesis · 3 forecasts
This week's synthesis
The pattern library tells you what each piece does. This is the missing article: the order a real build encounters them, where each hands off to the next, what each costs, and how each one fails in production.
· 13 min read · 8 sections
The library
Each of these keeps turning up independently in production systems that never talked to each other. What the list cannot show is the order they compose in — and that two of the arrows run backwards.
Select a stage in the diagram to read it.
Classify the request before anything expensive reads it, and send it down a branch built for its kind. Often no model at all — a regex, a length check, a lookup.
Patterns here: Routing
The categories drift out of sync with reality. Requests fitting no branch are silently jammed into the nearest one, and because the router 'succeeded', nothing alerts. Give it an explicit unclear bucket and track that bucket's rate.
One small, fast call — or zero. The cheapest stage in the pipeline and the one that decides how much the rest costs.
Decompose the task into ordered steps so that your code — not the model — gets to inspect what comes out between them. The gap between links is where validation lives.
Patterns here: Prompt Chaining
Error compounding. A slightly wrong extraction in step one becomes a confidently wrong answer in step three, and the output reads fluently enough that nobody suspects the middle. A chain with no checks between links is one long prompt with extra latency.
One call per link, latency additive. Buys back more than it spends only if something actually reads the intermediate output.
The part you could not script. The model interleaves reasoning with tool calls, observes each result, and decides its own next step — decomposing into workers where the subtasks are derivable, fanning out where they are independent.
Patterns here: ReAct (Reason + Act) Orchestrator–Workers Parallelization Autonomous Agent Loop
A plausible wrong turn eleven steps ago, with everything after it confidently downstream. Uninformative tool errors are the usual cause: an agent that cannot read why something failed hallucinates a world model instead of querying one.
The expensive stage, and worse than linear — each iteration re-reads the growing transcript, so a twenty-step loop pays for its history twenty times.
Make quality a mechanism rather than an aspiration. One pass criticises against explicit criteria and the work is revised; across attempts, a failed episode leaves a written lesson the next attempt reads.
Patterns here: Evaluator–Optimizer Reflexion
The evaluator cannot detect the failures you care about, so the loop converges on output that satisfies the evaluator — well-formatted, confident, approved wrongness, which survives review in a way obvious wrongness does not. Red-team the evaluator with known-bad outputs and write down its catch rate.
A full generation per revision cycle. Pays only where judging is genuinely cheaper than producing.
Decide what survives the request — and, more importantly, what this system must be structurally unable to remember. Working context is compacted; episodic memory is scoped in the schema, not in the prompt.
Patterns here: Memory Architectures
Two quiet ones. Poisoning: whatever gets written is trusted by later runs, so a wrong answer writes itself into every future session. Staleness: a remembered fact has no expiry and the world moves, so the system cites it with the confidence of experience.
Storage is cheap; the bill is retrieval on every subsequent request, plus the compaction that silently sheds the caveats and the reasoning that ruled things out.
Everything irreversible or externally visible stops here for a human. Classify by reversibility and blast radius, not by how nervous the action makes you.
Patterns here: Human-in-the-Loop Gates
Approval fatigue from gating reversible work, until the gate is theatre that costs latency — or an approval surface showing the agent's summary rather than the actual message, SQL or amount, which is approving the self-report the gate exists to check.
Somebody's attention, which is the scarcest budget in the system. A gate must never block the loop: write a pending-approval record and carry on.
01
Split a task into an ordered sequence of LLM calls, each working on the previous step's output. Trades latency for accuracy on tasks that decompose cleanly into fixed subtasks.
workflowdecomposition
02
Classify an input first, then dispatch it to a specialized prompt, model, or tool path. Keeps simple cases cheap and lets hard cases get a bigger model or more context.
workflowclassification
03
Run independent subtasks concurrently (sectioning) or run the same task multiple times and vote/aggregate (voting). Useful when subtasks don't depend on each other's output.
workflowthroughput
04
A central orchestrator dynamically breaks a task into subtasks and delegates to worker LLMs, then synthesizes their results. Unlike static parallelization, the subtask list isn't known in advance.
multi-agentdelegation
05
One LLM call generates a response; another evaluates it against explicit criteria and returns feedback, looping until the evaluator is satisfied. Effective when quality is hard to specify up front but easy to critique.
self-critiquequality
06
Interleave explicit reasoning traces with tool calls, feeding each observation back into the next reasoning step. The foundation most tool-using single agents still build on.
reasoningtool-use
07
An agent verbally critiques its own failed attempt, stores that reflection in episodic memory, and retries with the lesson in context — reinforcement learning without gradient updates.
self-critiquememory
08
An LLM plans, acts via tools, and observes results in an open-ended loop, checking in with a human or ground-truth signal at the end rather than at each step. Powerful and unpredictable — needs guardrails.
multi-agentautonomy
09
Episodic (what happened), semantic (what's true), and procedural (how to do things) memory, each with different retrieval and write strategies, layered to give an agent continuity across sessions.
memorystate
10
Insert mandatory approval checkpoints before irreversible or high-blast-radius actions (payments, deletions, external messages), independent of how autonomous the rest of the loop is.
safetycontrol
Forecasts
Every one names an exact, checkable fact and a date. We publish the probability we assigned before the answer was known, and we leave it up afterwards.
Open · resolves 31 Dec 2026 60%
How this gets graded: Check each framework's official docs/changelog on 2026-12-31. Resolves YES if at least one exposes an evaluator-optimizer construct directly in its API (e.g. a named node/decorator/class), not merely a tutorial showing how to build one manually.
Evaluator-optimizer already appears as a documented pattern in Anthropic's agent-building guidance and is conceptually simple to formalize as a primitive (generate -> evaluate -> loop). Frameworks converge on documented patterns quickly once demand is visible, but 5 months is a short window for a specific API addition to ship and stabilize across even one major framework.
Sources: Anthropic — Building Effective Agents
evaluator-optimizerframeworksprimitives
Open · resolves 31 Dec 2026 55%
How this gets graded: Check the project's official release notes/GitHub releases on 2026-12-31. Resolves YES if a release explicitly tagged 1.0 (or described as stable/GA, not preview/beta) exists by that date.
Merging two previously separate frameworks (Semantic Kernel, AutoGen) into one SDK is a large surface-area change; Microsoft has historically taken multiple preview cycles to stabilize major SDK rewrites. An 8-month window from initial ship to GA is plausible but not clearly favored either way.
Sources: Best AI Agent Frameworks 2026 — Alice Labs
microsoftagent-frameworkrelease
Open · resolves 31 Dec 2026 70%
How this gets graded: Check Metaculus's published AI Forecasting Benchmark / FutureEval results for the next leaderboard update after today. Resolves YES if the top entry is documented as using ensembling across multiple models or multiple independent research passes; NO if it's a single model/single pass.
Ensembling and multi-pass research are cheap to add on top of any base forecaster and have a strong track record of beating single-shot predictions in both classical forecasting and LLM-based settings; several community Metaculus bots already use ensemble/multi-agent approaches, suggesting the field has already converged this direction.
Sources: Metaculus/forecasting-tools · FutureEval | Metaculus
forecastingensemblingbenchmarks
Easyly is built by agents running these patterns against real gates — every change here passes a mechanical evaluator before it ships. This is the reference we work from, kept in the open because we would rather be checked than believed.