Claude in 2026: Models, Surfaces and Practical Limits

Most people who use Claude have only seen one tenth of it. They open the chat window, type a question, get an answer, and close the tab. That is Claude the way a phone is a calculator. It works, but it misses the point.

Claude in 2026 is four things wearing one brain. There is the chat product at claude.ai. There is Claude Code, an agent that lives in your terminal and edits real files. There is the developer API that lets you build Claude into your own software. And under all three sits one family of models, available not just from Anthropic but on Amazon, Google, and Microsoft clouds too. The skill that actually matters is not "prompting." It is knowing which of these four surfaces to reach for when. This guide walks all four, with the real numbers, so you can stop guessing.

We run a design and AI studio on Mallorca and use every one of these surfaces daily, on our own work and on client systems. What follows is the map I wish someone had handed me.

The model family, in one table#

The main families for this guide are Haiku, Sonnet, Opus and Fable. Versions, model IDs, prices and availability change. The earlier June table is therefore not a reliable current model catalog. Choose by task first, then check the specific version in the official model and pricing lists.

A benchmark helps only when version, test setup and date match. It is not a promise for your codebase. We do not carry the earlier percentages forward as a current recommendation. For coding, inspect the diff, running tests and the requirement actually met. An agent can misjudge a change even with a strong model.

A large context window allows more material; its limit depends on model and platform. Tokens do not translate into a fixed word count, and filling the window does not guarantee complete analysis. Keep the task focused, mark relevant sections and check important claims against the original. The window is capacity, not a target.

API calls charge for the version and tokens processed; caching, batch processing and other options change the bill. Subscription allowances use a different pricing model. Our starting rule remains: a fast model for defined recurring tasks, a balanced one for everyday work and coding, a stronger one for difficult cases. Compare cost and error rate on a small representative sample.

Claude models are available through Anthropic and, depending on version, Amazon Bedrock, Google Vertex AI or Microsoft Foundry. Model IDs, regions, context limits, tools and data terms can differ between platforms. Check the actual provider’s documentation; family availability does not mean every version has identical features everywhere.

Surface one: claude.ai, the chat product#

This is the part everyone knows, and it has quietly grown into a serious workspace. Worth understanding before you pay for anything.

Projects are the feature most people miss. A Project is a container with its own instructions and uploaded knowledge. Drop your brand guide, your API docs, and your tone rules into a Project once, and every conversation inside it inherits that context automatically. For a small business this is the difference between re-explaining your company every morning and never explaining it again.

Artifacts display outputs on a separate surface. Alongside small interactive tools, paid plans now have Designs, Slides and Docs templates with direct editing. Advanced features such as connector access or persistent text storage depend on type, plan and permissions. Check those prerequisites before turning one into an internal tool for others.

Then there is the connective tissue. Connectors are how claude.ai plugs into the outside world, and they run on the Model Context Protocol, the open standard Anthropic released for connecting AI to tools and data. Through MCP, Claude reaches Gmail, Google Drive, Slack, GitHub, Notion, Stripe, and hundreds of other services. As a non-developer you add a connector with a few clicks and Claude can suddenly read your calendar or triage your inbox. This is the same MCP that developers build servers for, which is the elegant part: the protocol is one thing, exposed at every level.

Claude in Chrome extends work into the browser. Cowork and chat are now merging in a gradually rolling out new experience for Pro and Max. Cloud tasks can continue across devices; local file tasks still need the appropriate desktop environment. Existing Cowork surfaces remain usable during transition. Check your account rather than assuming every user has the same surface after an announcement.

The plans, with real prices:

The honest version: Free is fine to evaluate. Pro is the right tier for one person doing real work. Max exists because the people who run Claude Code all day kept hitting limits, and the higher Max tier and the Team Premium seat are where Claude Code usage is most comfortable.

Surface two: Claude Code, the agent in your terminal#

