Listen To Our Podcast🎧

What are agentic AI architecture patterns?
Agentic AI architecture patterns describe how an AI agent is put together. They cover how it plans, which tools it calls, how it hands work to other agents and where a person steps in. Most published catalogs stop at the model and its tools, but for a CIO or CTO at a regulated firm, the pattern that decides whether an agent survives review is the one around them.
Every governed agent does five things in order. It takes in the case, understands it, weighs it, proves what it did and reports for a person to approve. Skip one and the decision can't be defended.
This guide maps the known patterns onto those stages and ends with a production checklist. Last updated 19 November 2026.
- Which agentic AI architecture patterns exist, in plain terms.
- How those patterns fit five stages of a governed agent.
- When one agent is enough and when several are worth the cost.
- Where a person must be able to pause, override or stop an agent.
- What to check before an agent goes into production.
Request the five-stage diagram with the two wraps

The five-stage diagram with the two wraps
Map every agentic AI architecture pattern onto five stages of a governed agent, with governance controls and data protection on every step, so each step has an owner and a record.
- Take in: the agent reads the case from the systems you already run, with scoped tools and its own identity.
- Understand: the agent assembles the customer, supplier, claim or application into one view before anything is scored.
- Weigh: your rules run first as hard checks, then the agent scores the case and recommends, with reasons.
- Prove: every step goes into one evidence record with inputs, time, actor and the rules in force.
- Report and learn: the agent drafts the report, a person approves it, and models change only after a person approves.
Agentic AI architecture patterns describe how an AI agent is put together: how it plans, which tools it calls, how it hands work to other agents and where a person steps in. A governed agent runs them inside five stages in order, take in, understand, weigh, prove, and report and learn, with governance controls and data protection on every step.
Agentic AI architecture diagram: five stages and two wraps
The diagram most teams draw is a model in the middle with tools around it. That leaves out what a reviewer, an internal auditor or a supervisor will ask about. In the governed version, five stages run in order and two controls wrap every one of them.
- Take in passes the case records to understand. Understand passes one assembled view of the case to weigh. Weigh passes the checked and scored recommendation to prove. Prove passes the evidence record to report and learn.
| Stage | What the agent does | Patterns you'll use here | What a person owns | What gets recorded |
|---|---|---|---|---|
| Take in | Reads the case from your existing systems | Tool use, MCP, routing | Which systems and fields it may read | Every source read, with identity |
| Understand | Assembles the customer, supplier or claim into one view | Planning, ReAct loops, parallel lookups | What "enough context" means for each case type | The assembled view as it stood |
| Weigh | Runs your rules first, then scores and recommends | Prompt chaining with gates, evaluator loops | The rules, thresholds and risk bands | Checks that ran, score, reasons |
| Prove | Writes every step into one evidence record | Checkpoints, traces | Retention and who may read the record | Inputs, time, actor, rules in force |
| Report and learn | Drafts the report, learns from feedback | Approval interrupts, reflection | Approving the report and model changes | The approval and the reviewer |
| Governance controls (every step) | Works inside a mandate | Guardrails, kill switch | The mandate and autonomy budget per risk band | Every stop and override |
| Data protection (every step) | Uses its own identity and the least access | Scoped tool permissions | Access approval and where data lives | Every access decision |
The first figure shows the five stages in order. Take in passes the case records to understand. Understand passes one assembled view of the case to weigh. Weigh passes the checked and scored recommendation to prove. Prove passes the evidence record to report and learn. Governance controls and data protection wrap all five.
The order matters more than the tools. An agent that weighs before it understands scores half a picture. The gap between what was decided and what you can show later is the replay gap, and the prove stage closes it.
Key insight: an auditor won't ask which pattern you used. They'll ask who approved the outcome and what was recorded, and no pattern in the catalogs answers either question. The five stages and the two wraps do.
Agentic AI architecture patterns: the catalog in plain terms
The patterns have settled into a small, shared vocabulary. Anthropic's guide to building effective agents separates workflows, where models and tools follow predefined code paths, from agents, where the model directs its own process and tool use. Its catalog of workflows is prompt chaining, routing, parallelization, orchestrator-workers and evaluator-optimizer.
| Pattern | Stage where it fits |
|---|---|
| Routing, tool use | Take in |
| Planning, parallelization, orchestrator-workers | Understand |
| Prompt chaining with checks, reflection | Weigh |
| Checkpoints and traces | Prove |
| Approval interrupt, evaluator-optimizer | Report and learn |
Prompt chaining breaks a task into steps where each call processes the output of the previous one, and you can add programmatic checks on any step in between. Routing classifies an input and sends it to a specialised follow-up task. In the orchestrator-workers workflow, a central model breaks down tasks, delegates them to worker models and combines their results. In the evaluator-optimizer workflow, one call generates a response while another provides evaluation and feedback in a loop.
Andrew Ng's four agent strategies cover the same ground from the model's side, with reflection, tool use, planning and multi-agent collaboration. Two research papers sit under most agent loops. The first, ReAct, has the model produce reasoning traces and task-specific actions in an interleaved way. The second, Reflexion, reinforces language agents through linguistic feedback instead of updating model weights.
None of these patterns says who approves the outcome or what gets kept, which is why the wraps sit outside all of them.
Anthropic's advice is to find the simplest solution possible, which might mean not building an agentic system at all. Microsoft's guidance on agent orchestration patterns tells teams to use the lowest level of complexity that reliably meets their requirements.
How do you pick between one agent and several?
Start with one agent, and add more only when the work splits cleanly. Google Cloud's guide to choosing a design pattern recommends that teams early in agent development start with a single agent.
- If the steps of a task are known in advance, the task goes to a workflow with fixed steps and checks between them. If the steps of a task can't be known in advance, the task goes to a single agent with tools. A single agent becomes a multi-agent system only when the work splits into independent parts that justify the extra cost. The workflow and the single agent both send their output to the reviewer, who makes the call.
The second figure shows how to pick a pattern. If the steps of a task are known in advance, the task goes to a workflow with fixed steps and checks between them. If the steps of a task can't be known in advance, the task goes to a single agent with tools. A single agent becomes a multi-agent system only when the work splits into independent parts that justify the extra cost. The workflow and the single agent both send their output to the reviewer, who makes the call.
Microsoft notes that multi-agent orchestration adds coordination overhead, latency and failure modes. The cost is measurable. In its write-up of its multi-agent research system, Anthropic reported that its agents typically use about 4 times more tokens than chat interactions, and multi-agent systems about 15 times more. The same team found its multi-agent research system beat a single agent by 90.2% on an internal research evaluation, especially on breadth-first questions that pursue several independent directions at once.
Multi-agent designs earn their cost on wide research tasks like that. They're harder to justify for a case that needs one consistent judgment.
Failures multiply too. In Don't Build Multi-Agents, Cognition argues that agents should share full context and traces, because actions carry implicit decisions and conflicting decisions carry bad results. A 2025 study of more than 1,600 annotated traces across 7 multi-agent frameworks identified 14 distinct failure modes. For a regulated case, two agents reaching different conclusions on the same file is a finding for the reviewer to resolve.
Our post on multi-agent AI systems in finance covers where several agents do help. For the head term and a bank rollout plan, see our guide to agentic AI architecture for regulated firms.
Where does a person step in?
A person steps in wherever the outcome is high risk, irreversible or legally significant.
- Before any action with effect, the agent hits an interrupt and the run pauses with its state saved. The interrupt sends the prepared case and the proposed action to the reviewer. If the reviewer approves, the run resumes and the tool call goes ahead. If the reviewer rejects or edits, the agent gets the reason back and the run goes on from the saved state. Either way, the reviewer's decision and reason go into the evidence record.
The frameworks now build this in. LangGraph's interrupts pause the graph at a chosen point, save its state and wait for outside input before going on. Microsoft's Agent Framework lets workflow steps send a request to a human operator and wait for the response before going on. OpenAI's Agents SDK runs guardrails on the input, on the final output and on each guarded tool call.
The third figure shows an approval interrupt. Before any action with effect, the agent hits an interrupt and the run pauses with its state saved. The interrupt sends the prepared case and the proposed action to the reviewer. If the reviewer approves, the run resumes and the tool call goes ahead. If the reviewer rejects or edits, the agent gets the reason back and the run goes on from the saved state. Either way, the reviewer's decision and reason go into the evidence record.
Regulators describe the same controls. Singapore's IMDA framework for agentic AI calls for significant checkpoints in the workflow that require human approval. The EU AI Act requires high-risk AI systems to be designed so natural persons can effectively oversee them. The people overseeing must be enabled to override or reverse the output and to interrupt the system through a "stop" button or a similar procedure.
The Financial Stability Board's October 2026 sound practices on AI and agentic AI describe a kill switch as a mechanism enabling human intervention to halt or constrain AI operations. The Monetary Authority of Singapore's AI risk management guidelines describe kill switches as mechanisms to deactivate AI quickly if it exceeds risk tolerances.
Our human-in-the-loop review control sets out the review requirements, and our kill switch definition covers how stopping works.
Who owns which decision in the architecture?
The CIO or CTO picks the patterns and platform; the process owner writes the mandate; the reviewer decides each case; risk or compliance sets the risk bands; IT and security own identity, access and the kill switch; agents gather, check, weigh and prepare.
| Component | Responsibility | Boundary |
|---|---|---|
| CIO or CTO | Picks the patterns, the platform and where agents run. | Doesn't approve individual cases. |
| Process owner | Writes the agent mandate by risk band and keeps the hard checks current. | Doesn't let a vendor write the mandate. |
| Reviewer or approver | Decides each case the mandate sends them, using the prepared file. | Doesn't approve without the evidence record. |
| Risk or compliance | Sets the risk bands and checks shadow mode results before autonomy widens. | Doesn't run day-to-day cases. |
| IT and security | Gives each agent its own identity, the least access and a tested kill switch. | Doesn't widen access without the process owner. |
| AI agents | Gather evidence, run the checks, weigh the case and prepare a recommendation. | Don't approve, reject, file or close a case. |
The reviewer decides every case the mandate sends them, every action with effect passes an approval interrupt, high risk always goes to a person, risk or compliance decides when autonomy widens, autonomy beyond preparing the case is set by the firm band by band, and any agent can be stopped with its kill switch.
How do agents connect to tools and to each other?
Two open protocols now carry most connections, and both need identity and permissions designed around them.
- Each agent connects to your systems through an MCP server that exposes only the tools its mandate allows. The MCP server calls the system of record with the agent's own identity, not a shared login. When one agent needs another, it sends the task over A2A to the other agent without sharing its memory or tools. Every call through the MCP server lands in the evidence record.
MCP, the Model Context Protocol, is an open-source standard for connecting AI applications to external systems. In December 2025 Anthropic announced it was donating MCP to the Agentic AI Foundation, a directed fund under the Linux Foundation. A2A, the Agent2Agent protocol, is an open protocol created by Google for agent-to-agent communication, and it launched as a Linux Foundation project in June 2025. A2A lets agents interact without sharing internal memory, tools or proprietary logic.
The fourth figure shows the connections. Each agent connects to your systems through an MCP server that exposes only the tools its mandate allows. The MCP server calls the system of record with the agent's own identity, not a shared login. When one agent needs another, it sends the task over A2A to the other agent without sharing its memory or tools. Every call through the MCP server lands in the evidence record.
Connections are also where attacks arrive. NIST's Center for AI Standards and Innovation says many AI agents are vulnerable to agent hijacking, where an attacker plants instructions in data the agent reads. OWASP traces excessive agency to excessive functionality, excessive permissions or excessive autonomy. The FSB's sound practices describe giving each AI agent a unique identifier, so a firm can see which actions it took and which humans configured and oversaw it.
Agentic AI architecture examples
These examples show how one set of stages fits different departments. They're patterns we recommend, not customer deployments.
| Department and case | Weigh | Who decides |
|---|---|---|
| Compliance: a transaction monitoring alert | Rules and thresholds first, then a score with reasons | The analyst, with compliance sign-off on any report |
| Finance and AP: a supplier bank-detail change | Callback and hold rules first, then a risk note | The approver, after a callback |
| Claims: a new motor claim | Coverage rules first, then a fraud and severity view | The claims handler |
| IT and security: a privileged access request | Access policy first, then a risk view | The access owner |
Each row follows the same three steps.
- Your rules run first as hard checks.
- The agent weighs what passes and prepares a recommendation with its reasons.
- A named person decides, and the decision goes into the evidence record.
Checks before judgment is our name for that order, and it's the FluxForce version of what the industry calls decision intelligence.
What do regulators expect from the architecture?
Regulators ask what the agent did, who could stop it and who was accountable.
Under the EU AI Act, high-risk AI systems must technically allow automatic recording of events over the system's lifetime. Deployers must keep those logs for at least six months, and financial institutions keep them in the documentation their financial services law already requires. Regulation (EU) 2026/1744 moved the high-risk duties for Annex III systems to 2 December 2027.
In the US, the April 2026 interagency model risk guidance from the OCC, the Federal Reserve and the FDIC puts generative and agentic AI outside its scope. In our view that leaves the architecture to carry controls the guidance doesn't spell out.
The FSB says firms should set a risk tolerance for each agentic AI use case at the start, which informs how much autonomy and access they grant.
Most firms aren't there yet. Deloitte's 2026 State of AI in the Enterprise found only 21% of companies report a mature model for agent governance. KPMG's third-quarter 2026 AI pulse survey found 49% of leaders have defined high-risk use cases where they don't allow autonomous decision-making by agents. Gartner expects 40% of enterprise applications to include task-specific AI agents by the end of 2026, up from less than 5% in 2025. In June 2025 it also predicted that over 40% of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear business value or inadequate risk controls.
What does this look like in practice?
The scenario below is invented to show the process, not drawn from a real customer. A 600-person payments firm's CTO has a demo agent that reviews new merchant applications. The head of compliance won't let it near live cases until the team can show how it's governed.
The model didn't change between demo and production. The stages, the record and the person at the end did.
Illustrative scenario: moving a merchant-review agent into production
Illustrative scenario, not a customer result.
This scenario is invented to show the process, not drawn from a real company or a FluxForce customer.
- The team keeps one agent and drops a planned second agent for website checks.
- The agent reads the application system and the sanctions screening results through MCP servers with read-only tools and its own identity.
- The firm's onboarding rules run first. An application that fails one goes straight to a reviewer with the rule that fired.
- For applications that pass, the agent assembles the merchant, its owners and its website into one view and prepares a recommendation.
- Every recommendation hits an approval interrupt. A reviewer approves, edits or rejects, and the reason goes into the evidence record.
- In six weeks of shadow mode, the team compares the agent's recommendations with its reviewers' decisions, and internal audit replays a sample before anything widens. The model is the same one from the demo. The stages, the record and the person at the end changed.
How does FluxForce approach agentic AI architecture?
FluxForce is the platform your departments run AI agents on. The agents investigate and prepare the work, a person makes the call, and every step leaves evidence an examiner can replay.
In take in, agents connect beside the ERP, CRM, case tool or core system you already run, and nothing is migrated. In understand, the agent assembles one view of the case before anything is scored. In weigh, your rules run first as hard checks, then the agent scores the case against your own history and recommends. In prove, every step goes into a tamper-evident evidence record. In report and learn, the agent drafts the report, a person approves it, and models change only after a person approves.
Governance controls apply on every step. Each agent works inside a mandate you set, you decide how much it does on its own in each risk band, high risk always goes to a person, and every agent has a kill switch with every stop recorded. Data protection applies on every step too, in SaaS, on-premise or hybrid deployments.
The proof layer is our name for the prove stage. It's the part of the platform that records every step an agent takes, with its inputs, time, actor and the rules in force, so any decision can be shown later. It's what we add to what the industry calls an agentic AI platform.
Financial crime and compliance is the first app line on the platform. AI agents that investigate AML, sanctions, fraud and KYC alerts and prepare the case. Your analyst makes the call, with evidence an examiner can replay. You decide how much each agent does on its own, and every one has a kill switch.
For the model side of the record, FluxForce AI Model Governance tracks which model version was live on any date. You can browse the AI agents on the platform, and our guide to AI agents in finance shows where autonomy stops inside a regulated firm.
Which sources support these patterns and controls?
Workflows versus agents; prompt chaining, routing, parallelization, orchestrator-workers and evaluator-optimizer; start with the simplest solution.
Model developer engineering guidance, December 2024.
2026-11-19
Agents use about 4 times and multi-agent systems about 15 times more tokens than chats; 90.2% gain on an internal research evaluation.
The developer's own internal evaluation, June 2025; not independent.
2026-11-19
More than 1,600 annotated traces across 7 frameworks; 14 failure modes.
Research preprint, 2025.
2026-11-19
Use the lowest level of complexity that reliably meets requirements; multi-agent orchestration adds coordination overhead, latency and failure modes.
Vendor architecture guidance.
2026-11-19
Human oversight by design; override and stop duties; automatic logging; logs kept at least six months.
EU law; Regulation (EU) 2026/1744 moved Annex III high-risk duties to 2 December 2027. The consolidated text has no legal effect.
2026-11-19
Unique agent identifiers; kill switch; risk tolerance set per use case at inception.
International standard-setter publication, October 2026.
2026-11-19
Significant checkpoints in the agentic workflow that require human approval.
Singapore voluntary framework, version 1.5, May 2026.
2026-11-19
Root causes are excessive functionality, permissions or autonomy.
Security community guidance.
2026-11-19
Many AI agents are vulnerable to agent hijacking through instructions planted in data.
US government technical blog, January 2025.
2026-11-19
Generative and agentic AI models are outside the scope of the revised model risk guidance.
US bank supervisory guidance, April 2026.
2026-11-19
Where does FluxForce AI Model Governance fit?
Once agents prepare the work, someone will ask which model produced a recommendation and whether it has changed since. FluxForce AI Model Governance keeps that part of the record. It tracks which version was live on any date, and every model version is tracked, compared and watched for drift once it's in production. If performance slips, you roll back to the previous version in one click.
Release needs the model owner's approval, so no model change goes live without a named approver, and every rollback is logged with who did it and why. It covers our agents' models and your own.
We'll inventory a set of your production models and show you what the record looks like before your next review.
See how AI Model Governance worksFluxForce doesn't replace your agent framework or your model provider, and AI Model Governance doesn't approve a model release on its own. The model owner approves releases and your reviewers make each call. FluxForce's agents don't approve, reject, block or file anything on their own, and any autonomy beyond preparing the case is yours to switch on, band by band, with a kill switch on every agent. Outside financial crime, ask which agents exist for your process today.
What should a CTO check before an agent goes into production?
- Draw the agent on the five stages and name what it reads, what it weighs, what it records and who approves.
- Pick the simplest pattern that works, and write down why a simpler one wasn't enough.
- Give each agent its own identity, the least access its mandate needs and read-only tools by default.
- Put an approval interrupt before every action with effect, and test that the run resumes from saved state.
- Run shadow mode on live cases and compare the agent's recommendations with your reviewers' decisions every week.
- Ask internal audit to replay a sample of cases from the evidence record before autonomy widens, and test the kill switch.
| Metric | Definition | Decision guardrail |
|---|---|---|
| Recommendation match | Share of shadow mode cases where the agent's recommendation matched the reviewer's decision. | Widen autonomy only for a case type with explained differences. |
| Replay rate | Share of sampled cases internal audit could replay without asking anyone. | Any case that can't be replayed is a finding. |
| Interrupt coverage | Share of actions with effect that passed through an approval interrupt. | Anything below all of them is a design defect. |
| Kill switch test | A recorded test that each agent stops at once when switched off. | No agent goes live without a passed test. |
- Patterns describe how an agent works. The five stages describe how it gets defended.
- Start with the simplest pattern, usually one agent with tools, and add agents only when the work splits cleanly.
- Put an approval interrupt before every action with effect, and record the decision either way.
- Give each agent its own identity, the least access it needs and a tested kill switch.
- An evidence record of every step closes the replay gap.
Conclusion
Patterns are how an agent works. Stages are how it gets defended. Pick the simplest pattern that does the job, run it inside the five stages, and keep a person on every call your firm will be asked to explain.
We think the agents that reach production at regulated firms will be the ones whose records an internal auditor can replay without calling the team that built them. Our audit trail evidence checklist lists what each record should hold.
Request the five-stage diagram with the two wraps

