Compare AI Agent Architecture Build Types
What are the main ways to build an AI agent?
Teams build AI agents five ways: a code-defined workflow with LLM steps, a self-hosted vendor agent SDK, a ReAct loop, an RPA flow with LLM steps, or a multi-agent framework. The difference is what each leaves your team to build and run: policy logic, document handling, evals, evidence, capacity. For regulated document workflows, MightyBot ships those layers as a platform. Building wins when agent infrastructure is your product.
Workflows vs agents: the line that matters
Anthropic draws the line this way. "Workflows are systems where LLMs and tools are orchestrated through predefined code paths." Agents "are systems where LLMs dynamically direct their own processes and tool usage." For well-defined tasks, the same guide says, "workflows offer predictability and consistency," while agentic systems "often trade latency and cost for better task performance" (Anthropic, Building effective agents). LangGraph's documentation uses the same split: workflows "have predetermined code paths," agents "define their own processes and tool usage."
The cloud architecture guides agree on where to start. Microsoft's orchestration guide says to "use the lowest level of complexity that reliably meets your requirements" (Azure Architecture Center). Google Cloud writes, "we recommend that you start with a single agent" (Choose a design pattern for your agentic AI system).
The five build types on this page sit at different points on that line. A deterministic workflow with LLM calls sits at the workflow end; a ReAct loop and a model-directed multi-agent framework sit at the agent end; an SDK build, an RPA flow and a code-defined multi-agent graph sit in between depending on how they are configured. "Deterministic workflow" here means LLM steps inside code-defined control flow. It does not mean a BPM engine. The money side of the decision lives on the build vs buy cost and TCO page.
One label on the table needs a note. A fixed prompt chain, where "each LLM call processes the output of the previous one" along a code-defined sequence, is a workflow under both definitions above, and this page counts it with the deterministic build type. The ROI calculator labels one preset "ReAct / sequential prompt-chain agent"; that pairing is a calculator modeling convention for loops where the model directs each step and the context grows as it runs, and the ReAct row below describes that loop.
Five agent architecture build types compared
Planning presets come from the ROI calculator's planning assumptions and are editable assumptions, not measurements. The "policy" column describes the usual implementation of each build type; a team can add a separately governed policy layer to any of them and then owns building and running it.
| Build type | How control flows | Who writes and changes the policy logic | What your team hosts and runs | Calculator planning preset | Fits best when | Detail |
|---|---|---|---|---|---|---|
| Deterministic workflow plus LLM calls (includes fixed prompt chains) | Code-defined steps; LLM calls inside steps | Engineers, in code, or in configuration, decision tables or a policy service the team builds and governs | Orchestration, document pipeline, policy versioning, evals, evidence, capacity | 6 engineers, 15 months, 3 maintenance engineers; 6 steps per run, 5,000 tokens per step, 1.25 retry factor | Well-defined tasks you will maintain in house | Deterministic workflow plus LLM calls vs MightyBot |
| Self-hosted vendor agent SDK | Vendor loop with tools and handoffs | Engineers, in prompts, tools and code | Hosting, session state, auth gateway, telemetry, evals, evidence | 4 engineers, 10 months, 2 maintenance engineers; 8 steps, 4,500 tokens per step, 1.2 retry factor | One model provider, a shorter build, tasks that fit the SDK's loop | Self-hosted vendor agent SDK vs MightyBot |
| ReAct agent (calculator preset: "ReAct / sequential prompt-chain agent") | The model chooses each next step at runtime; the context grows as the loop runs | Prompts and tool descriptions, plus checks your team adds around the loop | Loop caps, tracing, evals over repeated runs, evidence | 6 engineers, 15 months, 2.5 maintenance engineers; 8 steps, 6,500 tokens per step, 1.35 retry factor | Open-ended tasks where steps cannot be predicted | ReAct agents in production vs MightyBot |
| RPA plus LLM workflow | Bot or flow; LLM steps inside | Flow designers plus prompt text | Bots, orchestrator, exception queues, licensing, evidence | 6 engineers, 15 months, 2 maintenance engineers; 6 steps, 4,500 tokens per step, 1.25 retry factor, plus an automation software reserve | Stable interfaces, systems without APIs, structured volume | RPA plus LLM workflow vs MightyBot |
| Custom multi-agent framework | Agents with roles coordinate at runtime (supervisor, handoffs, group chat) or along a code-defined graph | Engineers, in role prompts and orchestration code | Dependency graph, context contracts, shared state, cross-agent tracing, cost caps, evidence | 6 engineers, 15 months, 3 maintenance engineers; 10 steps, 9,000 tokens per step, 1.45 retry factor | Breadth-first, parallel research tasks | Custom multi-agent framework vs MightyBot |
| MightyBot platform | Compiled execution plan from plain-English policies; deterministic checks plus LLM steps | Your policy owners, in plain English; versioning, review and rollback supplied by the platform | Policies, thresholds and review gates; the platform runs execution, documents, evals and the why-trail | About 60 days to production (calculator: 2 months, editable); 0.25 FTE retained | Regulated, document-heavy, policy-bound workflows | How MightyBot differs |
Build-type definitions from Anthropic and LangGraph. Presets from the ROI calculator's planning assumptions. Code-defined multi-agent graphs from LangChain and Microsoft Agent Framework. MightyBot row from the June 2026 whitepaper and the build vs buy hub.
Compare each build type
Read each build type compared with MightyBot
What every build has to add for regulated document work
The architecture decides how the model is called. Whether a loan file, a claim or a draw request is processed correctly under policy depends on the layers around it, and every one of the five patterns needs the same ones.
- A document pipeline: ingestion, classification, splitting, extraction and validation across inconsistent packages.
- A policy layer, with versioning, review and rollback when the credit or claims policy changes, whether the rules live in code, in configuration or in a separate policy service.
- Evals that run over repeated runs and again at every model upgrade.
- Review queues for the cases the checks cannot settle.
- Decision evidence that ties each outcome to its source pages and the policy version in force.
- Capacity, retries and on-call.
The hub lists the eight layers a build has to add in detail, with the engineering each one takes.
How MightyBot differs
MightyBot is an AI agent platform for regulated document workflows. Your policy owners write the rules as plain-English policies. The Agent Compiler turns that description into the schemas, the workflow and a versioned execution plan. The description is the source, and the compiled plan is what runs in production.
Execution is hybrid. Deterministic checks and LLM steps run inside one compiled agent execution plan, and the platform picks the execution style per task: a compiled plan for structured work, stepwise reasoning where judgment is needed, planned sequences for long-running work.
Documents come in through the Document Intelligence Pipeline, which classifies, splits, extracts, normalizes, reconciles and recomposes each package and attaches document intelligence with page-level evidence pointers down to the character.
Policy Profiles let one workflow vary its rules by jurisdiction, counterparty or product; every decision records the profile in effect. Each decision also produces a why-trail: policy version, values checked, evidence pointers, evaluation results and the final determination, with compliance exports. The platform is model-neutral; the question is which execution style the task needs.
Proof, attributed to its deployment: 99% or higher accuracy was observed in one construction draw review deployment; validate other workflows on your own data. See production results.
When building makes sense
The hub's test holds here. Build when agent infrastructure is your core product IP, when the workflow is experimental or low-risk, or when your team is ready to own every layer above indefinitely, including evals, model upgrades, security and rollback. Run the numbers on the build vs buy cost and TCO page before you decide.
Each pattern has a case where it is a fine choice.
- A deterministic workflow plus LLM calls suits a well-defined task that splits into verifiable steps and a platform team that wants to own it.
- A self-hosted vendor agent SDK suits a team standardized on one model provider that wants a shorter build for tasks that fit the SDK's loop.
- A ReAct agent suits open-ended problems where the step count cannot be predicted, such as research and prototypes.
- An RPA plus LLM workflow suits stable interfaces, legacy systems without APIs and structured high-volume data movement.
- A custom multi-agent framework suits breadth-first research where work parallelizes and the task is worth the token cost.
How we are measuring the five architectures
MightyBot is running a first-party benchmark of these five architectures. The same regulated document workflows run on each build type, and the results will be labeled for what they are: vendor-run, on synthetic documents, specific to the configurations tested. The RPA arm runs through a proxy, which the published method will state. No results exist yet, and this page will link to them when they are published.
Sources
Sources and verification
- Anthropic, Building effective agents
- LangGraph, Workflows and agents
- Microsoft Azure Architecture Center, AI agent orchestration patterns
- Google Cloud, Choose a design pattern for your agentic AI system
- Thinking Machines, Defeating nondeterminism in LLM inference
- tau-bench (arXiv 2406.12045)
- Anthropic, How we built our multi-agent research system
- Microsoft Agent Framework overview
- MightyBot, July 2026 agent evaluation cost study
- MightyBot, ROI calculator planning assumptions
- MightyBot, The Policy-Driven AI Agent Platform, June 2026 whitepaper.
FAQ
Frequently Asked Questions
What is the difference between an AI agent and an agentic workflow?
Anthropic's definitions are the ones most teams use. Workflows are "systems where LLMs and tools are orchestrated through predefined code paths." Agents are "systems where LLMs dynamically direct their own processes and tool usage." In a workflow, code decides the next step and the model does the work inside it. In an agent, the model decides the next step. For well-defined tasks, Anthropic notes that workflows offer predictability and consistency (source).
Which agent architecture is most reliable for regulated work?
The ones that keep the decision outside the model. A deterministic check returns the same result for identical extracted inputs and policy version; a loop that lets the model decide each step can vary between runs. Extraction is a model step too, so full-document rerun agreement has to be measured. Temperature 0 does not fix this: in one published test, 1,000 identical requests at temperature 0 produced 80 unique completions (Thinking Machines). MightyBot compiles plain-English policies into deterministic checks and uses LLM steps for reading and judgment.
How do you make AI agent outputs consistent run to run?
Three things carry most of the weight: deterministic checks for every rule that can be expressed as one, versioned policies so a rerun executes against the policy snapshot in force, and evidence pointers that tie each value to its source page. The alternative is measurable. In MightyBot's July 2026 agent evaluation cost study, single-pass agent evaluation flipped about 1 in 5 borderline decisions between runs on the workload measured. A check fires the same way on the same extracted values; variance left in extraction still has to be measured.
Should we use a managed agent platform or build on an agent SDK?
An agent SDK gives you the loop, tool calling and tracing; your team hosts it and builds the document pipeline, policy logic, evals and evidence around it. A platform ships those layers and leaves your team the policies, thresholds and review gates. Choose the SDK when agent infrastructure is your product or the task fits the SDK's loop with little around it. The self-hosted vendor agent SDK comparison and the build vs buy hub go through the trade in detail.
When should you use a multi-agent system instead of a workflow?
When the task is breadth-first and parallel: research that spans more information than one context window, where separate agents can explore independently and the result is worth the extra tokens. Anthropic reports that multi-agent systems use about 15 times the tokens of a chat and recommends against them for tasks where all agents must share the same context (source). Microsoft's guidance is blunter: "If you can write a function to handle the task, do that instead of using an AI agent" (source).
How much does it cost to build an AI agent in house?
At the calculator default, the full three-year path for an internal build runs $8.1M to $11.9M across the five architecture presets, including the manual work that continues until launch and residual human review. The number depends on your volume, engineer cost and architecture, so treat the presets as a starting point and change them. The build vs buy hub explains the model and the ROI calculator lets you edit every input.