Just exploring
Start with the concept pages: Models, Protocols, Extensions, Agents. You can stay in reading mode the whole time. No code required.
A model is just a program that takes text in and gives text back. Most of the rest of the ecosystem, from MCP servers to agent loops to skills and wrappers, is the machinery around that exchange. Brandon Fuchs built this site as a personal reference while learning the ecosystem, and the goal is to map that machinery without making it sound more mysterious than it is.
Where to start
Pick a path.
I want to understand how it fits together
Start with the Stack page if you want the big picture. Start Here walks through the path from model to agent without assuming you already know the vocabulary.
I want to build something
The labs are the hands-on path. Lab 00 gets you from zero to a working model CLI in one sitting.
The central idea
A practical map for a messy ecosystem.
AI tooling is full of overlapping names for things that partly do the same job. This guide is here to sort those pieces out: what they are, what job they do, and where they fit.
The goal is not to memorize every tool. It is to build a mental model sturdy enough that when a new tool shows up, you can place it.
A useful starting question
- What context does it provide?
- What action does it enable?
- Who decides when it runs?
Models first, tools next, build last.
Three moves
The fastest way to a working mental model
Most people only need three moves: choose how they will reach the model, turn that into one stable surface, then start layering tools and agent behavior on top.
Step 1
Choose model access
Figure out whether you are starting from a subscription, API key, managed platform, router, or local host.
Step 2
Bootstrap one boring interface
Reduce that choice to one repeatable request, response, or CLI surface before you think about agents.
Step 3
Start building upward
Enter lab 00 once the model surface is real, then keep climbing through tools, protocols, memory, and governance.
Deepest start: if you want to begin from a real local model, take the detour through local hosting and model artifacts before bootstrap.
How the pieces connect
Each layer builds on the one before it.
Start with model access. Then learn the concepts that explain the tooling. Then build a few pieces yourself. Use the reference pages when you need to classify something real.
Orientation
Models, Map, and Stack build the mental model — what the ecosystem is, why it's shaped the way it is, and how the layers relate to each other.
Concepts
Protocols, Extensions, and Agents each explain one thing in depth — what it does, where it fits, and what problem it actually solves.
Practice
Labs turn the concepts into runnable artifacts you can hold and modify. Theory without a working example is hard to remember; the labs make it stick.
Reference
The Catalog and Glossary are most useful once you have context — they help you classify real tools you encounter and check where something fits in the stack.
Infrastructure
The stack below the stack covers inference engines, model formats, serving layers, eval tools, and vector stores — the parts a lot of higher-level AI tools are built on top of.
The core idea
AI tools are ways for a model to get context and take action.
A language model on its own can only produce text. The tooling ecosystem is everything we add around it so it can read files, query systems, run commands, follow reusable procedures, ask for approvals, and remember what happened before.
The names can sound intimidating: MCP, skills, hooks, wrappers, agent runtimes. Fair. But most of them answer one of three questions: what can the AI see, what can it do, and who decides what is safe or useful?
A friendly metaphor
Think of it like a workshop
The AI is not the whole workshop. Think of it more like a smart apprentice working inside a shop full of tools, rules, recipes, adapters, and supervisors.
The model is the reasoning engine
It reads the situation and proposes next steps. It is powerful, but it needs context and tools to do grounded work.
Examples: GPT, Claude, Gemini, local models.
Tools are the hands
Tools do concrete things: search files, call an API, query a database, run tests, create a ticket, or edit a document.
Examples: git, rg, curl, SQL clients, cloud CLIs.
Protocols are the plugs
Protocols define how a host discovers tools and data without every integration being custom-built from scratch.
Examples: MCP, OpenAPI, function calling, LSP.
Skills are recipes
A skill tells the agent how to do a kind of task well: when to use which tool, what order to follow, and what mistakes to avoid.
Examples: code review, deploy a model, query a warehouse.
Hooks are shop rules
Hooks run automatically at key moments. They can check safety, add context, run formatting, block secrets, or log what happened.
Examples: before command, after edit, before commit.
Agents are workers with a loop
An agent keeps observing, deciding, acting, and checking progress until the task is done or it needs help.
Examples: CLI agents, IDE agents, persistent assistants.
Four ways into the same ecosystem
Same ecosystem, different handles
You find a local CLI agent
It is a host-shaped CLI agent.
It wraps models, tools, protocol extensions, approvals, and a user interface into one workflow. Goose is one example.
You find a task graph
It is durable work memory.
It gives agents and humans shared state instead of relying on a chat window to remember everything. Beads is one example (a niche open-source project).
You find a protocol adapter
It is an adapter for context and actions.
It can expose tools, resources, and prompt templates to compatible hosts. MCP servers are one example.
You want to build
Start with tiny versions.
The labs now start with bootstrap, then walk from model access to a toy agent loop, memory graph, coordinator, host, and logging layer.
The ecosystem in one screen
Model accessDecides where the reasoning engine lives and how you call it.
Data/contextGives the model something grounded to work from.
ToolsLet the AI do things outside chat.
ProtocolsStandardize how tools and context are exposed.
Skills/pluginsPackage reusable ways of doing work.
Agent runtimeRuns the observe -> decide -> act loop.
Host/UIOwns the user experience and approvals.
GovernanceKeeps the system safe, visible, and testable.
LabsBuild small versions of each layer.
Classify a new tool in about a minute
1
Name the action. If it runs tests, creates issues, edits files, or queries data, you are looking at a tool or capability.
2
Name the interface. If another app discovers and calls it through a schema, you are probably looking at a protocol or wrapper.
3
Name the decision-maker. If it chooses the next step, coordinates workers, or asks for approval, you are higher in the stack.