# Claude Mythos 5

Claude Mythos 5 is Anthropic's model for long-running agentic coding and knowledge work. Send the official Anthropic Messages request to SeedRouter: change the base URL and the API key, keep the body. The same model also answers the OpenAI Chat Completions and Responses formats.

## Model ID

| Model ID          | Context window | Max output  | Thinking            | Default effort |
| ----------------- | -------------- | ----------- | ------------------- | -------------- |
| `claude-mythos-5` | 1M tokens      | 128K tokens | Adaptive, always on | `high`         |

See the [model page](https://seedrouter.ai/models/claude-mythos-5#pricing) for current prices.

## Quick example

```bash
curl https://api.seedrouter.ai/v1/messages \
  -H "x-api-key: $SEEDROUTER_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-mythos-5",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Summarize the trade-offs of event sourcing in three bullet points."}]
  }'
```

```python
import os
import anthropic

client = anthropic.Anthropic(
    api_key=os.environ["SEEDROUTER_API_KEY"],
    base_url="https://api.seedrouter.ai",
)

message = client.messages.create(
    model="claude-mythos-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize the trade-offs of event sourcing in three bullet points."}],
)
print("".join(block.text for block in message.content if block.type == "text"))
```

```javascript
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.SEEDROUTER_API_KEY,
  baseURL: "https://api.seedrouter.ai",
});

const message = await client.messages.create({
  model: "claude-mythos-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Summarize the trade-offs of event sourcing in three bullet points." }],
});
for (const block of message.content) if (block.type === "text") console.log(block.text);
```

```go
package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"model": "claude-mythos-5", "max_tokens": 1024,
		"messages": [{"role": "user", "content": "Summarize the trade-offs of event sourcing in three bullet points."}]}`)
	req, _ := http.NewRequest("POST", "https://api.seedrouter.ai/v1/messages", bytes.NewReader(body))
	req.Header.Set("x-api-key", os.Getenv("SEEDROUTER_API_KEY"))
	req.Header.Set("anthropic-version", "2023-06-01")
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}
```

## Endpoints

| Format                  | Method and path                                      | Authentication                                                                |
| ----------------------- | ---------------------------------------------------- | ----------------------------------------------------------------------------- |
| Anthropic Messages      | `POST https://api.seedrouter.ai/v1/messages`         | `x-api-key: <key>` or `Authorization: Bearer <key>`, plus `anthropic-version` |
| OpenAI Chat Completions | `POST https://api.seedrouter.ai/v1/chat/completions` | `Authorization: Bearer <key>`                                                 |
| OpenAI Responses        | `POST https://api.seedrouter.ai/v1/responses`        | `Authorization: Bearer <key>`                                                 |

The Messages endpoint forwards your request body as sent, including optional fields, and returns the official response. An `anthropic-beta` header is passed on as well. Keep the API key in server-side code.

## Parameters

The current native contract has 24 top-level fields. Unknown fields and unsupported sampling settings (`temperature`, `top_p`, `top_k`) are ignored before forwarding. Invalid values of supported fields are rejected.

| Field                   | Type / default              | Constraint                                                                                          |
| ----------------------- | --------------------------- | --------------------------------------------------------------------------------------------------- |
| `model`                 | Required string             | Bare model ID for Default; full model:group ID for another listed tier.                             |
| `max_tokens`            | Required integer            | 0–128000, including thinking. Zero cannot accompany stream true, structured output or forced tools. |
| `messages`              | Required array              | 1–100000 official turns; empty only for a thread continuation after pause\_turn.                    |
| `system`                | String or text-block array  | Omit entirely on thread continuation.                                                               |
| `thinking`              | Object, adaptive by default | Only adaptive. display: omitted (default), summarized, updates or null.                             |
| `output_config`         | Object                      | effort: low, medium, high (default), xhigh, max or null. Optional format and task\_budget.          |
| `output_format`         | Object or null              | Deprecated structured-output alias; prefer output\_config.format.                                   |
| `stop_sequences`        | String array                | Not nullable; incompatible with on-demand compaction.                                               |
| `stream`                | Boolean, false              | SSE when true; not nullable.                                                                        |
| `tools`                 | Array                       | Official client tools and server tools/toolsets. Client tools are executed by your application.     |
| `tool_choice`           | Object                      | auto, none, any or tool; forced choices need declared tools.                                        |
| `metadata`              | Object                      | user\_id string or null, up to 512 characters.                                                      |
| `cache_control`         | Object or null              | type ephemeral, ttl 5m or 1h.                                                                       |
| `container`             | String, object or null      | Optional id and up to 20 skills.                                                                    |
| `context_management`    | Object or null              | Official context edits; requires the appropriate beta.                                              |
| `mcp_servers`           | Array                       | Up to 20 HTTPS servers; requires the appropriate MCP beta.                                          |
| `diagnostics`           | Object or null              | previous\_message\_id string or null, up to 256 characters.                                         |
| `service_tier`          | auto or standard\_only      | Optional; not nullable.                                                                             |
| `inference_geo`         | String or null              | global or us, subject to account availability.                                                      |
| `speed`                 | String or null              | standard or null; fast is unsupported.                                                              |
| `compaction`            | Object or null              | type summarize, optional instructions up to 16384 Unicode characters.                               |
| `fallbacks`             | default, array or null      | Up to three distinct targets; official server-side-fallback beta required.                          |
| `fallback_credit_token` | String, object or null      | Token up to 2048 characters; official credit beta required; cannot accompany fallbacks.             |
| `thread`                | Object or null              | create, or continue with previous\_message\_id; message-threads-2026-08-12 required.                |

