Six agent patterns cover every major control-flow choice in production AI systems. This overview shows why a seventh pattern adds nothing.
The Only 6 AI Agent Patterns You'll Ever Need · 9 minsTranscript14 entries
Instructor:Six patterns, not five, not ten. Six. In this video, we'll prove why six compositional patterns cover every enterprise use case we've talked about so far, and why adding a seventh would be redundant. These six patterns map to five orthogonal control-flow axes. It's a similar architecture principle to what you see in messaging systems, distributed systems, and enterprise application integration. Here the axes are execution order, concurrency, iteration, delegation, and complexity.
Instructor:Delegation then splits into two choices: coordinator and agent-as-tool, based on state control, and output control, while complexity gives you the atomic-versus-composite distinction that starts with the single agent. Adding a seventh pattern would most likely duplicate an existing axis, or be a composition of two patterns that already exist. Now let's quickly go through a couple of case studies and make this concrete. The actual systems are far more complex than what we present here, but this gives you the idea.
Instructor:The first system I'm going to show is basically a portfolio manager system, an agent system, that provides continuous validation while the portfolio manager handles the analysis through deterministic and non-deterministic approaches. It runs many deterministic quantitative agents behind the scenes, while the LLM makes higher-level choices about how to route decisions and how to choose the correct risk model. The risk model and the design are both verifiable and reproducible.
Instructor:But the LLM adds something very important, which is dynamic decision-making, while still allowing a thoughtful manager to remain in the human loop. And this implements all six patterns, as you can see. Here we see all six patterns, from market data to trade execution: parallel, sequential, loop and critique, coordinator, agent-as-tool, and single agent. This is a perfect industry example that shows how complex systems can still be designed with these six simple architecture patterns.
Instructor:We don't need additional primitives, because compositions of one, two, or more patterns give us any agent design we are likely to need. The same implementation works for a purchase department, or for e-commerce, where it can help teams make the right decisions about market conditions, timing, raw-material purchases, and upstream dependencies. The same idea also works in healthcare, where it gives teams a strong human-in-the-loop
Instructor:decision system based on parallel agents that can make 70 to 80 percent of decisions autonomously. So the bottom line is this: each one of these categories could be a one- or two-hour workshop on its own. But what we show here is the power of composing these design patterns. These patterns don't need to stand alone. They compose together to cover any use case or larger business process we are anticipating. Agentic AI is really about translating the business process, what we used to call BPM, into agentic AI BPM,
Instructor:then adding the right agent actors where needed. These six agent patterns generally cover all the use cases we are likely to need in a real architecture. When someone proposes a seventh pattern, apply this test: does it introduce a new control-flow axis? Or is it already covered by one of the six we just discussed? Or is it a composition of two patterns that already exist? Map-reduce is parallel plus sequential aggregation. A retry agent is basically loop and critique with a pass-through predicate.
Instructor:A hierarchical multi-agent system is a coordinator with nested coordinators. A supervisor-worker pattern is either coordinator or agent-as-tool. It depends on state ownership. Do we want to pass ownership to the specialist agent, or do we want to keep ownership with the primary agent? Every proposed seventh will most likely collapse into these existing six primitives. So let's make the decision process practical. If you have a new agent architecture problem, start here.
Instructor:This helps in most cases. First question: can a single agent with tools handle the entire task? If yes, you're done. That's a single agent. Straightforward task, one agent, model-driven execution, and tool orchestration where needed. If one agent is not enough, ask: do the steps require a defined execution order? If yes, the dependency pipeline moves through shared state. That's the sequential agent. Do you have independent subtasks? If not, sequencing is what you need.
Instructor:If subtasks are independent of each other, then the answer is a parallel agent. Does the output need iterative refinement, based on quality criteria? Then your choice is pretty straightforward. It's loop and critique. Refinement means generator plus evaluator in a bounded action loop. Now, do you need dynamic routing? If refinement isn't the issue, but you need dynamic routing, then you decide where the state should live. Do you want to control the state, or do you want to pass the conversation flow,
Instructor:and that decides it. If you want to own the state, that becomes the coordinator. The coordinator delegates and transfers state, and now the specialist takes over the conversation. If you don't need specialist-owned state, and you want to keep state with the primary agent, then agent-as-tool is the right pattern. The primary agent calls the specialist, gets the result, and keeps orchestrating. Six patterns and five control-flow axes. That gives you infinite compositions. That is the agent architecture toolkit.
Instructor:Start with the decision tree, then decompose your flow. Nest patterns until the architecture matches the problem. However, I do want to leave you with one practical piece of advice. This comes from my one and a half to two years of experience with agentic AI, spanning across multiple domains: simple is better. Agentic AI complexity can spiral up very quickly. So design discipline and standardization matter far more than any buzzword discussion we may have in conventional software engineering.
Instructor:Agentic AI amplifies complexity, and it can spiral up very quickly, to the point where managing the complexity and the existing system becomes very difficult. It can also lead to surprisingly high levels of technical debt. So the best advice I can give is this: keep it simple, focus on a finite set of patterns, master them, observe them well, design them well, and make better decisions. That is the key to agentic AI success. As we sometimes say in markets, profit is a byproduct.
Instructor:The real product you are after is risk management. And I would put that exact same statement in the context of agentic AI architecture. Productivity and value are the byproducts it gives you. Risk management is what you are really after. So happy coding, and happy agentic AI coding. Make sure you subscribe and follow this playlist. I'll probably add one or two ad hoc videos based on a couple of other edge cases that are still yet to be recorded. And thank you very much. I'll see you in the next video.
Learning Objectives5
Map each of the six patterns to one of five orthogonal control-flow axes
Explain the Unix analogy: pipes, conditionals, loops, and functions compose to express any workflow
Demonstrate that enterprise workflows (trading, procurement, healthcare) decompose entirely into these six patterns
Prove that a hypothetical seventh pattern either duplicates an axis or is a composition of existing patterns
Use the interactive decision framework to select the right pattern for a given agent task
Q&A
Q & A
Q
Why not just use a single powerful agent for everything?
Single agents hit three walls as complexity grows: prompt bloat, nondeterministic execution, and weak multi-step control. The other five patterns exist specifically to address these limitations while keeping each component simple.
Q
Can I combine more than two patterns in one system?
Absolutely. The trading, e-commerce, and healthcare examples all combine multiple patterns. Coordinator routes to specialists. Specialists use Sequential pipelines. Some stages run Parallel branches. A Loop & Critique validates output. Agent-as-Tool wraps controlled service calls. Single Agent remains the atomic building block.
Q
How do I test whether a proposed seventh pattern is really new?
Apply the seventh-pattern test. Ask whether it introduces a genuinely new control-flow axis, or whether it decomposes into ordering, concurrency, iteration, routing, call-return, or atomic work. In practice, proposals like map-reduce, retry, hierarchical multi-agent, and supervisor-worker all collapse into compositions of the existing six.
Q
Do these patterns only apply to Google ADK?
No. ADK gives us concrete names, but the patterns are framework-agnostic. LangGraph, CrewAI, AutoGen, Semantic Kernel, and custom orchestrators all implement the same control-flow primitives under different APIs.
