What is Claude? The whole ecosystem, mapped

I automate a large part of my own go-to-market work with Claude, and here is what I learned the hard way: Claude is not one product, it is a stack, and most people only ever meet one floor of it. They open claude.ai, type into the box, get a good answer, and conclude that is what Claude is. That is like judging Amazon by the search bar.

Here is the reframe I wish someone had handed me on day one. Anthropic builds a family of models. Then it wraps those models in surfaces, the assistant you chat with, the coding tool that edits your repo, the API your engineers call. And underneath all of it sits a small set of shared primitives that make the pieces talk to each other and to the rest of your software. Get that three-layer picture right and everything else snaps into place. Get it wrong and you will keep asking questions like why can't the chat do the thing the docs promised, which is almost always a layer confusion, not a missing feature.

This is the front-door overview. My goal is not to teach you every button. It is to leave you with a correct mental model of how the pieces fit, so that when you read about Routines or Skills or Managed Agents later, you already know which floor of the building they live on. I will be opinionated about what matters and what is noise, because after a year of living in this stack full time, I have strong views about both. As always, the specifics move fast, so date-stamp anything load-bearing and verify on the official docs before you build on it.

So what actually is Claude?

Claude is the name Anthropic gives to its AI models and to the products built on top of them. That is the whole definition, and the ambiguity is the point: the word Claude refers to a model when an engineer says it, and to an app when your marketing lead says it, and they are both correct. The trick is to stop treating Claude as a single thing and start treating it as three layers stacked on each other.

The bottom layer is the models. These are the engines: Opus 4.8, Sonnet 4.6, Haiku 4.5. They do the thinking. They have no buttons, no chat window, no file uploader. They are pure capability.

The middle layer is the surfaces. These are the products you actually touch: the Claude apps for chatting, Claude Code for engineering, and the Developer Platform for building your own software on top. Each surface picks a model under the hood and dresses it up for a job.

The top layer, and the one almost nobody sees, is the set of cross-cutting primitives: MCP, Skills, agents, adaptive thinking. These are not products. They are the wiring and the patterns that show up on every surface, which is exactly why they are easy to miss and hard to live without once you get them.

The models: the engines under everything

Every surface runs on a model, so start here. As of mid-2026, you choose between three usable tiers on the classic triangle of intelligence, speed, and cost.

Opus 4.8 is the top tier you can use today, highly autonomous and the model I lean on for long-horizon agentic work where it has to plan, act, and self-correct across many steps, and for anything where the problem is genuinely hard and getting it wrong is expensive. Sonnet 4.6 is the workhorse, the best balance of speed and intelligence, and it is what most production traffic should run on by default. Haiku 4.5 is the fastest and cheapest, the right call for classification, extraction, and high-volume tasks where you do not need a genius, you need a fast and reliable clerk. (Fable 5 was briefly the most capable model, but Anthropic withdrew it from availability under a US government order days after launch, so you cannot reach for it today.)

There is also Claude Mythos 5, which exists with limited availability and a defensive security focus. Most readers will never touch it; I mention it only so the name does not surprise you later.

My operator take: do not default to the most powerful model out of nervousness. That is how token bills balloon. Default to Sonnet 4.6, measure where it actually falls short, and only then promote those specific jobs to Opus 4.8. The cheapest token is the one you spend on the right tier. Model names and pricing change, so confirm the current roster on the docs before you wire anything to a specific ID.

• Opus 4.8: top usable tier. Best for autonomous, multi-step agentic work and the hardest reasoning. Reach for it when the cost of a wrong answer is high.
• Fable 5: was briefly the most capable, now withdrawn from availability under a US government order. You cannot call it today.
• Sonnet 4.6: the workhorse. Speed and intelligence balance. Your default.
• Haiku 4.5: fastest and cheapest. High-volume, simple, latency-sensitive tasks.
• Mythos 5: limited availability, defensive security focus. You can ignore it for now.

Surface one: the Claude apps (claude.ai)

This is the floor everyone knows: claude.ai on web, desktop, and mobile. It is the chat assistant. You type, it answers, and for most people that is the entire relationship.

