Introduction
'AI agent' has become one of the most overloaded terms in software. Founders use it to mean any LLM-powered feature; researchers use it to mean autonomous systems with goals and memory; vendors use it to mean whatever they want to sell you. This article cuts through the noise with a practical taxonomy that matches what we actually build for clients and what you will need to scope.
We group agents into four useful buckets: reactive agents, workflow agents, autonomous agents, and multi-agent systems. Each has a recognizable architecture, a predictable cost envelope, and a set of use cases where it is the right answer. Getting this right early saves you from the two most common agent mistakes: over-engineering a simple classifier into a multi-agent system, and under-scoping a genuine autonomy problem as a chatbot.
Reactive agents — the single-turn workhorse
Reactive agents take an input, perform one or two tool calls, and return a response. They are the simplest possible agent architecture and, for many use cases, the right one. Think of them as LLM calls with structured input and output — not chatbots, not autonomous explorers, just functions that happen to use a model.
Typical uses: lead enrichment from a URL, summarization of a document, translation with context awareness, classifying an inbound email and calling a routing API, extracting structured data from a contract. The reactive agent does exactly one well-scoped job and returns cleanly.
Architecture is minimal: a structured input schema, a prompt template, a small set of allowlisted tools, a structured output schema, and logging. Total code is usually under 300 lines. We build these in a single senior engineer-week when the integration is clear.
Cost envelope: $3k–$15k to build, under $0.05 per call in inference, production-ready in 2–3 weeks including tests. Reactive agents are the highest-ROI agent shape for most startups.
- Architecture: input schema → prompt → tools → output schema
- Use cases: enrichment, extraction, classification, routing, summarization
- Build cost: $3k–$15k. Inference: <$0.05/call.
- Timeline: 2–3 weeks for production readiness
Workflow agents — the stateful pipeline
Workflow agents execute a predefined sequence of steps with LLM decisions at specific branch points. Unlike reactive agents, they maintain state across multiple turns and can route through different branches based on intermediate results.
Typical uses: onboarding flows that adapt to user answers, multi-step document review (OCR → extract → validate → flag), customer support triage with escalation, research assistants that run a fixed sequence (search → read → summarize → cite).
Architecture is a directed graph: nodes are LLM calls or tool calls, edges are conditional transitions. LangGraph is the current standard tool for this shape once the graph has more than five nodes. For smaller graphs, a hand-rolled state machine in TypeScript or Python is usually cleaner and easier to debug.
Cost envelope: $15k–$50k to build, $0.10–$0.40 per completed workflow in inference, production-ready in 4–8 weeks. Workflow agents are the sweet spot for most B2B automation projects.
- Architecture: state machine with LLM decisions at branch points
- Use cases: adaptive onboarding, doc review, support triage, research assistants
- Build cost: $15k–$50k. Inference: $0.10–$0.40 per workflow.
- Tool of choice: LangGraph once graph has 5+ nodes
Autonomous agents — goal-directed and long-running
Autonomous agents pursue a goal across many steps, plan their own approach, and recover from intermediate failures. They can run for minutes to hours and chain dozens of tool calls. This is the most powerful and most expensive agent shape.
Typical uses: code generation and refactoring across a repo, competitive research across the web, customer onboarding that spans days and channels, internal-ops agents that maintain a task queue.
Architecture adds memory (short-term working context, long-term semantic memory), planning (task decomposition, plan revision), and robust recovery (retries, checkpointing, human-in-the-loop escalation). Observability is non-negotiable: you will debug these agents by reading traces.
Cost envelope: $60k–$250k to build, $0.30–$1.50 per completed task, production-ready in 10–20 weeks. Autonomous agents are rarely the right first project — start with workflow agents and graduate when you have a clear goal the workflow approach cannot handle.
- Architecture: planning, memory, tool use, error recovery, checkpointing
- Use cases: code generation, research, onboarding journeys, ops agents
- Build cost: $60k–$250k. Inference: $0.30–$1.50 per task.
- Start with workflow agents; graduate when you have a clear need
Multi-agent systems — orchestration of specialists
Multi-agent systems coordinate several specialist agents under a planner or supervisor. Think: a research agent, a coding agent, and a reviewer agent, each with focused context and tools, coordinated by a planner that decomposes the task.
Multi-agent architectures are powerful but expensive and hard to debug. Before committing, ask whether a single well-scoped agent with multiple tools could do the job. The answer is yes more often than teams expect.
When multi-agent does win: problems with clear decomposition (plan → draft → review → publish), problems requiring diverse context windows (each agent carries only what it needs), and problems where latency can be hidden by parallelization.
Cost envelope: $100k–$400k+ to build, $0.80–$3.00 per completed session, production-ready in 14–24 weeks. Reserve this architecture for problems you have evidence require it.
- Architecture: planner + specialists + reviewer, often with shared memory
- Win conditions: clear decomposition, diverse context needs, parallelizable
- Build cost: $100k–$400k+. Inference: $0.80–$3.00 per session.
- Rule of thumb: try a single well-tooled agent first
Choosing the right shape — a decision framework
Use this progression: if the task is one shot with structured I/O, use a reactive agent. If the task is a predictable pipeline with LLM decisions at branches, use a workflow agent. If the task is open-ended with dynamic planning and long-running execution, consider an autonomous agent. If multi-specialist coordination is genuinely required, build a multi-agent system.
The frequent mistake: reaching for autonomous or multi-agent patterns when a workflow agent would suffice. Autonomy is a cost and observability burden. Only take it on when you have evidence that the workflow pattern is insufficient.
Cost per task scales dramatically across shapes. If your product has consumer-scale volume, reactive and workflow agents are the only economically viable shapes at current pricing. Autonomous and multi-agent systems are typically B2B patterns where each task is worth $10+ in user-perceived value.
- Reactive → workflow → autonomous → multi-agent (escalate on evidence)
- Consumer-scale economics: stick with reactive or workflow
- B2B value-per-task >$10: autonomous or multi-agent becomes viable
- Only escalate when the simpler shape has been tried and found insufficient
Conclusion
The four-shape taxonomy gives you a clean way to scope any AI agent project. Match the architecture to the problem shape, start with the simplest viable option, and escalate only when you have evidence that a more complex architecture is required. The cost, risk, and debugging burden scales faster than the capability gain.
If you are designing an agent right now and want a second opinion, we are happy to pressure-test the architecture with a senior engineer. Getting the shape right at the start saves six-figure mistakes later.