Frequently Asked Questions
Start from the decision, not the model. Write down what the agent reads, weighs and records and who approves the outcome, then map those onto the five stages. Choose the simplest pattern for each stage, since Microsoft advises the lowest level of complexity that reliably meets your requirements. Add an approval interrupt before every action with effect, and give each agent its own identity and the least access it needs.
Build one agent first, as Google Cloud recommends teams early in agent development start with a single agent. Connect it to your systems through scoped tools, run your rules before its judgment, and save state at every approval point so a person can pause and resume it. Then run it in shadow mode against your reviewers' decisions.
The common workflow patterns are prompt chaining, routing, parallelization, orchestrator-workers and evaluator-optimizer, as Anthropic lists them. Andrew Ng adds four agent strategies, reflection, tool use, planning and multi-agent collaboration. ReAct, which interleaves reasoning and actions, sits under many agent loops.
Only for some tasks. Anthropic found multi-agent systems use about 15 times more tokens than chats, and they did best on broad research that splits into independent directions. A 2025 study found 14 distinct failure modes in multi-agent systems, so for a case that needs one consistent judgment, a single agent with good tools is easier to govern.
MCP connects an AI application to external systems such as data sources and tools. A2A connects one agent to another so they can exchange tasks without sharing internal memory, tools or logic. Both are open protocols under Linux Foundation governance, and neither one sets what an agent may do.
No. An agent can gather evidence and prepare a recommendation, but the firm stays accountable for the outcome. The EU AI Act requires that the people overseeing a high-risk system can override it or stop it. Put the reviewer at the approval point, and widen autonomy only where shadow mode results and an internal audit replay support it.
About the author

Sahil Kataria
Founder and CEO of FluxForce
Sahil works on secure AI and financial technology for regulated industries. His engineering background spans identity verification, payment security and compliance automation. He has led teams across Africa, the United States, Europe and India.
At FluxForce.ai, his focus is on explainable AI and auditable financial workflows. He writes for banking and compliance teams about the practical decisions behind these systems: how to assess risk, keep controls visible and introduce automation without losing accountability.
View Sahil Kataria author profile →Related articles
Primary solution: every model version tracked, compared and replayable.
The AI agents on the platform today.
Where autonomy stops inside a regulated firm.
The live post that owns the head term and a bank rollout plan.
Where several agents do help.
The review control behind every approval interrupt.


















Share this article