Every Anthropic surface, on one page.

The models shipping

Everything below — the web app, the API, the agents — is powered by one of three models. They all do the same kinds of things. They differ on smarts, speed, and price. Pick a default, and override only when you need to.

How to pick

• Default to Sonnet. For chat, code, and most building, Sonnet 4.6 is the right answer 80% of the time.
• Move up to Opus when you're stuck — a thorny refactor, a multi-step plan, design-quality judgment, or anything that needs to "really think."
• Move down to Haiku when you're going wide — thousands of items, repeated calls in a loop, or anything where the per-call price matters more than the per-call quality.

Claude.ai — web & mobile shipping

The chat app at claude.ai. No setup, no install — sign up, start typing. Mobile apps for iOS and Android share the same conversations.

What it does best

• Plain conversation — research, writing, summarizing, brainstorming.
• Drag-and-drop documents, images, PDFs, even ZIPs of code.
• Live preview of generated UI, charts, and code via Artifacts.
• Group related work into Projects so context carries between conversations.

Steps — start using Claude.ai

1. Open claude.ai and sign up with email or Google. Free tier is generous; Pro ($20/mo) unlocks longer messages, more usage, and Projects.
2. Type a question. The same way you'd ask a colleague. There is no special syntax.
3. Drop in a file. Drag a PDF, image, or document into the chat. Claude reads it, you ask questions about it.
4. Ask for an Artifact. Try "build me a one-page landing site for my coffee shop, brand color is forest green" — a live preview pane opens on the right.
5. Save the conversation as a Project if you'll come back to it. Projects keep instructions and files persistent across chats.

Claude Code — agent on your machine shipping

Anthropic's CLI tool. Same Claude as the web app, but it runs in your terminal and can act on your computer — read files, edit them, run commands, install dependencies, push commits, query databases. Available as a CLI, a desktop app, a web app at claude.ai/code, and as IDE plugins for VS Code and JetBrains.

What it does best

• Multi-step coding work: "refactor this file, run the tests, fix what breaks."
• File and folder operations: "rename every photo in this directory to YYYY-MM-DD format."
• Self-running agents that loop until done — kick it off, walk away, come back to a finished task.
• Lives in the project directory it's working in, so it has the right context automatically.

Steps — install in 5 minutes

1. Pick the right walk-through. Windows users: /newby. Mac users: /newby-mac. Both are written for people who have never opened a terminal.
2. Or the one-liner if you've done this before — Anthropic's native installer (recommended): macOS/Linux/WSL curl -fsSL https://claude.ai/install.sh | bash · Windows PowerShell irm https://claude.ai/install.ps1 | iex · Homebrew brew install --cask claude-code · WinGet winget install Anthropic.ClaudeCode.
3. Run claude in any folder. It prompts you to log in via browser the first time.
4. Type your task in plain English. "organize this messy downloads folder by file type" — Claude shows what it'll do, you approve, it runs.

Where Claude Code runs

The slash-commands worth knowing

Projects shipping

A Project on claude.ai is a folder for related conversations. It keeps a system instruction (always sent), a small set of pinned files, and the chat history together so Claude doesn't start from zero every time.

Steps — make your first Project

1. Click "Projects" in the sidebar on claude.ai. (Pro/Team plans only.)
2. Name the project after the recurring task — "Homework: AP Bio", "Bnbhot copywriting", "Family genealogy".
3. Add a system instruction. One paragraph telling Claude its role: "You are an editor for the bnbhot.com short-term-rental blog. Match the existing voice — practical, no fluff."
4. Pin a few reference files. Style guide, brand sheet, last 3 finished pieces. Claude consults them automatically.
5. Start chats inside the project. Each chat inherits the instructions and pinned files.

Artifacts — live previews shipping

When Claude builds you a webpage, a chart, a React component, or a Mermaid diagram, the result lands in a side panel — rendered live and editable. This is the single most useful design feature in the web app. See /design for a deeper recipe walkthrough.

