The stack
What you would actually learn.
The previous page argues that nothing structural stops you building one of these. This is the honest version of that claim: six layers, the competence each one asks for, and where to go and read.
Read it as a build order rather than a menu. Each layer supplies one of the four parts every shipped agent decomposes into, and the layers are listed in the order you meet them when you actually build one. Nobody learns all six at once, and nobody needs to.
What you use, before what you build
The daily drivers.
Fluency with the tools everyone already has is the first rung; the build layers below are the second. Go deep on a few of these as a user before touching any framework, and pick one workflow to make yours.
- ChatGPT ↗
The general assistant most orgs meet first; custom GPTs and projects for repeatable work.
- Claude ↗
Anthropic’s assistant: long documents, careful reasoning, artifacts, and agentic coding.
- Gemini ↗
Google’s assistant, wired into Workspace and grounded in Search.
- NotebookLM ↗
Source-grounded research: it answers from the documents you give it, with citations.
- Perplexity ↗
Answer engine over live web sources; ask, read the citations, follow them.
- Google AI Studio ↗
The fastest way to prototype against Gemini models before any code exists.
- Notion ↗
The workspace whose AI reads your own pages and databases: notes become a queryable memory.
- Make ↗
Visual automation: watch a trigger, run a scenario, no code between apps.
- Zapier ↗
The other automation staple; thousands of app connectors and now agent steps.
- Manus ↗
A general autonomous agent: give it a goal and watch it plan, browse, and deliver.
- Copilot ↗
Microsoft’s assistant across Windows and 365; where most enterprise seats meet AI at work.
- Hugging Face ↗
The open-model hub: try models, spaces, and datasets without owning any infrastructure.
- Genspark ↗
Agentic search and super-agent workflows: it researches and assembles rather than lists.
Workflow deep-dives worth owning
Practice areas rather than products: pick one, run it with the tools above, and keep the receipts. The network security, log analysis, and code review dives land directly on the seats this page serves.
- AI for workflow automation
- AI for database management
- AI for testing and QA
- AI for cloud architecture
- AI for API development
- AI for microservices
- AI for network security
- AI for technical documentation
- Log analysis and alerts with AI
- Code reviews with AI
- AI for product management
Supplies: The shape of the loop
LLM Frameworks
The skill
Expressing a task as a graph of steps rather than one long prompt, and knowing where state lives between them. This is the layer where most people stop, and stopping here is why so many pilots are a chatbot with a search box bolted on.
The component library: models, prompts, retrievers, and the plumbing between them.
Worth knowingReached 1.0 alongside LangGraph, with a stability commitment through to 2.0.
Agents as an explicit state graph: nodes, edges, checkpoints, and a loop you can resume.
Data-first framework: ingestion, indexing, and querying over your own documents.
Models, datasets, and the transformers library underneath most of the open ecosystem.
Supplies: The rule
Multi-Agent Frameworks
The skill
Deciding which agent owns which decision, how work is handed between them, and what happens when one is wrong. Orchestration is an organisational design problem wearing a library, which is why the org chart beat comes before this one.
Supervisor and swarm patterns on the same state graph, with durable execution across handoffs.
Role-based crews: agents with a goal and a backstory, coordinated by a process.
Conversational multi-agent patterns, and the origin of much of the current vocabulary.
Worth knowingAbsorbed. AutoGen and Semantic Kernel merged into Microsoft Agent Framework, now at 1.0. AutoGen keeps bug fixes and security patches; new capability lands in the successor.
- Microsoft Agent Framework ↗Added by research
The merged successor: AutoGen orchestration on Semantic Kernel enterprise plumbing, Python and .NET.
Agents, handoffs between them, and guardrails that run beside execution rather than after it.
Worth knowingRead the handoffs and guardrails pages together. Handoffs are the delegation primitive; guardrails are where a policy becomes code.
Agents built on top of your indexes, so retrieval is the native move rather than a bolt-on.
Supplies: A bounded tool
Agent Tool Calling
The skill
Giving an agent a short, explicit list of things it may do, wiring the authentication behind each one, and being able to say what is not on the list. The security question in this whole stack lives here, and it is a question about what you withheld.
- Model Context Protocol ↗Added by research
The open protocol underneath most of this layer now: one way to expose a tool to any client.
Worth knowingNot on the source map, and the single biggest change since it was drawn. Both tools below now describe themselves in its terms.
Hundreds of app integrations with the OAuth handled, exposed to the agent as a small set of meta-tools it can search.
Worth knowingThe discovery pattern is worth studying on its own: the agent searches a catalogue rather than being handed every tool at once.
A registry for discovering, deploying, and managing servers, with auth and token refresh handled.
The provider-native path: define a function, let the model choose it, run it, return the result.
Supplies: A memory
Retrieval and Vector Storage
The skill
Chunking, embedding, and retrieving well enough that the answer is grounded, plus the judgement to measure whether retrieval actually helped. This is the layer that reproduces a subject matter expert, which is why it is the one to understand deeply.
Embedded vector store, no server to run: the fastest way to get a real index on a laptop.
Managed vector database. You stop thinking about the index and start paying for it.
Open-source vector database with hybrid search and a schema, self-hosted or managed.
Open-source vector database built for scale, with the clustering story to match.
Supplies: The model
Model Serving and Inference
The skill
Running a model where you need it, at a cost and latency you can defend, and knowing what changes when it moves from a hosted API to your own hardware. Data residency, tenancy, and what leaves your network are decided here.
High-throughput inference server. The default answer for serving open models seriously.
Local models with one command. The cheapest way to learn what a model does without a bill.
Not an AI tool. The web layer nearly every Python inference service is actually wrapped in.
Deploying a chain behind a REST endpoint.
Worth knowingSuperseded. LangChain now points new work at LangGraph Platform and keeps LangServe on bug fixes. Learn the successor first.
Serverless GPU compute from a Python decorator, which removes most of the infrastructure excuse.
Run and fine-tune published models behind an API, without owning any of it.
Supplies: A human who signs
Frontend and Interface
The skill
Building the surface where a person sees what the agent did and decides. Treat this as the last layer and you will build an interface that shows a verdict with no way to disagree with it, which is exactly the failure the gate exists to prevent.
A working interface around a Python function in a few lines. Built for demos and evaluation.
Data apps in pure Python. The fastest route from a notebook to something a colleague can open.
The production answer when the interface has to be a real product rather than a demo.
- AI SDK ↗Added by research
Streaming, tool calls, and generative interface primitives for TypeScript front ends.
Speech to speech with tools, handoffs, and guardrails attached to the live session.
None of this is the hard part. Three of the four parts are engineering, and the whole of this page is those three. The fourth part is a person deciding what the agent was never allowed to do, and there is no framework for that.
The six categories and the tools inside them come from a framework map, kept intact: nothing was dropped for being unfashionable. Three entries are marked as additions, because the map was drawn before the tooling settled and saying so is cheaper than quietly rewriting it. Every link here was opened on 1 August 2026.
Back to the argumentFind your seat and start the mastery check