BUILD VS BUY

Compare AI Agent Architecture Build Types

Five ways teams build agents for regulated work, and what each leaves your team to own.

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 typeHow control flowsWho writes and changes the policy logicWhat your team hosts and runsCalculator planning presetFits best whenDetail
Deterministic workflow plus LLM calls (includes fixed prompt chains) Code-defined steps; LLM calls inside stepsEngineers, in code, or in configuration, decision tables or a policy service the team builds and governsOrchestration, document pipeline, policy versioning, evals, evidence, capacity6 engineers, 15 months, 3 maintenance engineers; 6 steps per run, 5,000 tokens per step, 1.25 retry factorWell-defined tasks you will maintain in houseDeterministic workflow plus LLM calls vs MightyBot
Self-hosted vendor agent SDK Vendor loop with tools and handoffsEngineers, in prompts, tools and codeHosting, session state, auth gateway, telemetry, evals, evidence4 engineers, 10 months, 2 maintenance engineers; 8 steps, 4,500 tokens per step, 1.2 retry factorOne model provider, a shorter build, tasks that fit the SDK's loopSelf-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 runsPrompts and tool descriptions, plus checks your team adds around the loopLoop caps, tracing, evals over repeated runs, evidence6 engineers, 15 months, 2.5 maintenance engineers; 8 steps, 6,500 tokens per step, 1.35 retry factorOpen-ended tasks where steps cannot be predictedReAct agents in production vs MightyBot
RPA plus LLM workflow Bot or flow; LLM steps insideFlow designers plus prompt textBots, orchestrator, exception queues, licensing, evidence6 engineers, 15 months, 2 maintenance engineers; 6 steps, 4,500 tokens per step, 1.25 retry factor, plus an automation software reserveStable interfaces, systems without APIs, structured volumeRPA plus LLM workflow vs MightyBot
Custom multi-agent framework Agents with roles coordinate at runtime (supervisor, handoffs, group chat) or along a code-defined graphEngineers, in role prompts and orchestration codeDependency graph, context contracts, shared state, cross-agent tracing, cost caps, evidence6 engineers, 15 months, 3 maintenance engineers; 10 steps, 9,000 tokens per step, 1.45 retry factorBreadth-first, parallel research tasksCustom multi-agent framework vs MightyBot
MightyBot platform Compiled execution plan from plain-English policies; deterministic checks plus LLM stepsYour policy owners, in plain English; versioning, review and rollback supplied by the platformPolicies, thresholds and review gates; the platform runs execution, documents, evals and the why-trailAbout 60 days to production (calculator: 2 months, editable); 0.25 FTE retainedRegulated, document-heavy, policy-bound workflowsHow 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.

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.