Anthropic Claude

By Anthropic

Frontier LLM API with strong tool-use and long-context reasoning, ideal as an agent's core model

Website ↗ Docs ↗

APIProprietary

#llm #tool-use #reasoning #api

Paid

Doc version 1.0 · Updated June 28, 2026

Related concepts

Harness Engineering Doc version 1.0 · Updated June 28, 2026 Wrapping an LLM in scaffolding — a control loop, tools, a sandbox, guardrails, and evaluation — so it behaves reliably in production.

Overview

Claude is Anthropic’s family of frontier models.
For agentic workloads it is a strong default thanks to reliable tool use (function calling), large context windows, and steerable instruction-following.

Common model ids (use the latest/most capable for new agents):

claude-opus-4-8 — most capable, best for hard reasoning and long agent loops
claude-sonnet-4-6 — balanced cost/latency for high-volume agents
claude-haiku-4-5-20251001 — fastest/cheapest for simple sub-tasks

flowchart LR
  user[user message] --> claude[Claude]
  claude -->|tool_use| tool[run tool]
  tool -->|tool_result| claude
  claude --> answer[final answer]

The Code samples tab shows TypeScript and Python examples — pick from the selector to compare.

When to use it

Reach for Claude when your agent needs dependable multi-step tool use, careful instruction-following, or long-context document reasoning.

Pricing

Paid API billed per token; Batch is 50% off and prompt caching up to 90% off. Prices per million tokens (input / output)

Plan	Price	Notes
Claude Opus 4.8	$5 / $25	Most capable
Claude Sonnet 4.6	$3 / $15	Balanced
Claude Haiku 4.5	$1 / $5	Fastest, cheapest

Source ↗ · as of 2026-06-27

Example

TypeScript · tool use

When to use

Reach for tool use when you want the model to call functions and take external actions.

How it flows

Claude returns a tool_use block; you run the tool and send the result back as a tool_result to continue the loop.

Structure

flowchart LR
  user[user message] --> claude[Claude]
  claude -->|tool_use| tool[run tool]
  tool -->|tool_result| claude
  claude --> answer[final answer]

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic(); // reads ANTHROPIC_API_KEY

const tools = [
  {
    name: 'get_weather',
    description: 'Get the current weather for a city',
    input_schema: {
      type: 'object',
      properties: { city: { type: 'string' } },
      required: ['city'],
    },
  },
] as const;

const message = await client.messages.create({
  model: 'claude-opus-4-8',
  max_tokens: 1024,
  tools,
  messages: [{ role: 'user', content: 'What should I wear in Seoul today?' }],
});

// When Claude wants a tool, it returns a `tool_use` block. Run the tool,
// then send the result back as a `tool_result` to continue the loop.
for (const block of message.content) {
  if (block.type === 'tool_use') {
    console.log('call', block.name, block.input);
  }
}

For a runnable build of this loop, see anthropic-claude_1 in the Implementation tab.

When to use

Reach for this when you need a simple one-shot message call from Python.

How it flows

messages.create returns the model's reply; the text lives in content[0].text.

Structure

flowchart LR
  msg[messages.create] --> claude[Claude]
  claude --> text[text reply]

from anthropic import Anthropic

client = Anthropic()  # reads ANTHROPIC_API_KEY

message = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize Claude in one line."}],
)
print(message.content[0].text)

Example

Anthropic Claude — a tool-using agent turn

A real, runnable mini-project. Download it and run with Docker.

View samples/anthropic-claude_1 on GitHub ↗

June 28, 2026

Anthropic Claude — a tool-using agent turn

A tiny agent loop built on the official Anthropic SDK: Claude is given one tool (get_weather), decides to call it, and the script feeds the result back as a tool_result — looping until Claude writes a final answer. That loop is the core agentic pattern.

Configure

cd samples/anthropic-claude_1
cp .env.sample .env
# edit .env: set ANTHROPIC_API_KEY (and optionally MODEL)

Get a key at console.anthropic.com. MODEL defaults to claude-opus-4-8; see the model list.

.env is gitignored — only .env.sample is committed.

Run with Docker

cd samples/anthropic-claude_1
docker build -t aas-anthropic-claude .
docker run --rm --env-file .env aas-anthropic-claude "What should I wear in Seoul today?"