What can be an Artifact

• Single-file HTML pages (with embedded CSS + JS) — full landing pages, dashboards, calculators.
• React components with Tailwind, lucide-react icons, recharts.
• SVG diagrams, Mermaid flowcharts, mini-games.
• Markdown documents you'll publish elsewhere.

Steps — build a one-pager in five minutes

1. Open a fresh chat at claude.ai.
2. Describe what you want in one paragraph: who it's for, what they should do next, what mood (warm? sharp? editorial?), what brand colors.
3. Drop a reference if you have one — a screenshot of a site you like, a logo, a photo. Claude reads images.
4. Iterate. "Make the hero taller, push the CTA above the fold, swap the green for #d97757." The Artifact updates in place.
5. Hit the copy button at the top of the artifact panel and paste the HTML wherever you publish.

Claude API shipping

Direct programmatic access to the models. SDKs for Python, TypeScript, Java, Go, Ruby, .NET. Also reachable through Amazon Bedrock and Google Vertex if you need cloud-native deployment.

Steps — your first API call

1. Get a key at console.anthropic.com. Add a small balance ($5 is plenty to learn).
2. Save it as an env var so it never lands in code: export ANTHROPIC_API_KEY=sk-ant-... (Mac/Linux) or setx ANTHROPIC_API_KEY "sk-ant-..." (Windows).
3. Install the SDK: pip install anthropic or npm install @anthropic-ai/sdk.
4. Send a message:

import anthropic
client = anthropic.Anthropic()
msg = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude."}]
)
print(msg.content[0].text)

Agent SDK shipping

A higher-level library on top of the API for building agents — programs that loop, use tools, and pursue a goal until done. The SDK handles the loop, tool dispatch, error retries, file I/O, sub-agents, and context window management. You write the goal and the tools.

What you get out of the box

• An agent loop that runs until it decides it's done (or hits a step budget).
• Built-in tools — file read/write, bash, web fetch — that you opt in or out of.
• Sub-agents, so a planner can spawn workers.
• Persistent memory and conversation state.
• The same harness Claude Code itself is built on.

When to use the SDK vs. plain API

• Plain API — single shot, structured I/O, classification, completion. You control the prompt, you parse the answer.
• Agent SDK — multi-step work where Claude needs to read files, run code, make decisions, and iterate. You hand it a goal.

Steps — first agent

1. Install: pip install claude-agent-sdk (or the npm equivalent).
2. Write a goal as a plain-English instruction: "Read every .md file in ./docs, find broken links, write a report to ./report.md."
3. Pick the tools the agent is allowed to use (file tools yes, bash maybe, web fetch maybe).
4. Run it. It loops, calls tools, reports back when done.

MCP — Model Context Protocol shipping

An open protocol Anthropic built so Claude can talk to external systems — Drive, Gmail, Calendar, Slack, GitHub, your database, your in-house APIs. Each system runs a small "MCP server" that advertises what it can do. Claude (in the desktop app, in Claude Code, in custom apps) connects to the server and uses those abilities like built-in tools.

Why it matters

Before MCP, every integration was bespoke. After MCP, the same connector works in any compliant client. Anthropic, Google, OpenAI, and the major IDE makers all speak it.

Steps — add an MCP server to Claude Code

1. Pick a server. The official ones live at github.com/modelcontextprotocol/servers — Drive, Gmail, GitHub, Slack, Postgres, Filesystem, Brave Search, Puppeteer, and dozens more.
2. Run claude mcp add and paste the install command from the server's README.
3. Restart Claude Code. The new tools show up in /help.
4. Use them in plain English: "search my Drive for the BBQ catering quote from last March" — Claude calls the Drive MCP server.

Skills shipping

A Skill is a packaged workflow that Claude can invoke on demand — a slash command (/security-review, /loop, /schedule) plus the prompt and tools that run when you call it. Built into Claude Code; bundled by Anthropic, distributed by plugin authors, or written by you.