But the app is more than a chat box, and the features that matter are the ones that make Claude useful on your actual work rather than as a clever party trick. Projects let you keep a persistent workspace with its own context. Artifacts give you a live pane where Claude can build and render things like documents or small apps next to the conversation. Memory lets it carry context forward across chats. You get web search, voice, and file, PDF, and image upload. And Connectors plug the chat into outside services so it can read your real data instead of guessing.

Here is my honest assessment of where the app fits. It is the right tool for thinking, drafting, one-off analysis, and exploration. It is not where you go to run something repeatedly or reliably at scale, because a human still has to sit there and drive. The moment you catch yourself doing the same prompt dance every morning, you have outgrown the app and you should be looking at one of the other surfaces.

Surface two: Claude Code (the agentic coding tool)

Claude Code is where Claude stops answering and starts doing. It is an agentic coding tool that runs across the CLI, your IDE, the desktop, and the web. You give it a goal, and it reads your codebase, plans, edits files, runs commands, and verifies its own work in a loop.

The features here are the vocabulary of serious agentic work, and they are worth knowing even if you never write code, because they show up in the same shape on the Developer Platform. Subagents let it fan out work in parallel. Hooks let you run your own logic at defined points in its loop. MCP connects it to your tools. Skills load reusable instruction bundles on demand. Plan mode makes it lay out a plan before it touches anything. A CLAUDE.md file gives it persistent project instructions. Checkpoints let you roll back if it goes sideways.

I am not a software engineer by trade, I run demand gen, and Claude Code is still one of the most-used tools in my stack. I use it to build and maintain the scripts and automations that move my GTM data around. The reframe that unlocked it for me: Claude Code is not a coding tool, it is a do-things-on-my-machine tool that happens to be very good at code. Anything that can be expressed as files and commands is fair game.

Surface three: the Developer Platform (build your own Claude)

The Developer Platform is where you stop using Anthropic's products and start building your own. It has three tiers, and the difference between them is who runs the loop.

The API is the foundation: the Messages API, plus tool use, streaming, prompt caching, structured outputs, file and vision input, and batch processing. Everything goes through one endpoint. You send messages, you get a response, you control everything. This is a single request and a single answer, the simplest unit of the whole platform.

The Agent SDK is the next tier up. It is for building your own agents, where you control the gather, act, verify loop in your own code, host your own tools, and decide the trajectory. Use this when you want maximum flexibility and you are happy owning the orchestration.

Managed Agents is the tier where Anthropic runs the loop for you and hosts the tool-execution sandbox. You define a persisted, versioned agent (its model, system prompt, and tools), then start sessions against it. Anthropic provisions a container as the agent's workspace, runs the agent loop on its own infrastructure, and streams events back to you. This is the right call when you want a stateful, long-running agent with a workspace and you do not want to babysit the compute. My rule of thumb: start at the API, move to the Agent SDK only when the task genuinely needs an open-ended loop you control, and reach for Managed Agents when you want the loop and the sandbox handled for you.

• API: Messages API, tool use, streaming, prompt caching, structured outputs, files and vision, batch. One request, one response. You control it all.
• Agent SDK: build your own agents. You run the loop and host the tools. Maximum flexibility.
• Managed Agents: Anthropic runs the loop and hosts the tool sandbox. Persisted, versioned agents with their own workspace.

Dispatch vs Routines: two ways to run Claude without sitting there

These two get conflated constantly, and the difference is the most useful distinction to internalize early, because it is really a question of where the work runs.

Dispatch is a Claude Cowork feature that lets you send a task to your desktop Claude from your phone. The key word is desktop: it runs locally, on your own machine. You are not spinning up cloud compute, you are remote-controlling the Claude already sitting on your laptop. Which means your laptop has to be on and awake for it to work.

Routines are the opposite arrangement. They are scheduled cloud agents that run on Anthropic's infrastructure, triggered by cron, by API, or by GitHub events. The defining property is that they run even when your machine is off. You set up a routine to do something on a schedule, close your laptop, and it still happens.

