What is the Claude Platform?

What it is

The Claude Platform is Anthropic's infrastructure for building with Claude programmatically. Instead of typing into a browser tab, your code sends a structured request and gets a structured response back, with control over every detail: which model answers, how many tokens it may spend, which tools it may call, and what system instructions it follows.

Anthropic describes it as four pieces:

A REST API you can call from any language.
SDKs in TypeScript (@anthropic-ai/sdk) and Python (anthropic), which wrap the API and add helpers like the Tool Runner.
Command-line interfaces - of which Claude Code is the one most people have met.
The Claude Console at platform.claude.com, the account and admin surface: keys, usage, spend limits, the Playground, and the Managed Agents section.

The word to hold on to is platform, not API. The API is one call. The Platform is everything that makes a thousand of those calls behave in production - and that is where most of the product actually lives.

Not the app

Anthropic ships Claude in several shapes, and they are easy to run together in conversation. claude.ai and its Pro, Max, Team, and Enterprise plans are a subscription for people, billed per seat. The Platform is an account for software, billed per token, and it is the only one of the two you reach with an API key. A paid app plan buys nothing on the Platform side; a Platform account seats no one in the app.

The two are joined by a shared sign-in and a handful of deliberate crossings, Claude Code being the notable one. Seats, Console workspaces, roles, and where the billing leaks are the subject of Claude Team vs Claude Platform. This article stays on the Platform side of that line and asks a different question: once you have the key, what is it for?

The three layers

Anthropic's own picture of the Platform is three layers stacked on each other, and it is a useful one because it explains why the Console has the sections it has.

01 · PRIMITIVES

Build with primitives

The API building blocks tuned to Claude: the Messages API, tool use, files, web search, code execution, MCP servers, and skills. These are the pieces your code actually calls.

02 · INFRASTRUCTURE

Scale on infrastructure

What you need past a prototype: managed agents, retries, queues, observability, prompt caching, memory. The plumbing that keeps things running when one Claude call becomes a thousand.

03 · CONTROLS

Run with control

The dials a team uses once it is live: dashboards, evaluations, workspaces, usage and spend limits, request logs. This is most of what the Console shows you.

The shorthand Anthropic uses is build with primitives, scale on infrastructure, run with control. Most first projects live entirely in layer one. Most production incidents are about layers two and three. You can see the structure in the Console itself, which is organised into sections for building, managing agents, and analytics - the infrastructure and control layers, laid out as tabs.

A single call

Everything on the Platform reduces to one operation: messages.create. Anthropic's course example is a help desk that drafts a reply from the contents of a ticket, following the team's tone guide, wired to a button in the UI. The whole integration is one request:

            PYTHON
            draft_reply.py
          

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-haiku-4-5",   # a simple drafting task: use the small model
    max_tokens=1024,
    system=TONE_AND_GUIDELINES,
    messages=[
        {"role": "user", "content": ticket_content}
    ],
)

draft = response.content
          

Each parameter does one job, and together they are the vocabulary of the whole Platform:

model - which model handles the request. Cost, speed, and capability all follow from this one line (section 08).
max_tokens - a hard cap on how long the response may be, and therefore on what it can cost.
system - the system prompt, where you define the role Claude plays. Tone, guidelines, and constraints go here, not in the user message.
messages - the conversation so far as an array of turns. The user role marks input; the ticket text goes there.

Notice what the example is not: it is not a chatbot. It is an existing product with Claude wired into one feature. That is the Platform's core idea - going from ask Claude a question to Claude is part of my product.

The agent loop

A single call returns a single response. To automate a workflow, Claude has to act, look at the result, decide what is next, and keep going. That pattern is what people mean by agentic, and on the Platform it is a loop you write yourself:

1 · SEND

Message with tools

You call messages.create with a tools array: each tool has a name, a description, and a JSON schema for its inputs.

2 · DECIDE

Claude answers or asks

The response stops with end_turn (a final answer) or tool_use (a request to run one of your tools with specific inputs).

3 · EXECUTE

Your code runs it

You execute the tool - a database query, an API call, a shell command. Claude never runs anything itself; it only asks.

4 · RETURN

Feed the result back

Append the assistant turn and a tool_result to messages, call again, and repeat until the stop reason is end_turn.

The course demo is a fake get_weather tool and the question "what should I wear in Austin today?" - two API calls, one tool execution, one answer. The production version is a compliance agent that reads a structural report, looks up building codes through a tool, and writes findings to a database as it goes. The shape of the loop is identical; only the tools and the plumbing change.