Where Skills come from

• Built-in — /init, /review, /security-review, /help.
• Plugins — frontend-design, claude-api, fewer-permission-prompts. Install via the plugin marketplace.
• Yours — drop a SKILL.md into ~/.claude/skills/<name>/ and it's available everywhere.

Steps — write your first Skill

1. Create the folder: ~/.claude/skills/my-skill/
2. Write SKILL.md with frontmatter — name, description, when to trigger — and the body of the prompt.
3. Reference any helper scripts in the same folder.
4. Type /my-skill in any Claude Code session — Claude loads and runs it.

Tool Use shipping

A primitive on the API. You give Claude a list of tools (a name, a description, a JSON schema for the inputs). Claude decides when to call them and returns the calls structurally. You execute them in your code and return the results.

What it's for

• Letting Claude query a database, hit your API, fetch a webpage, send an email — anything code-shaped.
• Forcing structured output: define a tool with a strict JSON schema and Claude responds in that shape.
• The building block under everything else — Agent SDK, MCP, Computer Use, Claude Code all use Tool Use under the hood.

Steps — sketch a tool

1. Describe the tool in JSON schema — name, what it does, what parameters it takes.
2. Pass it in tools=[...] on the message create call.
3. If Claude returns a tool_use block, run the tool yourself and return a tool_result block in the next message.
4. Loop until Claude returns plain text — that's the final answer.

Computer Use beta

A capability where Claude looks at screenshots and emits mouse + keyboard actions to drive a computer. You run a loop: capture the screen, send it to Claude, execute the actions Claude returns, repeat. Useful for automating apps that have no API.

Realistic use cases

• Filling browser forms across sites that block scraping.
• Driving legacy desktop software during a migration.
• QA — visiting a list of pages and reporting what's broken.

Steps — try it safely

1. Run it inside a VM or container. Anthropic publishes a Docker reference image. Don't point it at your daily-driver desktop.
2. Pull the reference container from ghcr.io/anthropics/anthropic-quickstarts.
3. Set ANTHROPIC_API_KEY and start the container; it serves a web UI you can chat with.
4. Give a small task first — "open Firefox and search for cat pictures" — to get a feel for it before pointing it at anything important.

Files API shipping

Upload a file once, reference it by ID across many API calls. PDFs, images, CSVs, code archives. Saves you from re-uploading the same 200-page contract every time.

Steps

1. POST /v1/files with the file. Get back a file_id.
2. Reference it in messages as {"type": "document", "source": {"type": "file", "file_id": "..."}}.
3. Combine with prompt caching for big documents you'll consult repeatedly.

Memory shipping

A capability that lets Claude remember facts about you and your work across conversations — in claude.ai, in Claude Code, and in apps you build with the SDK. Memory is file-based: human-readable notes under ~/.claude/projects/<dir>/memory/.

What gets remembered

• User memories — who you are, your role, your setup.
• Feedback memories — corrections you made ("don't mock the database in tests").
• Project memories — short-lived facts about ongoing work and deadlines.
• References — pointers to external systems ("bugs are tracked in Linear project INGEST").

Steps — manage it

1. Trust the auto-save. When you correct Claude or share something durable, it writes a memory file.
2. Inspect them — they're plain Markdown in ~/.claude/projects/<dir>/memory/.
3. Edit or remove a memory directly when it goes stale; the file IS the source of truth.
4. Say "forget X" in a session and Claude finds and removes the relevant entry.

Prompt Caching shipping

Mark part of your prompt as cacheable; Anthropic stores it on their servers for ~5 minutes. The next call that includes the same prefix pays roughly 10% of the normal input price. Often the biggest single cost lever in any Claude app.

What to cache

• System prompts longer than a couple of paragraphs.
• Reference documents you consult repeatedly (pricing sheets, contracts, brand guides).
• Tool definitions on long-running agents.
• The first turn of a conversation when you'll likely keep talking.

