Agentic AI, in five stages

Five stages take AI from prediction to the autonomous pursuit of goals. What each stage adds, and what it still can't do.

// Field Guide

Agentic AI, in five stages

Five stages take AI from prediction to the autonomous pursuit of goals. Each stage adds one new capability, and each one keeps an honest limit.

Click any stage to open it. Hover a term for its definition.

Start Raw data. Rules written by hand.

What this stage adds: statistical learning. Show the system enough labeled examples and it finds the pattern itself: classification, prediction, ranking. This is the foundation everything else stands on.

Supervised learning Unsupervised learning Reinforcement learning Regression & classification Decision trees & ensembles Recommendation systems

// The honest limit

Every model does one narrow thing, and a human still engineers the features. No fluency, no generality. A thousand small specialists.

What this stage adds: learned representation. Stacked neural networks discover the features themselves, which is why one architecture family, the transformer, now underpins nearly everything downstream.

Neural networks CNNs RNNs & LSTMs Transformers Attention mechanisms Embeddings Transfer learning

// The honest limit

Still a mapping from input to output. It recognizes and predicts brilliantly, but it doesn't create on demand, and it's hungry for data and compute.

What this stage adds: generation. Large models trained on internet-scale data can produce fluent, novel output in any modality. And because the interface is plain language, everyone becomes a user.

LLMs Diffusion models Multimodal generation Prompt engineering RAG Fine-tuning Hallucination mitigation

// The honest limit

It waits to be asked. No goals, no memory between conversations, no ability to act. And it is confidently wrong often enough that you must check.

What this stage adds: action. Wrap a model in a loop, hand it tools, and it can execute a task: search, book, file, fix. It checks its own work as it goes. One agent, one job, defined boundaries.

Tool use / function calling ReAct Chain-of-Thought Tree-of-Thoughts Task decomposition Working memory MCP Human-in-the-loop

// The honest limit

Planning horizons are shallow, errors compound over long chains, and the agent forgets the job when it's done. Useful, under supervision.

What this stage adds: orchestration. Multiple agents share persistent memory, split goals among themselves, hand off work, and improve from feedback. They pursue an outcome rather than executing a task.

Multi-agent orchestration Persistent memory Goal decomposition & chaining A2A protocol Delegation & handoff Self-improvement loops Long-horizon autonomy Observability & tracing

// The honest limit

Mostly frontier, not baseline. Errors propagate between agents, incentives drift, behavior emerges that nobody designed, and costs scale with ambition. The gap between demo and dependable is the whole story.

Where this is heading Goals pursued autonomously, with guardrails in place.

What runs underneath

These don't belong to one stage. They run underneath all five, and they're where most real-world success or failure happens.

Protocols & standards

MCP A2A WebMCP

Governance & safety

Guardrails Evals Human oversight Cost & resource management Audit & compliance

Interfaces & outputs

Code generation Voice (STT / TTS) Computer & browser use APIs & deployment