Run with Docker (in a devcontainer with DooD)

In a dev container that talks to the host Docker daemon (Docker-outside-of-Docker), the foreground docker run above often prints nothing and exits 0 — but the run itself succeeds. The script runs to completion and Docker captures all of its output; only the live attached stream drops it over the VM boundary. You can confirm this: docker logs on the same container shows the full output, the container exits 0, and it is not an OOM. Run detached and follow the logs instead:

cd samples/anthropic-claude_1
docker build -t aas-anthropic-claude .
docker logs -f "$(docker run -d --env-file .env aas-anthropic-claude \
  "What should I wear in Seoul today?")"

Run locally

cd samples/anthropic-claude_1
pip install -r requirements.txt
python app.py "What should I wear in Seoul today?"

python-dotenv loads .env automatically.

Example run

Output varies by model and run — LLMs are non-deterministic, so the exact wording (and an agent's steps) differ each time. Below is one run with claude-opus-4-8.

I'll check the current weather in Seoul to help you decide what to wear.
[tool call] get_weather({'city': 'Seoul'})
It's a beautiful day in Seoul today—**22°C and sunny**! Here's what I'd recommend:

- A light long-sleeve shirt or a t-shirt
- Comfortable pants, jeans, or a skirt/dress
- A light jacket or cardigan if you tend to get chilly, especially in the evening
- Sunglasses, maybe a hat, and a bit of sunscreen since it's sunny
...
22°C is mild and pleasant—no need for heavy layers. Enjoy your day!

Files

.env.sample

# Copy this file to `.env` and add your Anthropic API key.
#   cp .env.sample .env
#
# Get a key at https://console.anthropic.com/
ANTHROPIC_API_KEY=

# Model id — see https://docs.anthropic.com/en/docs/about-claude/models
#   claude-opus-4-8              most capable
#   claude-sonnet-4-6            balanced cost/latency
#   claude-haiku-4-5-20251001    fastest/cheapest
MODEL=claude-opus-4-8

app.py

"""Anthropic Claude: a tool-using agent turn with the official SDK.

Claude decides when to call a tool; we run it and feed the result back as a
`tool_result`, looping until Claude produces a final text answer. That loop —
function calling plus feeding results back — is the core agentic pattern.

Run:
    docker build -t aas-anthropic-claude .
    docker run --rm --env-file .env aas-anthropic-claude "What should I wear in Seoul today?"
"""

import os
import sys

from anthropic import Anthropic
from dotenv import load_dotenv

# Load .env when running locally; in Docker the key comes from --env-file.
load_dotenv()

client = Anthropic()  # reads ANTHROPIC_API_KEY
MODEL = os.environ.get("MODEL", "claude-opus-4-8")

TOOLS = [
    {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "input_schema": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    }
]


def get_weather(city: str) -> str:
    # A real tool would call a weather API; here we return a canned value.
    return f"It is 22°C and sunny in {city}."


def main() -> None:
    question = " ".join(sys.argv[1:]) or "What should I wear in Seoul today?"
    messages = [{"role": "user", "content": question}]

    while True:
        resp = client.messages.create(
            model=MODEL, max_tokens=1024, tools=TOOLS, messages=messages
        )

        for block in resp.content:
            if block.type == "text":
                print(block.text)
            elif block.type == "tool_use":
                print(f"[tool call] {block.name}({block.input})")

        # Claude is done once it stops asking for a tool.
        if resp.stop_reason != "tool_use":
            break

        # Run each requested tool and send the results back to continue the loop.
        messages.append({"role": "assistant", "content": resp.content})
        results = []
        for block in resp.content:
            if block.type == "tool_use":
                output = get_weather(**block.input) if block.name == "get_weather" else "unknown tool"
                results.append(
                    {"type": "tool_result", "tool_use_id": block.id, "content": output}
                )
        messages.append({"role": "user", "content": results})


if __name__ == "__main__":
    main()

Dockerfile

# Minimal image for the Anthropic Claude sample.
FROM python:3.13-slim

# Stream stdout/stderr unbuffered so the output appears live.
ENV PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

# Provide your config at run time (.env is NOT baked into the image):
#   docker run --rm --env-file .env aas-anthropic-claude "<question>"
ENTRYPOINT ["python", "app.py"]