This is the one that changes how work feels, and it is the most misunderstood. Claude Code is not a chatbot in a terminal. Anthropic describes it as an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools. You tell it what you want in plain language and it does the work across many files, runs the tests, and shows you the diff.

Installing it is one line. On macOS, Linux, or WSL:

curl -fsSL https://claude.ai/install.sh | bash

Claude Code is available in the terminal, editor extensions, desktop and cloud surfaces. Follow the install guide for your platform and sign in. Repository files can provide context to several surfaces. Local configuration, local MCP processes and file access do not automatically follow into every cloud session; check your setup’s scope.

The single highest-leverage thing in Claude Code is a file called CLAUDE.md. Anthropic's own best-practices doc calls it the agent's constitution. It is a markdown file in your project root that Claude reads at the start of every session. You put your coding standards, your architecture decisions, your preferred libraries, and your review checklist in it, and you stop repeating yourself. On top of that, Claude Code now builds auto memory as it works, saving things like your build command and debugging insights across sessions without you writing them down.

From there it gets powerful in layers. These are the pieces worth knowing by name, because they are the words you use to make Claude configure itself:

• MCP servers. The same Model Context Protocol from claude.ai, here in your terminal. claude mcp add wires up a server, and now Claude Code can read your Jira tickets, query your database, or use any tool you give it. Servers are configured per user, per project, or locally, and a shared .mcp.json checks the project's servers into git for the whole team.
• Subagents. A subagent is a separate Claude session with its own context window, spawned to handle a noisy or parallelizable task and report back only a summary. The main conversation stays clean. Type /agents to manage them. This is how you run several streams of work at once.
• Hooks. Programs run at configured events. A suitable synchronous hook can block covered tool calls; asynchronous hooks cannot. Test coverage and failure behavior rather than assuming a universal safety guarantee.
• Skills. A SKILL.md bundles a procedure. It normally runs in the current context; in Claude Code, context: fork can run it in a subagent with separate context. Scope depends on location and client.
• Plugins. A versioned bundle that ships skills, subagents, slash commands, hooks, output styles, and MCP servers together as one installable unit, shareable through a marketplace. If a Skill is a recipe card, a plugin is the whole cookbook.
• Plan mode. Claude reads and proposes a written plan without touching anything. You approve it, then it executes. The discipline this enforces is the whole game.
• Checkpoints. You can rewind conversation and tracked file edits. Shell commands, database changes, sending and other external effects are not generally undone.

Underneath all of it is a workflow Anthropic recommends and that genuinely works: explore, plan, code, commit. Let Claude read the relevant files first in plan mode, have it write down what it will change and in what order, then let it implement against that plan, then commit with a clear message. Skipping the explore and plan steps is the most common reason a session goes sideways.

And because it follows the Unix philosophy, you can script it. The -p flag runs Claude headless, so you can pipe into it:

git diff main --name-only | claude -p "review these changed files for security issues"

That single pattern, Claude in a pipe, is what turns it from an assistant into infrastructure. We run reviews, translations, and audits this way in CI.

Surface three: the API and the Agent SDK, for builders#

When you want Claude inside your own product, you drop to the API. The core is the Messages API, with official SDKs for Python, TypeScript, and Go. A minimal call looks like this:

from anthropic import Anthropic

client = Anthropic()
message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize this contract."}],
)
print(message.content[0].text)

From that foundation, a handful of features do most of the heavy lifting, and knowing they exist saves you money and rebuilds.

Tool use, also called function calling, lets Claude decide when to call functions you define and with what arguments. It is the basis of every agent. You hand Claude a list of tools with JSON schemas, and it returns structured calls you execute.

Prompt caching is the one that pays for itself. You mark a stable chunk of your prompt, a long system prompt or a big document, with cache_control, and subsequent calls reuse it. Cache reads are charged at roughly ten percent of the normal input rate, so repeated context gets up to ninety percent cheaper. The default cache lives five minutes, with a one-hour option. If you are sending the same instructions on every request and not caching, you are overpaying.