## Thinking, tools and state

Claude Mythos 5 uses adaptive thinking with high effort by default. It does not support enabled, disabled or between\_tools thinking, or budget\_tokens. `thinking.display: updates` needs `thinking-display-updates-2026-08-18`. `thinking.block_binding` allows prefix\_mismatch\_behavior error, drop\_block or null with `thinking-binding-controls-2026-08-01`.

`output_config.task_budget` requires `task-budgets-2026-03-13`, type tokens, integer total of at least 20000, and optional nonnegative integer remaining. Omit remaining when using compaction or replaying a signed compaction block. On-demand compaction requires `compact-2026-09-04` and cannot accompany context\_management, stop\_sequences, structured output or forced tools. Threshold compaction uses `compact-2026-01-12`, with an input\_tokens trigger of at least 50000.

Per-message effort is unsupported. Final assistant prefill is rejected; official pause\_turn and compaction continuations remain valid.

Computer use accepts computer\_toolset\_20260801 or computer\_20251124 with computer-use-2025-11-24. Advisor tools require advisor-tool-2026-03-01 and a supported target. Your application controls tool execution and permissions.

Thread continuation sends only new messages and must omit system and tools. It cannot accompany compaction or context edits other than keeping all thinking. State expires after five minutes without a request; retain your conversation locally. State-dependent constraints are checked when continuing.

Mythos fallback targets depend on official model and account capabilities; a target list has not been established by the local verification. Advanced beta execution and fast-mode charging require live verification; the request schema is not a measured capability guarantee.

## Media inputs

Images and PDFs go in a user turn's `content` as `image` and `document` blocks, with a `url` source or, as in the official API, a `base64` source:

```json
{"role": "user", "content": [
  {"type": "image", "source": {"type": "url", "url": "https://example.com/chart.png"}},
  {"type": "text", "text": "What does this chart show?"}
]}
```

Replace the example URL with a publicly reachable file of your own.

## Billing dimensions

See the [current rates on the model page](https://seedrouter.ai/models/claude-mythos-5#pricing). A request is billed by the tokens it uses:

* input tokens,
* output tokens, including thinking,
* prompt-cache reads, and
* prompt-cache writes, with separate 5-minute and 1-hour rates.

The charge is taken from the `usage` reported with the finished response. A request that fails is not charged. Your account's usage records show the exact charge for every request.

## Output

A non-streaming request returns the official message object:

```json
{
  "id": "msg_...",
  "type": "message",
  "role": "assistant",
  "model": "claude-mythos-5",
  "content": [{"type": "text", "text": "..."}],
  "stop_reason": "end_turn",
  "usage": {"input_tokens": 18, "output_tokens": 4, "cache_read_input_tokens": 0, "cache_creation_input_tokens": 0}
}
```

With `"stream": true` the response is a stream of the official events: `message_start`, `content_block_start`, `content_block_delta`, `content_block_stop`, `message_delta` and `message_stop`. The final `message_delta` carries the output token count.

## OpenAI-compatible formats

The same model answers the OpenAI formats, so existing OpenAI code only needs a new base URL and model ID:

```python
from openai import OpenAI

client = OpenAI(api_key="YOUR_SEEDROUTER_KEY", base_url="https://api.seedrouter.ai/v1")

chat = client.chat.completions.create(
    model="claude-mythos-5",
    messages=[{"role": "user", "content": "Hello"}],
)
response = client.responses.create(model="claude-mythos-5", input="Hello")
```

These requests are converted to the Messages format, so a field with no Messages counterpart has no effect. Their responses carry the official OpenAI fields and may include a few extra usage fields; read `usage.total_tokens` and the official fields.

## Errors

Errors on `/v1/messages` use the Anthropic shape, `{"type": "error", "error": {"type": "...", "message": "..."}}`; the other formats use `{"error": {"code": ..., "message": "..."}}`. The `code` is a code from the [common error catalog](https://seedrouter.ai/docs/api/errors). Failed requests are not charged.

## Tips

* Start with the default effort and raise it only for tasks that need more thinking; effort changes both quality and cost.
* Set `max_tokens` high enough for the thinking as well as the answer: it is one budget for both.
* Put long, reused context first and mark it with `cache_control` so later requests read it from the cache at the lower rate.

## Related

* [Claude Mythos 5 playground and pricing](https://seedrouter.ai/models/claude-mythos-5)
* [Download OpenAPI](https://seedrouter.ai/docs/claude-mythos-5.openapi.json)
* [Copyable Markdown](https://seedrouter.ai/docs/claude-mythos-5.md)

## Model tiers

Use `claude-mythos-5` for **Default**. Additional tiers appear automatically in the live price table when configured. Send the complete `model:group` ID shown on a tier to select it. Your key and account must permit that tier; its prices apply. The playground loads available choices and estimates without requiring you to paste a key.

The optional `X-SeedRouter-Group` header remains supported. If supplied together with a model suffix, both must select the same group.

Check access without generating a response:

```bash
curl "https://api.seedrouter.ai/v1/models" \
  -H "Authorization: Bearer $SEEDROUTER_API_KEY"
curl "https://api.seedrouter.ai/api/seedrouter/llm/groups?model=claude-mythos-5" \
  -H "Authorization: Bearer $SEEDROUTER_API_KEY"
```

## Official references

* [Model overview](https://platform.claude.com/docs/en/models/mythos-5/overview)
* [Messages reference](https://platform.claude.com/docs/en/api/beta/messages/create)
* [Thinking](https://platform.claude.com/docs/en/build-with-claude/thinking)

Contract checked November 10, 2026. Current prices are on the model page.