You own the loop and the tools. Claude owns the reasoning.- the division of labour on the Platform

Once you have written the loop by hand once, the SDK's Tool Runner collapses it into a single call. The course teaches it manually first so you know what the helper is doing - which matters the first time it does something you did not expect.

Extending an agent

The tools in the loop above were yours. The Platform also provides four ways to give an agent reach without writing every tool from scratch:

Built-in tools. Web search, web fetch, and code execution run on Anthropic's infrastructure - you switch them on in the request, and Claude uses them with no server of yours involved.
Skills. A procedure packaged once and reused across calls - the same idea covered in What are Agent Skills?, available server-side.
MCP servers. Connect Claude to third-party systems (Slack, Asana, GitHub, a database) through the Model Context Protocol without writing a tool schema for each one.
Context management. Prompt caching, compaction, and the other patterns that keep a long-running agent inside its context window and inside its budget past turn ten.

How the first three relate to each other, and when to reach for which, is the subject of Functions, MCP, and Skills and Skills, MCP, Hooks, and Plugins. Here the point is only that they are all Platform primitives - layer one.

Managed agents

The loop in section 05 runs on your infrastructure. Claude Managed Agents is the alternative: a suite of APIs where Anthropic hosts the loop. You define an agent with tools, a persona, and capabilities; you configure a sandbox environment with the packages and network rules it needs; then you fire off sessions from your application and Claude does the work inside an isolated container with a file system, bash, and web search.

The building blocks, in Anthropic's terms:

Agents	Definitions with specific tools, personas, and capabilities
Sessions	Individual runs you start from your own application; they run in parallel and stream tool calls back as events
Environments	Sandboxes with the right packages installed and network controls applied
Tools and MCP	Custom tools on your back end, plus MCP connections to services like Slack and Asana
Memory	A store the agent reads before starting and writes to when done, so next week's run knows what last week's found
Outcomes	Rubrics and separate graders that define what done looks like; Claude iterates until it meets them
Coordination	A coordinator agent delegating to specialists, each in its own context window on a shared file system

The examples Anthropic uses are telling: a Kanban board where dragging a ticket to "in progress" starts a session against a mounted repo; a weekly pricing-research agent that remembers last week's numbers; an incident-response coordinator that waits for a human approval before anything goes to Slack. The decision it puts in front of you is simple - run your own loop when you need to own every step; let Anthropic run it when you would rather define the outcome and watch the event stream. Managed Agents has its own section in the Console, which is one more reason the Console is the thing to understand first.

Choosing a model

The model parameter is the single biggest lever on cost and latency, and the Platform gives you a family to choose from rather than one answer. Anthropic's course lists four - Fable, Opus, Sonnet, and Haiku - and the advice attached to them is the useful part:

Do not guess; evaluate. Take a handful of your own real examples, run them through two or three models, and compare quality against cost and time. The Console Playground exists for exactly this.
Match the model to the task, not the project. The help desk example uses Haiku because drafting a short reply is simple. The same product might route a hard classification to Opus. One application, several models, chosen per call.
Budget the loop, not the call. An agent that takes twenty turns pays twenty times, and the context grows every turn. The Console's per-workspace spend limits and service tiers (covered on the account side in Claude Team vs Claude Platform) are how that variance stays predictable - the same problem covered in What an agent actually costs.

Getting started

You need three things: a Console account at platform.claude.com, an API key created inside a workspace there (keys are scoped to the workspace that made them - one workspace per environment is the sane default), and a small amount of prepaid credit. The key goes in an environment variable, the SDK reads it, and the first call is the six lines at the top of this article. Anthropic's stated prerequisites are modest - comfort reading and writing code in one language and basic command-line familiarity. No prior experience building with LLMs is assumed.

            SHELL
            terminal
          
# 1. install the SDK
npm install @anthropic-ai/sdk        # or: pip install anthropic

# 2. the key comes from a Console workspace, never from the app
export ANTHROPIC_API_KEY=sk-ant-...

# 3. one messages.create call, then build the loop

The best structured path through all of it is Anthropic's own Claude Platform 101 on Claude Academy: thirteen lessons in the order this article followed - first call, model choice, the loop by hand, tools, built-in tools, skills, MCP, context management, managed agents - each ending in runnable code. Its last lesson is worth noting: it builds against the API using Claude Code itself, on the argument that you have to know what good code looks like to review the code an agent writes for you.