Extended thinking lets the model reason before answering, with a budget_tokens you control:

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    thinking={"type": "enabled", "budget_tokens": 2000},
    messages=[{"role": "user", "content": "Plan a database migration."}],
)

The rest of the platform is a toolbox you pull from as needed. The Batch API runs large jobs asynchronously within 24 hours at a flat 50% discount, ideal for bulk work that is not time-sensitive. The Files API handles documents and images you reference across calls. Citations make Claude point to the exact sentences it used, which is how you build trustworthy, checkable output. There are first-party tools too: a web search tool for current data, a code execution tool that runs Python in the call, and an MCP connector for tool calls to compatible publicly reachable HTTP servers. Local stdio is not supported directly; the API feature is beta and not eligible for Zero Data Retention. A memory tool for long-running agents is in public beta.

When you want to build a full agent rather than make single calls, there is the Claude Agent SDK, formerly the Claude Code SDK. It gives you the same agent loop, tool handling, and context management that power Claude Code, in Python and TypeScript, with full control over orchestration and permissions. The mental model: the API is for calls, the Agent SDK is for agents.

Which surface for which job#

Put the four together and the decision gets simple.

Reach for claude.ai when a human is in the loop and the work is thinking, writing, analysis, or a quick tool you build in Artifacts. Reach for Claude Code when the work touches files, a codebase, or your local machine, and you want an agent that acts, not just answers. Reach for the API when Claude needs to live inside software you ship to other people. And pick the cloud version, Bedrock, Vertex, or Foundry, when procurement or data residency makes that the path of least resistance.

For the model inside any of those: Haiku for volume, Sonnet for most things, Opus when it is hard or costly to be wrong.

The traps nobody puts on the box#

A guide that only lists features is marketing. Here is what actually bites.

The first is confident wrong code. Claude will sometimes invent an API method that sounds right but was renamed two versions ago, or cite a library function that does not exist. The fix is not to trust less in a vague way, it is to give the model current facts. Point it at real documentation, and in Claude Code, give it tools that read your actual code instead of guessing. Stronger models need this verification too.

The second is context rot. As a session grows long, the model's attention thins out and quality drops. The 1M window invites you to dump everything in, and then the answer gets worse. Keep sessions scoped. Use subagents to push noisy work into separate context. Start fresh when a thread has wandered.

The third is the one to take seriously if you connect Claude to your tools: the lethal trifecta. Security researchers use this term for three conditions that, together, make an agent exploitable. Access to private data, exposure to untrusted content, and a way to send data out. Any one alone is fine. All three at once means a malicious instruction hidden in, say, a web page or an email can make your agent leak what it can see. MCP makes Claude far more capable and, in the same motion, widens this attack surface. The defenses are unglamorous and real: run only MCP servers you trust, use the permission allowlist so the agent cannot run anything it likes, and follow least privilege. Do not give an agent both your secrets and an open door at the same time.

None of these are reasons to avoid Claude. They are the difference between using it well and getting surprised.

Where to start#

If you have never gone past the chat window, do three things this week. Make one Project and load it with your real context. Install Claude Code and write a ten-line CLAUDE.md for one repo. Add one MCP connector to something you actually use. That is the whole arc of this guide in three moves, from chat to agent to connected.

The reason any of this matters for a business is that the gap between islands of tools is where time leaks, and Claude across these four surfaces is, more than anything, a way to close those gaps. We connect Claude to client systems through MCP for exactly that, and the StudioMeyer Memory server is our own answer to the part this guide keeps circling, giving Claude a memory that survives between sessions.

If you want the terminal side on its own, our walkthrough on setting up Claude Code without the jargon is the natural next read.

Claude is no longer one window. Learn the four surfaces and the model stops being a clever toy and starts being something you build on.

Sources and product status#

Anthropic plans and model access / Fable and Mythos 5.1: current status / Claude Code skills and subagent context / Claude Code hooks and blocking behavior / Claude chat and Cowork rollout

API MCP Connector / Claude Code Checkpoints