AI agents are software systems that pursue an objective by planning their own steps, calling tools, and checking their own work - and practitioners in 2026 classify them along three axes: how much autonomy they carry, how they are architected, and which domain they are specialized for. The textbook taxonomies you will find elsewhere (reflex agents, model-based agents, utility-based agents) describe decades of academic history accurately and describe almost nothing you can buy or build today. This page is the taxonomy teams actually use when they evaluate, compare, and deploy agents in production.
The three axes
The word agent is doing heavy lifting in 2026, covering everything from an autocomplete feature to a system that runs a week-long research program unattended. Anthropic's building effective agents research drew the line that stuck: workflows follow predefined code paths, while agents direct their own process and tool use at runtime. That gives you the entry test - a system is an agent when it decides steps for itself. Beyond the entry test, one label cannot carry the differences that matter, so the working taxonomy uses three independent axes. Autonomy tells you how much of the loop the system owns. Architecture tells you how it is built. Domain tells you what it is actually good at. Any real agent is a point in that three-dimensional space, and most confusion about agents is two people arguing across different axes. The full picture of what agentic AI means for a revenue organization is its own guide; this page is the map.
By autonomy: copilot to autonomous
Copilots assist a human who is doing the work: they draft, suggest, and complete, and every output passes through the person's hands before it counts. The human initiates everything and approves everything. Workflow agents own a defined slice end to end - a triage pass, an enrichment run, a report build - but a human or a schedule triggers them, and the boundaries of the slice are drawn in advance. Autonomous agents take an objective rather than a task: they plan the route, execute across as many steps and tools as the objective needs, verify their own output, and return finished work. The practical test for where a system sits is to ask two questions - who initiates, and who approves. Autonomy is also the axis where governance lives: the more of the loop the agent owns, the more the guardrails matter, which is why autonomous AI agents come with approval gates, budgets, and audit trails in any serious deployment. Autonomy is a dial rather than a badge, and the same product often exposes several settings of it.
By architecture: single, multi, agentic RAG
A single agent is one model in a loop with tools: plan, call, observe, repeat until done. It is the right architecture more often than the current enthusiasm suggests - simpler to debug, cheaper to run, and sufficient for most bounded objectives. A multi-agent system decomposes the objective across several specialized agents with a coordination layer - an orchestrator, a pipeline, or agents checking each other's work. The gains are specialization and parallelism; the costs are coordination overhead and new failure modes, and when one agent is not enough is a judgment call with real trade-offs. Agentic RAG puts the retrieval decisions inside the agent's loop: instead of a fixed retrieve-then-generate pipeline, the agent decides mid-plan what to look up, from which source, and whether the evidence it found is sufficient before it writes. It is the architecture behind agents whose work has to be grounded in live or proprietary data, and it builds on Retrieval-Augmented Generation the way agents build on plain generation. Architecture is a builder's axis: it predicts engineering effort and failure behavior, and it predicts very little about business outcomes on its own.
By domain: where agents specialize
Domain is the axis the market organized itself around, because tools, context, and verification are all domain-shaped. Coding agents work in repositories: they read codebases, write and run tests, and open pull requests. Research agents turn questions into sourced briefs - searching, reading, and cross-checking before they synthesize. GTM and growth agents do revenue work: prospect research, competitive teardowns, SEO and AI-visibility analysis, campaign and creative production. Operations agents keep systems truthful - CRM hygiene, data enrichment, reporting, and process glue. Browser and computer-use agents operate software the way a person does, clicking and typing through real interfaces; the AI browser wave made this class mainstream. Domain specialization is what separates an agent that demos well from one that ships work: an agent with the right tools, the right context, and domain-specific verification beats a general one carrying none of the three. AstroFabric's eight agents are a worked example of the pattern - Audit, Performance, Market Intelligence, AI Visibility, Pipeline, Content, Demand Generation, and Design each own one domain of growth, revenue, and digital operations work, as domain-specialized autonomous agents rather than one generalist wearing eight hats.
The taxonomy on one table
| Axis | The classes | The question it answers |
|---|---|---|
| Autonomy | Copilot / workflow agent / autonomous agent | Who initiates the work, and who approves it |
| Architecture | Single agent / multi-agent system / agentic RAG | How the system plans, coordinates, and grounds itself |
| Domain | Coding / research / GTM and growth / operations / computer-use | What work it is actually specialized to finish |
The axes are independent, and real products are points across all three at once - which is where the taxonomy starts paying rent. An AI SDR is a GTM-domain agent, usually at workflow-to-autonomous levels of autonomy, and very often agentic RAG underneath, because verified outreach depends on evidence retrieved per prospect. A coding copilot in an editor and a coding agent that opens pull requests overnight share a domain and differ entirely on the autonomy axis, which is why they feel like different products despite the shared adjective. And a research assistant that answers from its training data versus one that plans retrievals across the live web are the same domain and autonomy with different architectures, which shows up as the difference between plausible answers and sourced ones. When a comparison between two agents feels confusing, locate both on all three axes first; most apples-to-oranges arguments dissolve once you can see that the products sit on different points.
Using the taxonomy when you evaluate
The axes earn their keep at evaluation time. If you are buying, lead with domain and autonomy: does the agent specialize in the work you need finished, and does its autonomy level match your appetite for review - our catalog of AI agent examples shows what each domain class produces in production, and how agents execute the work walks one domain end to end. If you are building, lead with architecture: start single-agent, add retrieval when grounding fails, and split into multiple agents only when one demonstrably cannot carry the objective - the framework landscape maps the build-or-buy decision honestly. And treat vendor labels as claims rather than classifications. A product calling itself an autonomous agent while every action awaits a click is a copilot with better marketing, and the taxonomy exists precisely so you can tell.
Frequently asked questions
What are the main types of AI agents?
Practitioners classify agents on three axes: autonomy (copilots, workflow agents, autonomous agents), architecture (single agent, multi-agent systems, agentic RAG), and domain (coding, research, GTM and growth, operations, browser or computer-use). A real agent is a point on all three axes at once.
What is the difference between a copilot and an autonomous agent?
Who initiates and who approves. A copilot assists a human doing the work and every output passes through their hands. An autonomous agent takes an objective, plans its own steps, executes with tools, verifies its output, and returns finished work - with governance gates where the stakes require them.
Are the textbook agent types (reflex, model-based, goal-based) still used?
They survive in courses and textbooks as academic history, and they rarely appear in practice - no production agent in 2026 is bought or built as a simple reflex agent. The autonomy, architecture, and domain axes describe what teams actually deploy and compare.
What is agentic RAG?
An architecture where the agent makes retrieval decisions inside its planning loop - choosing what to look up, from which source, and whether the evidence suffices before generating. It replaces the fixed retrieve-then-generate pipeline of classic RAG with retrieval steered by the agent mid-plan.
Which type of AI agent should a growth team start with?
Domain-specialized workflow or autonomous agents aimed at work you already know needs doing - audits, research, pipeline building, reporting. Match the autonomy level to your review appetite, start with objectives whose output you can verify, and widen the mandate as the work proves out.
Sources
- Anthropic - Building effective agents
- Gartner - What is agentic AI?
- Lewis et al. - Retrieval-Augmented Generation (the original RAG paper)
Every playbook on this blog ships as a runnable mission.
Open a workspace and the playbook library is waiting - describe the outcome and the agents carry it end to end, on your plan's monthly credits.