Steps

1. Add cache_control: {"type": "ephemeral"} to the content block you want cached.
2. Make calls within ~5 minutes of each other to keep the cache warm.
3. Watch the response — cache_creation_input_tokens on the first call, cache_read_input_tokens on subsequent ones.

Extended Thinking shipping

A mode where Claude takes extra time to reason through a problem before answering. You see a "thinking" block in the response (collapsed by default) followed by the final answer. Trades latency and cost for quality on hard problems.

When it earns its keep

• Multi-step math, proofs, or careful tracebacks.
• Tricky refactors where you want Claude to plan before editing.
• Plan mode in Claude Code — turn this on and Claude drafts a plan before touching files.

Steps

1. API: add thinking: {"type": "enabled", "budget_tokens": 8000} to the message create call.
2. Claude Code: use /think or enter Plan mode (Shift+Tab twice) before the work.
3. claude.ai: toggle "Extended thinking" in the model picker.

Batch API shipping

Submit thousands of requests as a single batch; Anthropic processes them within 24 hours at 50% of the regular price. Built for throughput, not latency.

Real uses

• Tagging or summarizing every article in an archive.
• Translating a back-catalog.
• Running an evaluation suite against a new model release.

Steps

1. Build a JSONL file with one request per line.
2. POST it to /v1/messages/batches.
3. Poll the batch ID until status is ended.
4. Download the output JSONL — one response per line, in submission order.

Citations shipping

Pass documents along with your question and Claude returns answers anchored to specific spans of those documents. Each claim ships with a pointer back to the source. Removes most of the "did you make that up?" worry.

Steps

1. Pass each source as a content block with citations: {"enabled": true}.
2. Ask the question in the next block.
3. Read the response — text spans interleave with citation objects pointing back to the source.

Vision & PDF input shipping

All current Claude models read images and PDFs natively. Drop a screenshot, a chart, a mockup, a scanned letter — Claude treats it like any other content.

What works well

• UI screenshots — "build me this in HTML" or "what's broken in this layout?"
• Charts and diagrams — extracting numbers, summarizing trends.
• Scanned forms and old documents — surprisingly good OCR plus understanding.
• Photographs — "what brand is this dishwasher?" "is this lightbulb dimmable?"

Managed Agents early access

A hosted runtime for agents — instead of running the loop on your laptop, you submit a goal and Anthropic's infrastructure runs it in a sandbox, with persistent state, scheduling, and a job dashboard. Think "GitHub Actions, but the worker is Claude."

What it gets you

• Long-running agents that survive your laptop closing.
• Scheduled agents — kick off every Monday morning.
• Sandboxed environments per agent run.
• A dashboard with logs, costs, and outputs.

Status & how to get in

Available to selected partners and through certain Claude Code features (the /schedule command in particular). Watch anthropic.com/news for general availability.

Mythos & what's coming forward-looking

This section is intentionally honest: it's about products that are partially announced, rumored, or implied by Anthropic's research direction. Treat everything below as "watch for it" — not "shipping today."

Mythos

"Mythos" is a name we're tracking as a future Anthropic surface. As of writing it has not been formally launched; we will fill in this section the moment Anthropic publishes details. If you're reading this and Mythos has shipped, the source of truth is anthropic.com/news and docs.anthropic.com.

Other directions worth watching

• Multi-agent orchestration — first-class primitives for one Claude managing a fleet of sub-agents, beyond what the Agent SDK offers today.
• Persistent agent identity — agents that maintain memory, credentials, and reputation across many tasks and over months.
• Real-time / voice — lower-latency interfaces for spoken interaction and live audio analysis.
• Native enterprise data plane — Claude reading from your warehouse, lake, and document stores without manual MCP wiring.
• Better browsing & computer use — Computer Use is in beta; expect dramatic improvements in reliability and speed over the next year.
• On-device / edge inference — for workloads that can't leave a device or must stay below a latency floor.