So the clean mental model: Dispatch is remote control of your local Claude, Routines are autonomous agents living in the cloud. If the task needs your local files, your local tools, or your local environment, Dispatch. If the task needs to happen on a schedule regardless of whether you are around, Routines. I lean on Routines heavily for the recurring GTM jobs that have to run overnight, and I would never want those tied to my laptop being awake at 3am.

• Dispatch: phone to your desktop Claude. Runs locally. Your machine must be on.
• Routines: scheduled cloud agents (cron, API, or GitHub triggers). Run on Anthropic's infrastructure even when your machine is off.

The connective tissue: MCP, Skills, and agents

Now the top layer, the primitives that show up on every surface and that turn Claude from a smart text box into something that touches your real systems.

MCP, the Model Context Protocol, is the one to learn first. It is an open standard for connecting Claude to your tools and data, with a growing ecosystem of 200-plus servers. Think of it as the USB port: instead of every tool inventing its own bespoke integration, they all speak one protocol, and Claude can plug into any of them. This is what lets Claude read your CRM, query your warehouse, or post to Slack. When people say Claude can use my tools, MCP is usually the how.

Skills are reusable instruction bundles loaded on demand. Each skill is a folder of instructions and context that Claude pulls in only when the task calls for it, instead of cramming everything into one giant prompt. They are how you teach Claude your specific workflows and standards without re-explaining them every time. The progressive-disclosure design (a short description sits in context, the full skill loads when relevant) is what keeps them cheap.

Agents are not a product at all, they are a pattern: the gather, then act, then verify loop. Claude gathers information, takes an action, checks the result, and repeats until the job is done. This is the single most important concept in the whole ecosystem, because once you see it, every surface starts to look like the same thing in different clothes. Claude Code is that loop with a coding wrapper. Managed Agents is that loop hosted for you. A Routine is that loop on a schedule. Two more controls round it out: adaptive thinking, where Claude decides how much to reason per request, and an effort control that lets you dial the depth and token spend up or down. Learn the loop, and the rest of the stack stops looking like a list of products and starts looking like one idea expressed many ways.

What about my data?

You cannot reason about whether to put real work into Claude without knowing how your data is treated, and the answer depends on which plan you are on.

For consumer accounts, data is opt-out of training, a default that has been in place since October 2025. That means you can turn training off, but you should know it is a setting to check rather than assume.

For Team and Enterprise, the contract is stronger: your data is contractually not used for training, full stop. Enterprise goes further still with Zero Data Retention available, which means your inputs and outputs are not retained after processing.

My practical guidance: if you are doing anything with customer data, proprietary strategy, or regulated information, that belongs on Team or Enterprise, not a personal consumer account, regardless of what the training setting says. The contractual guarantee is the thing you can actually build a policy on. As always, verify the current terms on the official docs, because data policy is exactly the kind of specific that shifts over time.

Putting it together: which floor do you need?

Here is the framework I give every colleague who asks where do I start. It is three questions.

First, are you thinking, drafting, or doing a one-off? Stay in the Claude apps. The chat box is genuinely excellent and you do not need anything fancier to get enormous value. Most people never need to leave here, and that is fine.

Second, do you want Claude to do things on your machine, edit files, run commands, work inside a real project? That is Claude Code, even if you do not consider yourself technical. It is the bridge from asking to delegating.

Third, are you building software, or automating something that has to run repeatedly and reliably? Now you are on the Developer Platform, and the sub-question is who runs the loop: you (API or Agent SDK) or Anthropic (Managed Agents). And if the thing has to run on a schedule without you, that is Routines.

That is the whole map. A handful of surfaces, a few models, a small set of primitives, one loop. The reason I can automate as much of my work as I do without losing my mind is not that I memorized every feature. It is that I know which floor each job lives on, so I never fight the wrong tool for the work. Get the layers right, and Claude stops being a confusing pile of product names and becomes what it actually is: a stack you can build a real operation on.

Frequently asked questions

Sources & further reading

• Claude docs (claude.com/docs)
• Anthropic news
• Model Context Protocol

Claude ships fast. This page was last reviewed Jun 16, 2026; verify time-sensitive details against the official docs above before relying on them.