---
title: Advisor-Tool
url: https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool
description: Kombiniere ein schnelleres Executor-Modell mit einem intelligenteren Advisor-Modell, das während der Generierung strategische Anleitung liefert.
---
Mit dem Advisor-Tool kann ein schnelleres, kostengünstigeres **„executor model" (Ausführungsmodell)** während der Generierung ein intelligenteres **„advisor model" (Berater-Modell)** um strategische Orientierung bitten. Der Advisor liest die gesamte Konversation, erstellt einen Plan oder eine Kurskorrektur, und der Executor setzt die Aufgabe fort.
Dieses Muster eignet sich für agentische Workloads mit langem Zeithorizont (Coding-Agenten, Computer Use, mehrstufige Recherche-Pipelines), bei denen die meisten Turns mechanisch sind, ein hervorragender Plan aber entscheidend ist. Du erreichst nahezu die Qualität des Advisor-Modells allein, während der Großteil der Token-Generierung zu den Preisen des Executor-Modells erfolgt. Gemessene Ergebnisse, einschließlich der Frage, wie der Nutzen schrumpft, wenn sich die Fähigkeiten des Executors denen des Advisors annähern, findest du unter [Optimierung von Kosten und Intelligenz](https://platform.claude.com/docs/de/about-claude/models/optimizing-for-cost-and-intelligence).
```mermaid
sequenceDiagram
accTitle: How the executor model consults the advisor model
accDescr: Your application sends a request with the advisor tool to the executor model, which begins the task. The executor emits a server_tool_use block, and Anthropic runs the advisor model server-side. The advisor reads the full transcript and returns strategic guidance in an advisor_tool_result. The executor continues, informed by the advice, and returns the response to your application.
participant U as Your application
participant E as Executor model
participant A as Advisor model
U->>E: Request with advisor tool
note over E: Executor begins the task
E->>A: server_tool_use (server-side)
note over A: Reads the full transcript,
returns strategic guidance
A-->>E: advisor_tool_result
note over E: Executor continues,
informed by the advice
E-->>U: Response
```
Um zu erfahren, wie „zero data retention“ (Null-Datenspeicherung), oder ZDR, auf diese Funktion angewendet wird, siehe [API und Datenspeicherung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention).
## Wann du es verwenden solltest
Der Advisor eignet sich für diese Konfigurationen:
* **Du verwendest derzeit Sonnet für komplexe Aufgaben:** Füge einen Advisor einer höheren Stufe hinzu. Mit Opus bleiben die Gesamtkosten ähnlich oder sinken; Claude Fable 5.1 maximiert den Qualitätsgewinn.
* **Du verwendest derzeit Haiku und möchtest mehr Intelligenz:** Füge einen Opus- oder Fable-Advisor hinzu. Rechne mit höheren Kosten als bei Haiku allein, aber mit niedrigeren als beim Wechsel des Executors zu einem größeren Modell.
Die Ergebnisse hängen von der Aufgabe ab. Evaluiere mit deinem eigenen Workload.
Weniger gut geeignet ist der Advisor in diesen Fällen:
* Single-Turn-Q\&A, weil es nichts zu planen gibt.
* Reine Pass-through-Modellauswahlen, bei denen deine Nutzer ihren Kompromiss zwischen Kosten und Qualität bereits selbst wählen.
* Workloads, bei denen wirklich jeder Turn die volle Leistungsfähigkeit des Advisor-Modells erfordert.
## Schnellstart
Das Advisor-Tool befindet sich in der Beta-Phase. Füge den Beta-Header `advisor-tool-2026-03-01` in deine Anfragen ein.
```bash cURL
curl https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: advisor-tool-2026-03-01" \
-H "content-type: application/json" \
-d '{
"model": "claude-sonnet-5",
"max_tokens": 4096,
"tools": [
{
"type": "advisor_20260301",
"name": "advisor",
"model": "claude-opus-5"
}
],
"messages": [{
"role": "user",
"content": "Build a concurrent worker pool in Go with graceful shutdown."
}]
}'
```
```bash CLI
ant beta:messages create --beta advisor-tool-2026-03-01 <<'YAML'
model: claude-sonnet-5
max_tokens: 4096
tools:
- type: advisor_20260301
name: advisor
model: claude-opus-5
messages:
- role: user
content: Build a concurrent worker pool in Go with graceful shutdown.
YAML
```
```python Python
client = anthropic.Anthropic()
response = client.beta.messages.create(
model="claude-sonnet-5",
max_tokens=4096,
betas=["advisor-tool-2026-03-01"],
tools=[
{
"type": "advisor_20260301",
"name": "advisor",
"model": "claude-opus-5",
}
],
messages=[
{
"role": "user",
"content": "Build a concurrent worker pool in Go with graceful shutdown.",
}
],
)
print(response)
```
```typescript TypeScript
const client = new Anthropic();
const response = await client.beta.messages.create({
model: "claude-sonnet-5",
max_tokens: 4096,
betas: ["advisor-tool-2026-03-01"],
tools: [
{
type: "advisor_20260301",
name: "advisor",
model: "claude-opus-5"
}
],
messages: [
{
role: "user",
content: "Build a concurrent worker pool in Go with graceful shutdown."
}
]
});
console.log(response);
```
```csharp C#
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
var client = new AnthropicClient();
var parameters = new MessageCreateParams
{
Model = Messages::Model.ClaudeSonnet5,
MaxTokens = 4096,
Tools = new BetaToolUnion[]
{
new BetaAdvisorTool20260301
{
Model = Messages::Model.ClaudeOpus5
}
},
Messages =
[
new BetaMessageParam
{
Role = Role.User,
Content = "Build a concurrent worker pool in Go with graceful shutdown."
}
],
Betas = ["advisor-tool-2026-03-01"]
};
var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);
```
```go Go
client := anthropic.NewClient()
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeSonnet5,
MaxTokens: 4096,
Tools: []anthropic.BetaToolUnionParam{
{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
Model: anthropic.ModelClaudeOpus5,
}},
},
Messages: []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Build a concurrent worker pool in Go with graceful shutdown.")),
},
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaAdvisorTool2026_03_01,
},
})
if err != nil {
log.Fatal(err)
}
fmt.Println(response)
```
```java Java
import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
MessageCreateParams params = MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5)
.maxTokens(4096L)
.addTool(BetaAdvisorTool20260301.builder()
.model(Model.CLAUDE_OPUS_5)
.build())
.addUserMessage("Build a concurrent worker pool in Go with graceful shutdown.")
.addBeta("advisor-tool-2026-03-01")
.build();
BetaMessage response = client.beta().messages().create(params);
IO.println(response);
}
```
```php PHP
$client = new Client();
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: [
[
'role' => 'user',
'content' => 'Build a concurrent worker pool in Go with graceful shutdown.',
],
],
model: 'claude-sonnet-5',
tools: [
[
'type' => 'advisor_20260301',
'name' => 'advisor',
'model' => 'claude-opus-5',
],
],
betas: ['advisor-tool-2026-03-01'],
);
echo $response;
```
```ruby Ruby
client = Anthropic::Client.new
response = client.beta.messages.create(
model: "claude-sonnet-5",
max_tokens: 4096,
tools: [
{
type: "advisor_20260301",
name: "advisor",
model: "claude-opus-5"
}
],
messages: [
{
role: "user",
content: "Build a concurrent worker pool in Go with graceful shutdown."
}
],
betas: ["advisor-tool-2026-03-01"]
)
puts response
```
Der `content` der Antwort enthält einen `advisor_tool_result`-Block mit der Anleitung des Advisors. Dieser Schnellstart verwendet `claude-opus-5` als Advisor. In diesem Fall ist das `content`-Feld des Blocks die Variante `advisor_redacted_result`. Sie ist verschlüsselt: Der Executor liest sie serverseitig, dein Client jedoch nicht. Wenn du den Ratschlagstext direkt in deiner Antwort sehen möchtest, verwende stattdessen `claude-opus-4-8` als Advisor-Modell. Es gibt die Klartext-Variante `advisor_result` zurück. Unter [Ergebnisvarianten](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#result-variants) findest du beide Formen nebeneinander und erfährst, welche Advisor-Modelle welche Variante zurückgeben. Die vollständige Liste gültiger Paare findest du unter [Modellkompatibilität](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#model-compatibility).
## Funktionsweise
Wenn du das Advisor-Tool zu deinem `tools`-Array hinzufügst, entscheidet das Executor-Modell wie bei jedem anderen Tool selbst, wann es das Tool aufruft. Ein Advisor-Aufruf läuft so ab:
1. Der Executor gibt einen [`server_tool_use`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools)-Block mit `name: "advisor"` und leerem `input` aus. Der Executor bestimmt also den Zeitpunkt, und der Server liefert den Kontext.
2. Anthropic führt serverseitig einen separaten Inferenzdurchlauf auf dem Advisor-Modell aus. Der Advisor läuft unter seinem eigenen, von Anthropic bereitgestellten „system prompt" (System-Prompt). Als Eingabe erhält er das vollständige Transkript des Executors als zitierten Kontext. Dieses Transkript umfasst deinen System-Prompt, die Tool-Definitionen, die vorherigen Turns und Tool-Ergebnisse sowie den Text, den der Executor in diesem Turn bisher erzeugt hat.
3. Die Antwort des Advisors geht als `advisor_tool_result`-Block an den Executor zurück.
4. Der Executor generiert weiter und berücksichtigt dabei den Ratschlag.
All dies geschieht innerhalb einer einzigen `/v1/messages`-Anfrage, ohne zusätzliche Roundtrips auf deiner Seite. Die Ausnahme ist ein Turn, der mitten im Aufruf pausiert. Diesen setzt du mit einer Folgeanfrage fort (siehe [Einen pausierten Turn fortsetzen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#resuming-a-paused-turn)).
Der Advisor selbst läuft ohne Tools und ohne Kontextverwaltung. Seine „thinking blocks" (Thinking-Blöcke) werden verworfen, bevor das Ergebnis zurückgegeben wird. Nur der Ratschlagstext erreicht den Executor.
## Tool-Parameter
| Parameter | Typ | Standard | Beschreibung |
| ------------ | -------------- | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `type` | string | *erforderlich* | Muss `"advisor_20260301"` sein. |
| `name` | string | *erforderlich* | Muss `"advisor"` sein. |
| `model` | string | *erforderlich* | Die ID des Advisor-Modells, z. B. claude-opus-5. Die Sub-Inferenz wird zu den Preisen dieses Modells abgerechnet. |
| `max_uses` | integer | unbegrenzt | Maximale Anzahl an Advisor-Aufrufen in einer einzelnen Anfrage. Sobald der Executor diese Obergrenze erreicht, geben weitere Advisor-Aufrufe einen `advisor_tool_result_error` mit `error_code: "max_uses_exceeded"` zurück. Der Executor fährt dann ohne weitere Ratschläge fort. Die Obergrenze gilt pro Anfrage, nicht pro Konversation. Limits auf Konversationsebene findest du unter [Kostenkontrolle](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#cost-control). |
| `max_tokens` | integer | Ausgabeobergrenze des Advisor-Modells | Begrenzt die gesamte Ausgabe des Advisors („thinking" (Nachdenken) plus Text) pro Aufruf. Minimum 1024. Siehe [Advisor-Ausgabe begrenzen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#capping-advisor-output). |
| `caching` | object \| null | `null` (aus) | Aktiviert [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) für das eigene Transkript des Advisors über mehrere Aufrufe innerhalb einer Konversation. Siehe [Advisor-Prompt-Caching](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#advisor-prompt-caching). |
Das `caching`-Objekt hat die Form `{"type": "ephemeral", "ttl": "5m" | "1h"}`. Anders als `cache_control` bei Content-Blöcken ist es keine Breakpoint-Markierung, sondern ein Ein/Aus-Schalter. Wo die Cache-Grenzen liegen, bestimmt der Server.
Das Advisor-Tool akzeptiert außerdem die generischen Eigenschaften, die jede Tool-Definition unterstützt: `cache_control`, `allowed_callers`, `defer_loading` und `strict` (beschrieben unter [Structured Outputs](https://platform.claude.com/docs/de/build-with-claude/structured-outputs)). Ihre Semantik findest du in der [Tool-Referenz](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#tool-definition-properties).
## Antwortstruktur
### Erfolgreicher Advisor-Aufruf
Wenn der Advisor aufgerufen wird, folgt im Content des Assistenten auf einen `server_tool_use`-Block ein `advisor_tool_result`-Block. Das folgende Beispiel zeigt die Klartext-Variante `advisor_result`, die ein Claude Opus 4.8-Advisor zurückgibt. Der [Schnellstart](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#quick-start) verwendet dagegen Claude Opus 5, das die verschlüsselte Variante `advisor_redacted_result` zurückgibt. Beide Formen nebeneinander findest du unter [Ergebnisvarianten](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#result-variants).
```json
{
"role": "assistant",
"content": [
{
"type": "text",
"text": "Let me consult the advisor on this."
},
{
"type": "server_tool_use",
"id": "srvtoolu_abc123",
"name": "advisor",
"input": {}
},
{
"type": "advisor_tool_result",
"tool_use_id": "srvtoolu_abc123",
"content": {
"type": "advisor_result",
"text": "Use a channel-based coordination pattern. The tricky part is draining in-flight work during shutdown: close the input channel first, then wait on a WaitGroup..."
}
},
{
"type": "text",
"text": "Here's the implementation. I'm using a channel-based coordination pattern to avoid writer starvation..."
}
]
}
```
`server_tool_use.input` ist immer leer. Der Server erstellt die Sicht des Advisors automatisch aus dem vollständigen Transkript. Was der Executor in `input` einträgt, erreicht den Advisor nicht.
### Ergebnisvarianten
Das Feld `advisor_tool_result.content` ist eine Discriminated Union. Bei erfolgreichen Aufrufen hängt die Variante vom Advisor-Modell ab:
| Variante | Felder | Zurückgegeben, wenn |
| ------------------------- | ---------------------------------- | ---------------------------------------------------------------------- |
| `advisor_result` | `text`, `stop_reason` | Das Advisor-Modell Klartext zurückgibt (zum Beispiel Claude Opus 4.8). |
| `advisor_redacted_result` | `encrypted_content`, `stop_reason` | Das Advisor-Modell verschlüsselte Ausgabe zurückgibt. |
Claude Sonnet 5.5, Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Fable 5, Claude Mythos 5 und Claude Haiku 5.5 geben als Advisor das verschlüsselte `advisor_redacted_result` zurück. Jedes andere Advisor-Modell in der [Kompatibilitätstabelle](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#model-compatibility) gibt das Klartext-`advisor_result` zurück. Um den Ratschlagstext in deinen eigenen Antworten zu lesen, verwende einen Advisor, der Klartext zurückgibt, wie `claude-opus-4-8`, sofern die Zeile deines Executors in der [Kompatibilitätstabelle](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#model-compatibility) einen solchen aufführt. Executors vom Typ Claude Sonnet 5.5, Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Opus 5, Claude Fable 5 und Claude Mythos 5 lassen sich nur mit Advisors kombinieren, die die verschlüsselte Form zurückgeben, sodass der Ratschlagstext bei diesen Executors in der Antwort nicht lesbar ist.
Die folgenden Beispiele zeigen beide Varianten anhand derselben Anfrage, die zweimal gesendet wird und sich nur im Advisor-`model` in der Tool-Definition unterscheidet.
Mit `"model": "claude-opus-4-8"` ist der Ratschlag Klartext:
```json
{
"type": "advisor_tool_result",
"tool_use_id": "srvtoolu_abc123",
"content": {
"type": "advisor_result",
"text": "Use a channel-based coordination pattern. The tricky part is draining in-flight work during shutdown: close the input channel first, then wait on a WaitGroup..."
}
}
```
Mit `"model": "claude-opus-5"` ist der Ratschlag verschlüsselt:
```json
{
"type": "advisor_tool_result",
"tool_use_id": "srvtoolu_abc123",
"content": {
"type": "advisor_redacted_result",
"encrypted_content": "EqQBCkYIBRgCIiQ5ZjE0N2M2OC0yYWIxLTRkZTktYjA3ZC1hZTUyMzkxYjhkMmU..."
}
}
```
Beide Ergebnisvarianten enthalten ein `stop_reason`-Feld, wenn du [`max_tokens`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#capping-advisor-output) in der Tool-Definition festlegst, und lassen es weg, wenn du das nicht tust. Es enthält den Stop-Grund des Advisor-Unteraufrufs, typischerweise `"end_turn"`, oder `"max_tokens"`, wenn die Obergrenze erreicht wird. Die Werte entsprechen dem [`stop_reason`](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons) der Messages API auf oberster Ebene.
Bei `advisor_result` enthält das Feld `text` menschenlesbaren Ratschlag. Bei `advisor_redacted_result` enthält das Feld `encrypted_content` einen undurchsichtigen Blob, den du nicht lesen kannst. Im nächsten Turn entschlüsselt der Server ihn und fügt den Klartext in den Prompt des Executors ein.
Gib den Inhalt in beiden Fällen in nachfolgenden Turns unverändert zurück. Wenn du mitten in der Konversation das Advisor-Modell wechselst, verzweige anhand von `content.type`, um beide Formen zu verarbeiten.
### Fehlerergebnisse
Wenn der Advisor-Aufruf fehlschlägt, enthält das Ergebnis einen Fehler:
```json
{
"type": "advisor_tool_result",
"tool_use_id": "srvtoolu_abc123",
"content": {
"type": "advisor_tool_result_error",
"error_code": "overloaded"
}
}
```
Der Executor sieht den Fehler und fährt ohne weitere Ratschläge fort. Die Anfrage selbst schlägt nicht fehl.
| `error_code` | Bedeutung |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `max_uses_exceeded` | Die Anfrage hat die in der Tool-Definition festgelegte `max_uses`-Obergrenze erreicht. Weitere Advisor-Aufrufe in derselben Anfrage geben diesen Fehler zurück. |
| `too_many_requests` | Die Advisor-Sub-Inferenz hat ein „rate limit" (Ratenlimit) erreicht. |
| `overloaded` | Die Advisor-Sub-Inferenz hat Kapazitätsgrenzen erreicht. |
| `prompt_too_long` | Das Transkript hat das „context window" (Kontextfenster) des Advisor-Modells überschritten. |
| `execution_time_exceeded` | Bei der Advisor-Sub-Inferenz ist eine Zeitüberschreitung aufgetreten. |
| `model_not_found` | Das konfigurierte Advisor-Modell ist nicht verfügbar. |
| `unavailable` | Jeder andere Advisor-Fehler. |
Ratenlimits für den Advisor zählen gegen dasselbe modellbezogene Kontingent wie direkte Aufrufe des Advisor-Modells. Ein Ratenlimit beim Advisor erscheint als `too_many_requests` im Tool-Ergebnis. Ein Ratenlimit beim Executor lässt dagegen die gesamte Anfrage mit HTTP 429 fehlschlagen.
## Multi-Turn-Konversationen
Übergib in nachfolgenden Turns den vollständigen Assistenten-Content an die API zurück, einschließlich der `advisor_tool_result`-Blöcke. Gib die Ergebnisblöcke dabei unverändert zurück. Bei einem Claude Opus 5-Advisor ist der `content` des Ergebnisblocks die verschlüsselte Variante `advisor_redacted_result`. Der Server entschlüsselt sie und fügt den Ratschlag im nächsten Turn in den Prompt des Executors ein (siehe [Ergebnisvarianten](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#result-variants)). Die Mechanik ist für jedes Advisor-Modell identisch.
```python Python
client = anthropic.Anthropic()
tools = [
{
"type": "advisor_20260301",
"name": "advisor",
"model": "claude-opus-5",
}
]
messages = [
{
"role": "user",
"content": "Build a concurrent worker pool in Go with graceful shutdown.",
}
]
response = client.beta.messages.create(
model="claude-sonnet-5",
max_tokens=1024,
betas=["advisor-tool-2026-03-01"],
tools=tools,
messages=messages,
)
# Hänge den vollständigen Antwortinhalt an, einschließlich aller advisor_tool_result-Blöcke
messages.append({"role": "assistant", "content": response.content})
# Setze die Unterhaltung fort
messages.append({"role": "user", "content": "Now add a max-in-flight limit of 10."})
response = client.beta.messages.create(
model="claude-sonnet-5",
max_tokens=1024,
betas=["advisor-tool-2026-03-01"],
tools=tools,
messages=messages,
)
```
```typescript TypeScript
const client = new Anthropic();
const tools: Anthropic.Beta.Messages.BetaToolUnion[] = [
{
type: "advisor_20260301",
name: "advisor",
model: "claude-opus-5"
}
];
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
{
role: "user",
content: "Build a concurrent worker pool in Go with graceful shutdown."
}
];
const response = await client.beta.messages.create({
model: "claude-sonnet-5",
max_tokens: 1024,
betas: ["advisor-tool-2026-03-01"],
tools,
messages
});
// Hänge den vollständigen Antwortinhalt an, einschließlich aller advisor_tool_result-Blöcke
messages.push({ role: "assistant", content: response.content });
// Setze die Unterhaltung fort
messages.push({ role: "user", content: "Now add a max-in-flight limit of 10." });
const followUp = await client.beta.messages.create({
model: "claude-sonnet-5",
max_tokens: 1024,
betas: ["advisor-tool-2026-03-01"],
tools,
messages
});
```
```csharp C#
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
var client = new AnthropicClient();
var tools = new BetaToolUnion[]
{
new BetaAdvisorTool20260301 { Model = Messages::Model.ClaudeOpus5 }
};
var messages = new List
{
new() { Role = Role.User, Content = "Build a concurrent worker pool in Go with graceful shutdown." }
};
var response = await client.Beta.Messages.Create(new MessageCreateParams
{
Model = Messages::Model.ClaudeSonnet5,
MaxTokens = 1024,
Tools = tools,
Messages = messages,
Betas = ["advisor-tool-2026-03-01"]
});
// Hänge den vollständigen Antwortinhalt an, einschließlich aller advisor_tool_result-Blöcke
messages.Add(new BetaMessageParam
{
Role = Role.Assistant,
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
// Setze die Konversation fort
messages.Add(new BetaMessageParam { Role = Role.User, Content = "Now add a max-in-flight limit of 10." });
var followUp = await client.Beta.Messages.Create(new MessageCreateParams
{
Model = Messages::Model.ClaudeSonnet5,
MaxTokens = 1024,
Tools = tools,
Messages = messages,
Betas = ["advisor-tool-2026-03-01"]
});
```
```go Go
client := anthropic.NewClient()
tools := []anthropic.BetaToolUnionParam{
{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
Model: anthropic.ModelClaudeOpus5,
}},
}
messages := []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Build a concurrent worker pool in Go with graceful shutdown.")),
}
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeSonnet5,
MaxTokens: 1024,
Tools: tools,
Messages: messages,
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaAdvisorTool2026_03_01,
},
})
if err != nil {
log.Fatal(err)
}
// Hänge den vollständigen Antwortinhalt an, einschließlich aller advisor_tool_result-Blöcke.
messages = append(messages, response.ToParam())
// Setze die Unterhaltung fort
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Now add a max-in-flight limit of 10.")))
response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeSonnet5,
MaxTokens: 1024,
Tools: tools,
Messages: messages,
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaAdvisorTool2026_03_01,
},
})
if err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaContentBlock;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaMessageParam;
import com.anthropic.models.beta.messages.BetaToolUnion;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
List tools = List.of(
BetaToolUnion.ofAdvisorTool20260301(
BetaAdvisorTool20260301.builder().model(Model.CLAUDE_OPUS_5).build()));
List messages = new ArrayList<>();
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.content("Build a concurrent worker pool in Go with graceful shutdown.")
.build());
BetaMessage response = client.beta().messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5)
.maxTokens(1024L)
.tools(tools)
.messages(messages)
.addBeta("advisor-tool-2026-03-01")
.build());
// Hänge den vollständigen Antwortinhalt an, einschließlich aller advisor_tool_result-Blöcke
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.ASSISTANT)
.contentOfBetaContentBlockParams(
response.content().stream().map(BetaContentBlock::toParam).toList())
.build());
// Setze die Unterhaltung fort
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.content("Now add a max-in-flight limit of 10.")
.build());
BetaMessage followUp = client.beta().messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5)
.maxTokens(1024L)
.tools(tools)
.messages(messages)
.addBeta("advisor-tool-2026-03-01")
.build());
}
```
```php PHP
$client = new Client();
$tools = [
[
'type' => 'advisor_20260301',
'name' => 'advisor',
'model' => 'claude-opus-5',
],
];
$messages = [
[
'role' => 'user',
'content' => 'Build a concurrent worker pool in Go with graceful shutdown.',
],
];
$response = $client->beta->messages->create(
maxTokens: 1024,
messages: $messages,
model: 'claude-sonnet-5',
tools: $tools,
betas: ['advisor-tool-2026-03-01'],
);
// Hänge den vollständigen Antwortinhalt an, einschließlich aller advisor_tool_result-Blöcke
$messages[] = ['role' => 'assistant', 'content' => $response->content];
// Setze die Konversation fort
$messages[] = ['role' => 'user', 'content' => 'Now add a max-in-flight limit of 10.'];
$response = $client->beta->messages->create(
maxTokens: 1024,
messages: $messages,
model: 'claude-sonnet-5',
tools: $tools,
betas: ['advisor-tool-2026-03-01'],
);
```
```ruby Ruby
client = Anthropic::Client.new
tools = [
{
type: "advisor_20260301",
name: "advisor",
model: "claude-opus-5"
}
]
messages = [
{
role: "user",
content: "Build a concurrent worker pool in Go with graceful shutdown."
}
]
response = client.beta.messages.create(
model: "claude-sonnet-5",
max_tokens: 1024,
tools: tools,
messages: messages,
betas: ["advisor-tool-2026-03-01"]
)
# Hänge den vollständigen Antwortinhalt an, einschließlich aller advisor_tool_result-Blöcke
messages << { role: "assistant", content: response.content }
# Setze die Konversation fort
messages << { role: "user", content: "Now add a max-in-flight limit of 10." }
response = client.beta.messages.create(
model: "claude-sonnet-5",
max_tokens: 1024,
tools: tools,
messages: messages,
betas: ["advisor-tool-2026-03-01"]
)
```
Du kannst das Advisor-Tool in einem Folge-Turn aus `tools` entfernen, auch wenn der Nachrichtenverlauf noch `advisor_tool_result`-Blöcke enthält. Die Anfrage wird akzeptiert, und die historischen Blöcke bleiben erhalten. Das Modell kann den Advisor in diesem Turn allerdings nicht aufrufen. Den Beta-Header `advisor-tool-2026-03-01` musst du trotzdem senden, damit diese Verlaufsblöcke akzeptiert werden.
Das Advisor-Tool hat keine eingebaute Obergrenze auf Konversationsebene. Um die Advisor-Aufrufe über eine Konversation hinweg zu begrenzen, zähle sie clientseitig. Wenn du deine Obergrenze erreichst, entferne das Advisor-Tool aus deinem `tools`-Array. Die `advisor_tool_result`-Blöcke musst du nicht aus deinem Nachrichtenverlauf entfernen.
### Einen pausierten Turn fortsetzen
Eine Antwort kann mit `stop_reason: "pause_turn"` enden, während ein Advisor-Aufruf noch aussteht. Die Antwort enthält dann den `server_tool_use`-Block des Advisors, aber kein zugehöriges `advisor_tool_result`.
So setzt du den Turn fort:
1. Hänge diese Assistenten-Nachricht mit unverändertem Inhalt an `messages` an. Der `server_tool_use`-Block muss dabei erhalten bleiben.
2. Sende die Anfrage erneut mit demselben Advisor-Tool und demselben Beta-Header. Eine Benutzernachricht oder einen `tool_result`-Block musst du nicht hinzufügen.
Die API führt den ausstehenden Advisor-Aufruf aus und setzt den Turn des Executors in der neuen Antwort fort. Ein fortgesetzter Turn kann erneut pausieren. Wiederhole in diesem Fall dieselben Schritte.
Füge das Advisor-Tool immer hinzu, solange ein Aufruf aussteht. Fehlt es in der Fortsetzungsanfrage, gibt die API einen 400 `invalid_request_error` zurück, weil für den ausstehenden `server_tool_use`-Block keine Tool-Definition vorhanden ist.
Hat der Executor im selben Turn stattdessen eines deiner Tools aufgerufen, endet die Antwort mit `stop_reason: "tool_use"`, während der Advisor-Aufruf noch aussteht. Sende die `tool_result`-Blöcke wie gewohnt. Der ausstehende Advisor-Aufruf wird dann zu Beginn dieser nächsten Anfrage ausgeführt. Siehe [Server-Tools und Client-Tools in einem Turn kombinieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools#mixing-server-tools-and-client-tools-in-one-turn).
### Anstoß mitten in der Konversation für Executors, die zu selten aufrufen
Wenn ein Haiku-Executor den Advisor in seinem ersten Assistenten-Turn nicht aufgerufen hat, hänge vor dem zweiten Assistenten-Turn eine kurze Erinnerung als zusätzliche Nutzernachricht an. In Anthropics interner Verhaltensevaluation mit Claude Haiku 4.5-Executors erhöhte dies die Erfolgsquote bei Aufgaben um etwa 7 Prozentpunkte. Bei Sonnet-Executors hatte der Klartext-Anstoß in Anthropics Tests keinen messbaren Effekt. Die folgenden Überlegungen zum Aufrufzeitpunkt sind besonders für Sonnet relevant. Wende den Anstoß nicht auf Opus-Executors an: Bei Opus senkte er die Erfolgsquoten leicht.
Mit dem Standardwert `NUDGE_TURN` von 2 kommt die Erinnerung typischerweise an, nachdem sich das Modell in der Aufgabe orientiert hat, aber bevor es sich auf einen Ansatz festgelegt hat.
```python Python
client = anthropic.Anthropic()
NUDGE_TURN = 2 # inject before this assistant turn if no advisor call yet
NUDGE_TEXT = (
"You have not consulted the advisor yet. If the task has a non-obvious "
"design decision or a failure mode you haven't ruled out, call advisor "
"now before committing to an approach."
)
MAX_TURNS = 10 # agent loop cap
def run_your_tools(content):
# Ersetze dies durch dein Tool-Dispatching. Gibt pro tool_use-Block einen tool_result-Block zurück.
return [
{
"type": "tool_result",
"tool_use_id": block.id,
"content": "Replace with your tool output.",
}
for block in content
if block.type == "tool_use"
]
tools = [
{"type": "advisor_20260301", "name": "advisor", "model": "claude-opus-5"},
# ... deine anderen Tools
]
task = "Build a concurrent worker pool in Go with graceful shutdown."
messages = [{"role": "user", "content": task}]
advisor_called = False
for turn in range(1, MAX_TURNS + 1):
response = client.beta.messages.create(
model="claude-haiku-5-5",
max_tokens=4096,
betas=["advisor-tool-2026-03-01"],
tools=tools,
messages=messages,
)
messages.append({"role": "assistant", "content": response.content})
advisor_called = advisor_called or any(
block.type == "server_tool_use" and block.name == "advisor"
for block in response.content
)
if response.stop_reason == "pause_turn":
continue # server tool pending; re-send to let the API complete it
if response.stop_reason != "tool_use":
break # end_turn, or a stop such as max_tokens that needs handling (see below)
results = run_your_tools(response.content) # list of tool_result blocks
if results:
messages.append({"role": "user", "content": results})
# Überspringe dies, wenn dein System-Prompt das Modell bereits anweist, sparsam aufzurufen.
if turn == NUDGE_TURN - 1 and not advisor_called:
messages.append({"role": "user", "content": NUDGE_TEXT})
```
```typescript TypeScript
const client = new Anthropic();
const NUDGE_TURN = 2; // inject before this assistant turn if no advisor call yet
const NUDGE_TEXT =
"You have not consulted the advisor yet. If the task has a non-obvious " +
"design decision or a failure mode you haven't ruled out, call advisor " +
"now before committing to an approach.";
const MAX_TURNS = 10; // agent loop cap
function runYourTools(
content: Anthropic.Beta.Messages.BetaContentBlock[]
): Anthropic.Beta.Messages.BetaToolResultBlockParam[] {
// Ersetze dies durch dein Tool-Dispatching. Gibt pro tool_use-Block einen tool_result-Block zurück.
return content
.filter((block) => block.type === "tool_use")
.map((block) => ({
type: "tool_result" as const,
tool_use_id: block.id,
content: "Replace with your tool output."
}));
}
const tools: Anthropic.Beta.Messages.BetaToolUnion[] = [
{ type: "advisor_20260301", name: "advisor", model: "claude-opus-5" }
// ... deine anderen Tools
];
const task = "Build a concurrent worker pool in Go with graceful shutdown.";
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [{ role: "user", content: task }];
let advisorCalled = false;
for (let turn = 1; turn <= MAX_TURNS; turn++) {
const response = await client.beta.messages.create({
model: "claude-haiku-5-5",
max_tokens: 4096,
betas: ["advisor-tool-2026-03-01"],
tools,
messages
});
messages.push({ role: "assistant", content: response.content });
advisorCalled =
advisorCalled ||
response.content.some(
(block) => block.type === "server_tool_use" && block.name === "advisor"
);
if (response.stop_reason === "pause_turn") {
continue; // server tool pending; re-send to let the API complete it
}
if (response.stop_reason !== "tool_use") {
break; // end_turn, or a stop such as max_tokens that needs handling (see below)
}
const results = runYourTools(response.content); // list of tool_result blocks
if (results.length > 0) {
messages.push({ role: "user", content: results });
}
// Überspringe dies, wenn dein System-Prompt das Modell bereits anweist, sparsam aufzurufen.
if (turn === NUDGE_TURN - 1 && !advisorCalled) {
messages.push({ role: "user", content: NUDGE_TEXT });
}
}
```
```csharp C#
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
var client = new AnthropicClient();
const int NudgeTurn = 2; // inject before this assistant turn if no advisor call yet
const string NudgeText =
"You have not consulted the advisor yet. If the task has a non-obvious "
+ "design decision or a failure mode you haven't ruled out, call advisor "
+ "now before committing to an approach.";
const int MaxTurns = 10; // agent loop cap
// Ersetze dies durch dein Tool-Dispatching. Gibt pro tool_use-Block einen tool_result-Block zurück.
List RunYourTools(IReadOnlyList content)
{
List results = [];
foreach (var block in content)
{
if (block.TryPickToolUse(out var toolUse))
{
results.Add(new BetaToolResultBlockParam
{
ToolUseID = toolUse.ID,
Content = "Replace with your tool output."
});
}
}
return results;
}
var tools = new BetaToolUnion[]
{
new BetaAdvisorTool20260301 { Model = Messages::Model.ClaudeOpus5 }
// ... deine anderen Tools
};
var task = "Build a concurrent worker pool in Go with graceful shutdown.";
var messages = new List { new() { Role = Role.User, Content = task } };
var advisorCalled = false;
for (var turn = 1; turn <= MaxTurns; turn++)
{
var response = await client.Beta.Messages.Create(new MessageCreateParams
{
Model = Messages::Model.ClaudeHaiku5_5,
MaxTokens = 4096,
Tools = tools,
Messages = messages,
Betas = ["advisor-tool-2026-03-01"]
});
messages.Add(new BetaMessageParam
{
Role = Role.Assistant,
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
advisorCalled =
advisorCalled
|| response.Content.Any(block =>
block.TryPickServerToolUse(out var serverToolUse)
&& serverToolUse.Name.Value() == Name.Advisor
);
if (response.StopReason == BetaStopReason.PauseTurn)
{
continue; // server tool pending; re-send to let the API complete it
}
if (response.StopReason != BetaStopReason.ToolUse)
{
break; // end_turn, or a stop such as max_tokens that needs handling (see below)
}
var results = RunYourTools(response.Content); // list of tool_result blocks
if (results.Count > 0)
{
messages.Add(new BetaMessageParam { Role = Role.User, Content = results });
}
// Überspringe dies, wenn dein System-Prompt das Modell bereits anweist, sparsam aufzurufen.
if (turn == NudgeTurn - 1 && !advisorCalled)
{
messages.Add(new BetaMessageParam { Role = Role.User, Content = NudgeText });
}
}
```
```go Go
const (
nudgeTurn = 2 // inject before this assistant turn if no advisor call yet
nudgeText = "You have not consulted the advisor yet. If the task has a non-obvious " +
"design decision or a failure mode you haven't ruled out, call advisor " +
"now before committing to an approach."
maxTurns = 10 // agent loop cap
)
// Ersetze dies durch dein Tool-Dispatching. Gibt pro tool_use-Block einen tool_result-Block zurück.
func runYourTools(content []anthropic.BetaContentBlockUnion) []anthropic.BetaContentBlockParamUnion {
var results []anthropic.BetaContentBlockParamUnion
for _, block := range content {
if block.Type == "tool_use" {
results = append(results, anthropic.NewBetaToolResultBlock(block.ID, "Replace with your tool output.", false))
}
}
return results
}
func main() {
client := anthropic.NewClient()
tools := []anthropic.BetaToolUnionParam{
{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
Model: anthropic.ModelClaudeOpus5,
}},
// ... deine anderen Tools
}
task := "Build a concurrent worker pool in Go with graceful shutdown."
messages := []anthropic.BetaMessageParam{
anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(task)),
}
advisorCalled := false
for turn := 1; turn <= maxTurns; turn++ {
response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
Model: anthropic.ModelClaudeHaiku5_5,
MaxTokens: 4096,
Tools: tools,
Messages: messages,
Betas: []anthropic.AnthropicBeta{
anthropic.AnthropicBetaAdvisorTool2026_03_01,
},
})
if err != nil {
log.Fatal(err)
}
messages = append(messages, response.ToParam())
for _, block := range response.Content {
if block.Type == "server_tool_use" && block.Name == "advisor" {
advisorCalled = true
}
}
if response.StopReason == anthropic.BetaStopReasonPauseTurn {
continue // server tool pending; re-send to let the API complete it
}
if response.StopReason != anthropic.BetaStopReasonToolUse {
break // end_turn, or a stop such as max_tokens that needs handling (see below)
}
results := runYourTools(response.Content) // list of tool_result blocks
if len(results) > 0 {
messages = append(messages, anthropic.BetaMessageParam{
Role: anthropic.BetaMessageParamRoleUser,
Content: results,
})
}
// Überspringe dies, wenn dein System-Prompt das Modell bereits anweist, sparsam aufzurufen.
if turn == nudgeTurn-1 && !advisorCalled {
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(nudgeText)))
}
}
}
```
```java Java
import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaContentBlock;
import com.anthropic.models.beta.messages.BetaContentBlockParam;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaMessageParam;
import com.anthropic.models.beta.messages.BetaServerToolUseBlock;
import com.anthropic.models.beta.messages.BetaStopReason;
import com.anthropic.models.beta.messages.BetaToolResultBlockParam;
import com.anthropic.models.beta.messages.BetaToolUnion;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
static final int NUDGE_TURN = 2; // inject before this assistant turn if no advisor call yet
static final String NUDGE_TEXT =
"You have not consulted the advisor yet. If the task has a non-obvious "
+ "design decision or a failure mode you haven't ruled out, call advisor "
+ "now before committing to an approach.";
static final int MAX_TURNS = 10; // agent loop cap
// Ersetze dies durch dein Tool-Dispatching. Gibt pro tool_use-Block einen tool_result-Block zurück.
List runYourTools(List content) {
List results = new ArrayList<>();
for (BetaContentBlock block : content) {
if (block.isToolUse()) {
results.add(BetaContentBlockParam.ofToolResult(
BetaToolResultBlockParam.builder()
.toolUseId(block.asToolUse().id())
.content("Replace with your tool output.")
.build()));
}
}
return results;
}
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
List tools = List.of(
BetaToolUnion.ofAdvisorTool20260301(
BetaAdvisorTool20260301.builder().model(Model.CLAUDE_OPUS_5).build())
// ... deine anderen Tools
);
String task = "Build a concurrent worker pool in Go with graceful shutdown.";
List messages = new ArrayList<>();
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.content(task)
.build());
boolean advisorCalled = false;
for (int turn = 1; turn <= MAX_TURNS; turn++) {
BetaMessage response = client.beta().messages().create(MessageCreateParams.builder()
.model(Model.CLAUDE_HAIKU_5_5)
.maxTokens(4096L)
.tools(tools)
.messages(messages)
.addBeta("advisor-tool-2026-03-01")
.build());
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.ASSISTANT)
.contentOfBetaContentBlockParams(
response.content().stream().map(BetaContentBlock::toParam).toList())
.build());
advisorCalled = advisorCalled
|| response.content().stream().anyMatch(block ->
block.isServerToolUse()
&& block.asServerToolUse().name().equals(BetaServerToolUseBlock.Name.ADVISOR));
BetaStopReason stopReason = response.stopReason().orElse(null);
if (BetaStopReason.PAUSE_TURN.equals(stopReason)) {
continue; // server tool pending; re-send to let the API complete it
}
if (!BetaStopReason.TOOL_USE.equals(stopReason)) {
break; // end_turn, or a stop such as max_tokens that needs handling (see below)
}
List results = runYourTools(response.content()); // list of tool_result blocks
if (!results.isEmpty()) {
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.contentOfBetaContentBlockParams(results)
.build());
}
// Überspringe dies, wenn dein System-Prompt das Modell bereits anweist, sparsam aufzurufen.
if (turn == NUDGE_TURN - 1 && !advisorCalled) {
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.USER)
.content(NUDGE_TEXT)
.build());
}
}
}
```
```php PHP
$client = new Client();
const NUDGE_TURN = 2; // inject before this assistant turn if no advisor call yet
const NUDGE_TEXT = "You have not consulted the advisor yet. If the task has a non-obvious "
. "design decision or a failure mode you haven't ruled out, call advisor "
. "now before committing to an approach.";
const MAX_TURNS = 10; // agent loop cap
// Ersetze dies durch dein Tool-Dispatching. Gibt pro tool_use-Block einen tool_result-Block zurück.
function runYourTools(array $content): array
{
$results = [];
foreach ($content as $block) {
if ($block->type === 'tool_use') {
$results[] = [
'type' => 'tool_result',
'tool_use_id' => $block->id,
'content' => 'Replace with your tool output.',
];
}
}
return $results;
}
$tools = [
['type' => 'advisor_20260301', 'name' => 'advisor', 'model' => 'claude-opus-5'],
// ... deine anderen Tools
];
$task = 'Build a concurrent worker pool in Go with graceful shutdown.';
$messages = [['role' => 'user', 'content' => $task]];
$advisorCalled = false;
for ($turn = 1; $turn <= MAX_TURNS; $turn++) {
$response = $client->beta->messages->create(
maxTokens: 4096,
messages: $messages,
model: 'claude-haiku-5-5',
tools: $tools,
betas: ['advisor-tool-2026-03-01'],
);
$messages[] = ['role' => 'assistant', 'content' => $response->content];
foreach ($response->content as $block) {
if ($block->type === 'server_tool_use' && $block->name === 'advisor') {
$advisorCalled = true;
}
}
if ($response->stopReason === 'pause_turn') {
continue; // server tool pending; re-send to let the API complete it
}
if ($response->stopReason !== 'tool_use') {
break; // end_turn, or a stop such as max_tokens that needs handling (see below)
}
$results = runYourTools($response->content); // list of tool_result blocks
if ($results !== []) {
$messages[] = ['role' => 'user', 'content' => $results];
}
// Überspringe dies, wenn dein System-Prompt das Modell bereits anweist, sparsam aufzurufen.
if ($turn === NUDGE_TURN - 1 && !$advisorCalled) {
$messages[] = ['role' => 'user', 'content' => NUDGE_TEXT];
}
}
```
```ruby Ruby
client = Anthropic::Client.new
NUDGE_TURN = 2 # inject before this assistant turn if no advisor call yet
NUDGE_TEXT =
"You have not consulted the advisor yet. If the task has a non-obvious " \
"design decision or a failure mode you haven't ruled out, call advisor " \
"now before committing to an approach."
MAX_TURNS = 10 # agent loop cap
# Ersetze dies durch dein Tool-Dispatching. Gibt pro tool_use-Block einen tool_result-Block zurück.
def run_your_tools(content)
content.filter_map do |block|
next unless block.type == :tool_use
{ type: "tool_result", tool_use_id: block.id, content: "Replace with your tool output." }
end
end
tools = [
{ type: "advisor_20260301", name: "advisor", model: "claude-opus-5" }
# ... deine anderen Tools
]
task = "Build a concurrent worker pool in Go with graceful shutdown."
messages = [{ role: "user", content: task }]
advisor_called = false
(1..MAX_TURNS).each do |turn|
response = client.beta.messages.create(
model: "claude-haiku-5-5",
max_tokens: 4096,
tools: tools,
messages: messages,
betas: ["advisor-tool-2026-03-01"]
)
messages << { role: "assistant", content: response.content }
advisor_called ||= response.content.any? do |block|
block.type == :server_tool_use && block.name == :advisor
end
next if response.stop_reason == :pause_turn # server tool pending; re-send to let the API complete it
break unless response.stop_reason == :tool_use # end_turn, or a stop such as max_tokens that needs handling (see below)
results = run_your_tools(response.content) # list of tool_result blocks
messages << { role: "user", content: results } unless results.empty?
# Überspringe dies, wenn dein System-Prompt das Modell bereits anweist, sparsam aufzurufen.
messages << { role: "user", content: NUDGE_TEXT } if turn == NUDGE_TURN - 1 && !advisor_called
end
```
Die Schleife endet bei jedem Stop-Grund außer `tool_use` oder `pause_turn`. Wenn `max_tokens` eine Antwort abschneidet, entferne den abgeschnittenen Assistenten-Turn aus `messages` und [versuche es mit einem höheren `max_tokens` erneut](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons#max-tokens). Wenn dieser Turn keinen `tool_use`-Block enthält, kannst du ihn stattdessen behalten und [die Antwort fortsetzen](https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons#ensuring-complete-responses), indem du eine neue Nutzernachricht sendest. Den abgeschnittenen Assistenten-Turn erneut als letzte Nachricht zu senden, ist ein [Prefill](https://platform.claude.com/docs/de/api/errors#prefill-not-supported), das Claude 4.6 und neuere Modelle ablehnen.
Hänge den Anstoß als eigene Nutzernachricht nach den Tool-Ergebnissen an, statt als Geschwisterblock in derselben Nachricht. Aufeinanderfolgende Nutzernachrichten sind gültig. In Anthropics Tests mit Claude Haiku 4.5- und Sonnet-Executors verhielten sie sich gleichwertig zu einem Geschwisterblock. Die Form als separate Nachricht hält die Erinnerung außerdem klar von der Tool-Ausgabe getrennt.
**Kompromisse:** Der Anstoß erhöht die Aufrufrate, was trivial einfache Aufgaben zu einer unnötigen Konsultation verleiten kann. Wenn dein Workload einfache und komplexe Aufgaben mischt, erwäge, `NUDGE_TURN` auf 3 zu erhöhen, damit Aufgaben mit zwei Turns abgeschlossen sind, bevor der Anstoß ausgelöst wird, oder mache den Anstoß von einem Aufgabenkomplexitätssignal abhängig, das du bereits berechnest. Wenn dein System-Prompt bereits zurückhaltende Formulierungen enthält („reserve the advisor for genuine uncertainty"), verzichte ganz auf den Anstoß, da sich die beiden Anweisungen widersprechen.
Der Klartext-Anstoß ist bei Claude Haiku 4.5- und Sonnet-Executors sehr auffällig: 74 Prozent (Sonnet) bis 98 Prozent (Claude Haiku 4.5) der angestoßenen Versuche riefen in Anthropics Tests den Advisor sofort in Turn 2 auf. Wenn das geschieht, bevor dein Executor das Problem gelesen oder Kontext gesammelt hat, ist der resultierende Advisor-Aufruf kontextarm und kann einen besser getimten späteren Aufruf verdrängen. Miss den Turn des ersten Aufrufs deines Executors als Ausgangswert, bevor du den Anstoß hinzufügst. Wenn der Executor den Advisor bereits zuverlässig aufruft und sein erster Aufruf typischerweise in Turn N erfolgt, setze `NUDGE_TURN` größer als N. In Anthropics Tests korrelierte ein Anstoß in Turn 2 bei Workloads, bei denen der erste Aufruf im Ausgangszustand in Turn 7 oder später erfolgte, mit einem Rückgang der Aufgabenleistung um 3 bis 4 Prozentpunkte. Bei einem Browse-Workload mit einer Ausgangs-Aufrufrate von 86 Prozent erhöhte derselbe Anstoß die Nutzung ohne Einbußen bei der Aufgabenleistung.
Um bei einer bestimmten Anfrage eine Konsultation zu erzwingen, statt einen Anstoß zu geben, setze `tool_choice` auf `{"type": "tool", "name": "advisor"}`, vorbehaltlich der Einschränkungen unter [Tool-Nutzung erzwingen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/define-tools#forcing-tool-use). Erzwungene Tool-Nutzung kann nicht mit manuellem erweitertem Nachdenken (`thinking: {type: "enabled"}`) kombiniert werden: Die API gibt einen `400 invalid_request_error` zurück, wenn du beides aktivierst. Adaptives Nachdenken unterstützt erzwungene Tool-Nutzung. Executors vom Typ Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1 und Claude Mythos 5.1 lehnen die `tool_choice`-Typen `tool` und `any` ab, verwende bei diesen Modellen daher stattdessen den Prompt-Anstoß.
## Streaming
Die Advisor-Sub-Inferenz wird nicht gestreamt. Der Stream des Executors pausiert, während der Advisor läuft. Anschließend kommt das vollständige Ergebnis in einem einzigen Event an.
Der `server_tool_use`-Block mit `name: "advisor"` zeigt an, dass ein Advisor-Aufruf beginnt. Die Pause beginnt, wenn dieser Block geschlossen wird (`content_block_stop`). Während der Pause sendet der Stream nur die standardmäßigen SSE-`ping`-Keepalives, etwa alle 30 Sekunden. Bei kurzen Advisor-Aufrufen erscheinen möglicherweise gar keine Pings.
Wenn der Advisor fertig ist, kommt das `advisor_tool_result` vollständig in einem einzigen `content_block_start`-Event an (ohne Deltas). Danach wird die Ausgabe des Executors weiter gestreamt.
Anschließend folgt ein `message_delta`-Event. Sein aktualisiertes `usage.iterations`-Array enthält die Token-Zahlen des Advisors.
## Nutzung und Abrechnung
Advisor-Aufrufe laufen als separate Sub-Inferenz und werden zu den Preisen des Advisor-Modells abgerechnet. Die Nutzung wird im Array `usage.iterations[]` gemeldet:
```json
{
"usage": {
"input_tokens": 1760,
"cache_read_input_tokens": 412,
"cache_creation_input_tokens": 0,
"output_tokens": 531,
"iterations": [
{
"type": "message",
"input_tokens": 412,
"cache_read_input_tokens": 0,
"cache_creation_input_tokens": 0,
"output_tokens": 89
},
{
"type": "advisor_message",
"model": "claude-opus-5",
"input_tokens": 823,
"cache_read_input_tokens": 0,
"cache_creation_input_tokens": 0,
"output_tokens": 1612
},
{
"type": "message",
"input_tokens": 1348,
"cache_read_input_tokens": 412,
"cache_creation_input_tokens": 0,
"output_tokens": 442
}
]
}
}
```
Die `usage`-Felder auf oberster Ebene enthalten nur Executor-Tokens. Advisor-Tokens fließen nicht in diese Gesamtsummen ein, weil sie zu einem anderen Preis abgerechnet werden. Iterationen mit `type: "advisor_message"` werden zu den Preisen des Advisor-Modells abgerechnet, Iterationen mit `type: "message"` zu den Preisen des Executor-Modells.
Jedes `usage`-Feld auf oberster Ebene ist die Summe dieses Felds über alle Executor-Iterationen. Das gilt auch für `input_tokens`, `output_tokens` und `cache_read_input_tokens`. Jede Executor-Iteration sendet die wachsende Konversation erneut, sodass die Eingaben späterer Iterationen die Ausgaben früherer Iterationen enthalten. Die summierten `input_tokens` sind deshalb größer als jeder einzelne Prompt. Wenn du Logik zur Kostenverfolgung erstellst, verwende `usage.iterations` für eine vollständige Aufschlüsselung pro Iteration.
Die Advisor-Ausgabe umfasst typischerweise 400 bis 700 Text-Tokens bzw. insgesamt 1.400 bis 1.800 Tokens einschließlich Nachdenken. Die Kosteneinsparung entsteht, weil nicht der Advisor deine vollständige finale Ausgabe generiert, sondern der Executor zu seinem niedrigeren Preis.
Das `max_tokens` auf oberster Ebene gilt nur für die Executor-Ausgabe und begrenzt die Tokens der Advisor-Sub-Inferenz nicht. Um die Advisor-Ausgabe direkt zu begrenzen, setze [`max_tokens` in der Tool-Definition](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#capping-advisor-output). Die Tokens des Advisors werden außerdem nicht von einem [Task-Budget](https://platform.claude.com/docs/de/build-with-claude/task-budgets) des Executors abgezogen.
[Priority Tier](https://platform.claude.com/docs/de/api/service-tiers) gilt für jedes Modell separat. Eine Priority-Tier-Zusage für das Executor-Modell gilt nicht für den Advisor. Advisor-Aufrufe laufen nur dann im Priority Tier, wenn deine Organisation auch für das Advisor-Modell eine Zusage hat.
## Advisor-Prompt-Caching
Es gibt zwei unabhängige Caching-Ebenen.
### Caching auf Executor-Seite
Der `advisor_tool_result`-Block lässt sich wie jeder andere Content-Block cachen. Ein `cache_control`-Breakpoint, den du in einem nachfolgenden Turn hinter diesem Block platzierst, erzielt einen Cache-Treffer. Der Prompt des Executors enthält den Ratschlag immer im Klartext, unabhängig davon, ob dein Client `text` oder `encrypted_content` erhalten hat. Das Caching-Verhalten ist daher für beide Ergebnisvarianten identisch.
### Advisor-seitiges Caching
Setze `caching` in der Tool-Definition, um Prompt-Caching für das eigene Transkript des Advisors über Aufrufe innerhalb derselben Konversation hinweg zu aktivieren:
```python Python
tools = [
{
"type": "advisor_20260301",
"name": "advisor",
"model": "claude-opus-5",
"caching": {"type": "ephemeral", "ttl": "5m"},
}
]
```
```typescript TypeScript
const tools: Anthropic.Beta.Messages.BetaToolUnion[] = [
{
type: "advisor_20260301",
name: "advisor",
model: "claude-opus-5",
caching: { type: "ephemeral", ttl: "5m" }
}
];
```
```csharp C#
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
var tools = new BetaToolUnion[]
{
new BetaAdvisorTool20260301
{
Model = Messages::Model.ClaudeOpus5,
Caching = new BetaCacheControlEphemeral { Ttl = Ttl.Ttl5m }
}
};
```
```go Go
tools := []anthropic.BetaToolUnionParam{
{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
Model: anthropic.ModelClaudeOpus5,
Caching: anthropic.BetaCacheControlEphemeralParam{TTL: anthropic.BetaCacheControlEphemeralTTLTTL5m},
}},
}
```
```java Java
import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaCacheControlEphemeral;
import com.anthropic.models.beta.messages.BetaToolUnion;
import com.anthropic.models.messages.Model;
List tools = List.of(
BetaToolUnion.ofAdvisorTool20260301(BetaAdvisorTool20260301.builder()
.model(Model.CLAUDE_OPUS_5)
.caching(BetaCacheControlEphemeral.builder()
.ttl(BetaCacheControlEphemeral.Ttl.TTL_5M)
.build())
.build()));
```
```php PHP
$tools = [
[
'type' => 'advisor_20260301',
'name' => 'advisor',
'model' => 'claude-opus-5',
'caching' => ['type' => 'ephemeral', 'ttl' => '5m'],
],
];
```
```ruby Ruby
tools = [
{
type: "advisor_20260301",
name: "advisor",
model: "claude-opus-5",
caching: { type: "ephemeral", ttl: "5m" }
}
]
```
Der Prompt des Advisors beim N-ten Aufruf ist der Prompt des (N-1)-ten Aufrufs mit einem zusätzlich angehängten Segment, sodass das Präfix über Aufrufe hinweg stabil ist. Mit aktiviertem `caching` schreibt jeder Advisor-Aufruf einen Cache-Eintrag, und der nächste Aufruf liest bis zu diesem Punkt und zahlt nur für das Delta. Du wirst sehen, dass `cache_read_input_tokens` bei der zweiten und späteren `advisor_message`-Iterationen ungleich null wird.
**Wann du es aktivieren solltest:** Das Schreiben in den Cache kostet mehr, als die Lesevorgänge einsparen, wenn der Advisor zweimal oder seltener pro Konversation aufgerufen wird. Caching rechnet sich ab etwa drei Advisor-Aufrufen und wird von da an besser. Aktiviere es für lange Agenten-Schleifen und lass es bei kurzen Aufgaben deaktiviert.
**Bleib konsistent:** Setze `caching` einmal und lass es für die gesamte Konversation bestehen. Wenn du es mitten in der Konversation aus- und wieder einschaltest, führt das zu Cache-Misses.
[`clear_thinking`](https://platform.claude.com/docs/de/build-with-claude/context-editing) mit einem `keep`-Wert außer `"all"` verschiebt das zitierte Transkript des Advisors in jedem Turn, was zu Advisor-seitigen Cache-Misses führt. Dies ist nur eine Kostenverschlechterung. Die Qualität der Ratschläge ist nicht betroffen. Wenn Nachdenken ohne explizite `clear_thinking`-Konfiguration aktiviert ist, verwendet die API standardmäßig `keep: {type: "thinking_turns", value: 1}`, was dieses Verhalten auslöst (der Standard bei früheren Opus- und Sonnet-Modellen und bei Haiku-Modellen bis einschließlich Claude Haiku 4.5; bei Claude Opus 4.5 und neueren Opus-Modellen, Claude Sonnet 4.6 und neueren Sonnet-Modellen sowie Claude Haiku 5.5 werden standardmäßig alle Turns behalten). Setze `keep: "all"`, um die Stabilität des Advisor-Caches zu erhalten.
## Kombination mit anderen Tools
Das Advisor-Tool lässt sich mit anderen serverseitigen und clientseitigen Tools kombinieren. Füge sie alle zum selben `tools`-Array hinzu:
```python Python
tools = [
{
"type": "web_search_20250305",
"name": "web_search",
"max_uses": 5,
},
{
"type": "advisor_20260301",
"name": "advisor",
"model": "claude-opus-5",
},
{
"name": "run_bash",
"description": "Run a bash command",
"input_schema": {
"type": "object",
"properties": {"command": {"type": "string"}},
},
},
]
```
```typescript TypeScript
const tools: Anthropic.Beta.Messages.BetaToolUnion[] = [
{
type: "web_search_20250305",
name: "web_search",
max_uses: 5
},
{
type: "advisor_20260301",
name: "advisor",
model: "claude-opus-5"
},
{
name: "run_bash",
description: "Run a bash command",
input_schema: {
type: "object",
properties: { command: { type: "string" } }
}
}
];
```
```csharp C#
using System.Text.Json;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
var tools = new BetaToolUnion[]
{
new BetaWebSearchTool20250305 { MaxUses = 5 },
new BetaAdvisorTool20260301 { Model = Messages::Model.ClaudeOpus5 },
new BetaTool
{
Name = "run_bash",
Description = "Run a bash command",
InputSchema = new()
{
Properties = new Dictionary
{
["command"] = JsonSerializer.SerializeToElement(new { type = "string" })
}
}
}
};
```
```go Go
tools := []anthropic.BetaToolUnionParam{
{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
MaxUses: anthropic.Int(5),
}},
{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
Model: anthropic.ModelClaudeOpus5,
}},
{OfTool: &anthropic.BetaToolParam{
Name: "run_bash",
Description: anthropic.String("Run a bash command"),
InputSchema: anthropic.BetaToolInputSchemaParam{
Properties: map[string]any{
"command": map[string]any{"type": "string"},
},
},
}},
}
```
```java Java
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaTool;
import com.anthropic.models.beta.messages.BetaToolUnion;
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.messages.Model;
List tools = List.of(
BetaToolUnion.ofWebSearchTool20250305(BetaWebSearchTool20250305.builder()
.maxUses(5L)
.build()),
BetaToolUnion.ofAdvisorTool20260301(BetaAdvisorTool20260301.builder()
.model(Model.CLAUDE_OPUS_5)
.build()),
BetaToolUnion.ofBetaTool(BetaTool.builder()
.name("run_bash")
.description("Run a bash command")
.inputSchema(BetaTool.InputSchema.builder()
.properties(JsonValue.from(Map.of(
"command", Map.of("type", "string"))))
.build())
.build()));
```
```php PHP
$tools = [
[
'type' => 'web_search_20250305',
'name' => 'web_search',
'max_uses' => 5,
],
[
'type' => 'advisor_20260301',
'name' => 'advisor',
'model' => 'claude-opus-5',
],
[
'name' => 'run_bash',
'description' => 'Run a bash command',
'input_schema' => [
'type' => 'object',
'properties' => ['command' => ['type' => 'string']],
],
],
];
```
```ruby Ruby
tools = [
{
type: "web_search_20250305",
name: "web_search",
max_uses: 5
},
{
type: "advisor_20260301",
name: "advisor",
model: "claude-opus-5"
},
{
name: "run_bash",
description: "Run a bash command",
input_schema: {
type: "object",
properties: { command: { type: "string" } }
}
}
]
```
Der Executor kann im selben Turn im Web suchen, den Advisor aufrufen und deine benutzerdefinierten Tools verwenden. Der Plan des Advisors kann beeinflussen, zu welchen Tools der Executor als Nächstes greift.
| Funktion | Zusammenspiel |
| -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Batch-Verarbeitung](https://platform.claude.com/docs/de/build-with-claude/batch-processing) | Unterstützt. `usage.iterations` wird pro Element gemeldet. |
| [Token-Zählung](https://platform.claude.com/docs/de/build-with-claude/token-counting) | Gibt nur die Eingabe-Token der ersten Iteration des Executors zurück. Für eine grobe Schätzung des Advisors rufe `client.beta.messages.count_tokens()` (typescript: `client.beta.messages.countTokens()`; go, csharp: `client.Beta.Messages.CountTokens()`; java: `client.beta().messages().countTokens()`; php: `$client->beta->messages->countTokens()`; cli: `ant beta:messages count-tokens`; curl: `POST /v1/messages/count_tokens`) mit `model` auf das Advisor-Modell gesetzt und denselben Nachrichten auf. |
| [Kontextbearbeitung](https://platform.claude.com/docs/de/build-with-claude/context-editing) | `clear_tool_uses` ist nicht vollständig mit Advisor-Tool-Blöcken kompatibel. Zu `clear_thinking` siehe die vorherige Caching-Warnung. |
| `pause_turn` | Ein offener Advisor-Aufruf beendet die Antwort mit `stop_reason: "pause_turn"` und einem `server_tool_use`-Block ohne Ergebnis, wenn im selben Turn kein Client-`tool_use`-Block auf dein Ergebnis wartet. Der Advisor wird bei der Fortsetzung ausgeführt. Wenn der Executor in diesem Turn auch eines deiner Tools aufgerufen hat, endet die Antwort stattdessen mit `stop_reason: "tool_use"`, und der ausstehende Advisor-Aufruf wird zu Beginn deiner nächsten Anfrage ausgeführt, nachdem du die `tool_result`-Blöcke gesendet hast. Siehe [Einen pausierten Turn fortsetzen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#resuming-a-paused-turn), [Server-Tools und Client-Tools in einem Turn mischen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools#mixing-server-tools-and-client-tools-in-one-turn) und [Server-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools#the-server-side-loop-and-pause-turn). |
## Best Practices
### Prompting für Coding- und Agent-Aufgaben
Das Advisor-Tool bringt eine eingebaute Beschreibung mit. Sie regt den Executor an, den Advisor zu Beginn komplexer Aufgaben und bei Schwierigkeiten aufzurufen. Für Rechercheaufgaben ist typischerweise kein zusätzliches Prompting nötig.
Bei Coding- und Agent-Aufgaben liefert der Advisor höhere Intelligenz bei ähnlichen Kosten, wenn er die Gesamtzahl der Tool-Aufrufe und die Länge der Konversation reduziert. Entscheidend dafür sind zwei Zeitpunkte:
1. Ein früher erster Advisor-Aufruf, sobald einige erkundende Lesevorgänge im Transkript stehen.
2. Bei schwierigen Aufgaben ein abschließender Advisor-Aufruf, sobald Dateischreibvorgänge und Testausgaben im Transkript stehen.
Stellt dein Agent weitere planerähnliche Tools bereit (zum Beispiel ein Todo-Listen-Tool), weise das Modell an, den Advisor vor diesen Tools aufzurufen. So fließt der Plan des Advisors in diese Tools ein. Der [vorgeschlagene System-Prompt](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#suggested-system-prompt-for-coding-tasks) fördert den frühen Aufruf. Ergänze ihn um einen eigenen Satz, der auf die Planer-Tools deines Agents verweist.
#### Vorgeschlagener System-Prompt für Coding-Aufgaben
Ohne Steuerung über den System-Prompt ruft der Executor den Advisor in manchen Domänen zu selten auf, insbesondere bei Coding-Aufgaben. Für Coding-Aufgaben mit konsistentem Timing und etwa zwei bis drei Advisor-Aufrufen pro Aufgabe stellst du die folgenden Blöcke an den Anfang deines Executor-System-Prompts. Sie müssen vor allen anderen Sätzen stehen, die den Advisor erwähnen.
Hinweise zum Timing:
```text wrap
You have access to an `advisor` tool backed by a stronger reviewer model. It takes NO parameters — when you call advisor(), your entire conversation history is automatically forwarded. They see the task, every tool call you've made, every result you've seen.
Call advisor BEFORE substantive work — before writing, before committing to an interpretation, before building on an assumption. If the task requires orientation first (finding files, fetching a source, seeing what's there), do that, then call advisor. Orientation is not substantive work. Writing, editing, and declaring an answer are.
Also call advisor:
- When you believe the task is complete. BEFORE this call, make your deliverable durable: write the file, save the result, commit the change. The advisor call takes time; if the session ends during it, a durable result persists and an unwritten one doesn't.
- When stuck — errors recurring, approach not converging, results that don't fit.
- When considering a change of approach.
On tasks longer than a few steps, call advisor at least once before committing to an approach and once before declaring done. On short reactive tasks where the next action is dictated by tool output you just read, you don't need to keep calling — the advisor adds most of its value on the first call, before the approach crystallizes.
```
Wie der Executor den Ratschlag behandeln soll (direkt nach dem Timing-Block platzieren):
```text wrap
Give the advice serious weight. If you follow a step and it fails empirically, or you have primary-source evidence that contradicts a specific claim (the file says X, the paper states Y), adapt. A passing self-test is not evidence the advice is wrong — it's evidence your test doesn't check what the advice is checking.
If you've already retrieved data pointing one way and the advisor points another: don't silently switch. Surface the conflict in one more advisor call — "I found X, you suggest Y, which constraint breaks the tie?" The advisor saw your evidence but may have underweighted it; a reconcile call is cheaper than committing to the wrong branch.
```
#### Alternativer System-Prompt für Haiku bei Coding-Workloads
Claude Haiku 4.5 setzt die Standard-Advisor-Anleitung zurückhaltend um. Bei Recherche- und Nachschlage-Workloads bleibt die Aufrufrate dadurch angemessen niedrig. Bei Coding-Workloads kostet das jedoch Qualität, denn dort zahlt sich eine frühe Advisor-Konsultation zuverlässig aus. In einem internen Coding-Benchmark erhöhte eine eng verwandte Variante des folgenden Blocks die Erfolgsquoten von Haiku um etwa 7,5 Prozentpunkte gegenüber dem eingebauten Standard. Die Ausnahme für reine Lesevorgänge in der Hard rule wurde erst nach dieser Messung hinzugefügt.
Verwende diesen Block anstelle der beiden vorherigen Blöcke (Timing und Umgang mit dem Ratschlag), wenn dein Haiku-Executor überwiegend Coding- oder Schreibaufgaben bearbeitet:
```text wrap
Consult a stronger reviewer who sees your full conversation transcript.
No parameters. When you call advisor(), your entire history -- task, every tool call and result, your reasoning -- is automatically forwarded. The advisor sees exactly what you've done.
Call advisor BEFORE substantive work -- before writing, before committing to an interpretation, before building on an assumption. If the task requires orientation first (finding files, fetching a source, seeing what's there), do that, then call advisor. Orientation is not substantive work. Writing, editing, and declaring an answer are.
Also call advisor:
- When you believe the task is complete. BEFORE this call, make your deliverable durable: write the file, save the result, commit the change. The advisor call takes time; if the session ends during it, a durable result persists and an unwritten one doesn't.
- When stuck -- errors recurring, approach not converging, results that don't fit.
- When considering a change of approach.
On tasks longer than a few steps, call advisor at least once before committing to an approach and once before declaring done. On short reactive tasks where the next action is dictated by tool output you just read, you don't need to keep calling -- the advisor adds most of its value on the first call, before the approach crystallizes.
Give the advice serious weight. If you follow a step and it fails empirically, or you have primary-source evidence that contradicts a specific claim (the file says X, the paper states Y), adapt. A passing self-test is not evidence the advice is wrong -- it's evidence your test doesn't check what the advice is checking.
If you've already retrieved data pointing one way and the advisor points another: don't silently switch. Surface the conflict in one more advisor call -- "I found X, you suggest Y, which constraint breaks the tie?" The advisor saw your evidence but may have underweighted it; a reconcile call is cheaper than committing to the wrong branch.
Call advisor for design, architecture, and risk questions where you won't touch a file. If your response would be analysis or a recommendation with no other tool calls, call advisor first -- that judgment call is exactly where a second opinion is highest-value.
Hard rule: your first write_file, edit_file, or state-changing bash call on a task must be preceded by an advisor call in the same or an earlier turn. Read-only orientation commands (ls, cat, grep, find) are not state-changing. This is a checkpoint, not a difficulty judgment. It applies to one-line edits too.
```
**Einschränkung:** In einem internen Browse-Comprehension-Benchmark (n = 1.266) senkte eine eng verwandte Variante dieses Blocks die Genauigkeit um etwa 4 Prozentpunkte gegenüber dem eingebauten Standard. Wenn dein Workload Coding mit umfangreichen Nachschlage- oder Retrieval-Aufgaben mischt, bleib bei den [vorgeschlagenen Blöcken](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#suggested-system-prompt-for-coding-tasks). Alternativ kannst du den Austausch von einem Signal zum Workload-Typ abhängig machen, das du bereits berechnest.
#### Advisor-Aufrufe bei Opus-Executors erhöhen
Opus-Executors rufen den Advisor typischerweise auch ohne zusätzliches Prompting angemessen oft auf. Wenn dein Opus-Executor den Advisor bei deinem Workload zu selten aufruft, füge deinem System-Prompt den folgenden Checkpoint hinzu:
```text wrap
Call advisor for design, architecture, and risk questions where you won't touch a file. If your response would be analysis or a recommendation with no other tool calls, call advisor first. That judgment call is exactly where a second opinion is highest-value. (This does not apply to simple factual lookups or arithmetic; those you answer directly.)
Hard rule: your first write_file, edit_file, or state-changing bash call on a task must be preceded by an advisor call in the same or an earlier turn. Read-only orientation commands (ls, cat, grep, find) are not state-changing. This is a checkpoint, not a difficulty judgment. It applies to one-line edits too.
```
**Einschränkung:** In Anthropics Tests erhöhte eine eng verwandte Variante dieses Blocks die Erfolgsquoten bei Aufgaben mit zu seltenen Aufrufen um etwa 7 bis 10 Prozentpunkte. Die Ausnahme für reine Lesevorgänge in der Hard rule wurde erst nach dieser Messung hinzugefügt. Gleichzeitig rief Opus den Advisor zu häufig auf, wenn die erste Aktion einer Aufgabe keine Planung erforderte. Bei einem gemischten Workload war der Nettoeffekt ungefähr neutral. Füge den Block nur hinzu, wenn du beobachtet hast, dass Opus den Advisor bei Aufgaben überspringt, bei denen eine Konsultation geholfen hätte. Verwende ihn nicht als Standard.
#### Länge der Advisor-Ausgabe kürzen
Die Ausgabe ist der größte Kostentreiber des Advisors, und das `max_tokens` auf oberster Ebene begrenzt sie nicht. Der Advisor sieht deinen System-Prompt und deine Benutzernachrichten als zitierten Kontext zur Aufgabe des Executors. Anweisungen, die den Advisor direkt ansprechen, befolgt er deshalb deutlich zuverlässiger als Beschreibungen in der dritten Person. Am wirksamsten war in Anthropics Tests eine Zeile in der Benutzernachricht:
```text wrap
(Advisor: please keep your guidance under 80 words — I need a focused starting point, not a comprehensive plan.)
```
Dein Agent-Framework kann diese Zeile vor dem Senden der Anfrage programmatisch voranstellen. Das Limit ist nur eine weiche Vorgabe, die der Advisor gelegentlich überschreitet. Fordere deshalb etwa 80 Prozent deiner tatsächlichen Obergrenze an.
In Anthropics Tests führte diese Zeile auch dazu, dass der Executor den Advisor häufiger konsultierte. Die Gesamtkosten sanken trotzdem (mehr Konsultationen, aber jede kürzer).
Den besten Kompromiss zwischen Kosten und Qualität erzielst du, wenn du diesen Ansatz mit den Timing-Hinweisen unter [Vorgeschlagener System-Prompt für Coding-Aufgaben](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#suggested-system-prompt-for-coding-tasks) kombinierst. Falls du stattdessen den [alternativen Haiku-Block](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#alternative-system-prompt-for-haiku-on-coding-workloads) verwendest, kombiniere ihn mit diesem. Eine harte Obergrenze statt einer weichen Vorgabe beschreibt [Advisor-Ausgabe begrenzen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#capping-advisor-output).
### Advisor-Ausgabe begrenzen
Setze `max_tokens` in der Tool-Definition, um die gesamte Ausgabe des Advisors (Nachdenken plus Text) pro Aufruf zu begrenzen:
```python Python
tools = [
{
"type": "advisor_20260301",
"name": "advisor",
"model": "claude-opus-5",
"max_tokens": 2048,
}
]
```
```typescript TypeScript
const tools: Anthropic.Beta.Messages.BetaToolUnion[] = [
{
type: "advisor_20260301",
name: "advisor",
model: "claude-opus-5",
max_tokens: 2048
}
];
```
```csharp C#
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;
var tools = new BetaToolUnion[]
{
new BetaAdvisorTool20260301
{
Model = Messages::Model.ClaudeOpus5,
MaxTokens = 2048
}
};
```
```go Go
tools := []anthropic.BetaToolUnionParam{
{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
Model: anthropic.ModelClaudeOpus5,
MaxTokens: anthropic.Int(2048),
}},
}
```
```java Java
import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaToolUnion;
import com.anthropic.models.messages.Model;
List tools = List.of(
BetaToolUnion.ofAdvisorTool20260301(BetaAdvisorTool20260301.builder()
.model(Model.CLAUDE_OPUS_5)
.maxTokens(2048L)
.build()));
```
```php PHP
$tools = [
[
'type' => 'advisor_20260301',
'name' => 'advisor',
'model' => 'claude-opus-5',
'max_tokens' => 2048,
],
];
```
```ruby Ruby
tools = [
{
type: "advisor_20260301",
name: "advisor",
model: "claude-opus-5",
max_tokens: 2048
}
]
```
Der Mindestwert ist 1024. Liegt `max_tokens` über der Ausgabeobergrenze des Advisor-Modells, gibt die API einen 400-Fehler zurück. Die Obergrenze gilt für jeden Advisor-Aufruf einzeln und wird nicht zwischen den Aufrufen einer Anfrage geteilt.
Die Ausgabe wird dabei nicht einfach hart abgeschnitten. Der Server teilt dem Advisor auch sein verbleibendes Token-Budget mit, sodass der Advisor seine Antwort daran anpasst.
**Empfohlener Ausgangspunkt:** `max_tokens: 2048`. Anthropic hat diesen Wert mit einem anspruchsvollen Reasoning-Benchmark getestet (n = 40 pro Konfiguration). Im Vergleich zu einer nicht gesetzten Obergrenze sank die durchschnittliche Advisor-Ausgabe auf etwa ein Siebtel. Dabei wurden fast keine Aufrufe gekürzt, und es gab keine erkennbaren Qualitätseinbußen. Mit dem Mindestwert 1024 sank die Ausgabe auf etwa ein Zehntel, allerdings wurden rund 10 Prozent der Aufrufe gekürzt. Die Genauigkeitsunterschiede zwischen den Konfigurationen lagen bei dieser Stichprobengröße im Rauschen. Validiere die Werte mit deinem eigenen Workload.
| `max_tokens` | Durchschnittliche Advisor-Ausgabe-Tokens | Gekürzte Aufrufe |
| ------------- | ---------------------------------------- | ---------------- |
| nicht gesetzt | \~4.200 bis 5.900 | n. z. |
| 2048 | \~630 bis 840 | \~0 % |
| 1024 | \~370 bis 480 | \~10 % |
Bei anspruchsvollen Reasoning-Aufgaben fällt die Advisor-Ausgabe deutlich länger aus als die [typischen 1.400 bis 1.800 Tokens](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#usage-and-billing), die weiter oben für leichtere Workloads genannt sind. Nutze die Tabelle, um das Einsparungsverhältnis abzuschätzen, nicht als allgemeingültigen Richtwert für die Länge der Advisor-Ausgabe.
Erreicht der Advisor die Obergrenze, enthält der Ergebnisblock `stop_reason: "max_tokens"`. Das gilt für beide [Ergebnisvarianten](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#result-variants) und unabhängig vom Advisor-Modell. Anhand von `stop_reason` erkennst du gekürzte Ratschläge. Du kannst dann entscheiden, ob du die Obergrenze erhöhst oder den Executor mit der unvollständigen Anleitung weiterarbeiten lässt.
Die API hängt außerdem `[Advisor output truncated at max_tokens=2048.]` an den Ratschlagstext an, wobei der Wert deiner Obergrenze entspricht. So sieht der Executor die Kürzung in seinem eigenen Kontext. Bei einem Advisor, der das Klartext-`advisor_result` zurückgibt, sieht auch dein Client diese Markierung. Beide Signale erscheinen nur, wenn du `max_tokens` in der Tool-Definition setzt.
```json
{
"type": "advisor_tool_result",
"tool_use_id": "srvtoolu_abc123",
"content": {
"type": "advisor_redacted_result",
"encrypted_content": "EqQBCkYIBRgCIiQ3YTAwMjY1Mi1mZjM5LTQ1NGUtODgxNC1kNjNjNTk1ZWI3Y...",
"stop_reason": "max_tokens"
}
}
```
Wie nah ein Aufruf an seine Obergrenze herankam, siehst du an `output_tokens` im zugehörigen `advisor_message`-Eintrag in `usage.iterations`.
Anders als der [Prompt-basierte Ansatz](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#trimming-advisor-output-length) ist `max_tokens` eine harte Obergrenze statt einer weichen Vorgabe. Verwende `max_tokens`, wenn du eine garantierte Grenze für Kosten oder „latency" (Latenz) brauchst. Verwende den Prompt-basierten Ansatz (oder beide zusammen), wenn du kürzere Antworten erreichen möchtest, ohne zu riskieren, dass der Advisor mitten im Gedanken abgeschnitten wird.
### Kombination mit Effort-Einstellungen
Für Coding-Aufgaben erreicht die Kombination eines Sonnet-Modells als „executor" (ausführendes Modell) mit mittlerem [„effort"](https://platform.claude.com/docs/de/build-with-claude/effort) (Aufwand) und eines Opus-Modells als „advisor" (beratendes Modell) eine Intelligenz, die mit Sonnet bei Standard-Effort vergleichbar ist, und das zu geringeren Kosten. Für maximale Intelligenz belässt du den Executor beim Standard-Effort.
### Kostenkontrolle
* Für Budgets auf Konversationsebene zählst du die Advisor-Aufrufe clientseitig. Wenn du dein Limit erreichst, entferne das Advisor-Tool aus `tools`. Du musst keine `advisor_tool_result`-Blöcke aus deinem Nachrichtenverlauf entfernen (siehe den Hinweis unter [Multi-Turn-Konversationen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/advisor-tool#multi-turn-conversations)).
* Aktiviere `caching` nur für Konversationen, in denen du drei oder mehr Advisor-Aufrufe erwartest.
## Modellkompatibilität
Das Executor-Modell (das `model`-Feld auf oberster Ebene) und das Advisor-Modell (das `model`-Feld innerhalb der Tool-Definition) müssen ein gültiges Paar bilden. Der Advisor muss Claude Sonnet 4.6 oder ein leistungsfähigeres Modell sein, und er muss mindestens so leistungsfähig sein wie der Executor. Modelle mit gleicher Leistungsfähigkeit (zum Beispiel Claude Opus 4.7 und Claude Opus 4.8) können sich gegenseitig beraten.
| Executor-Modelle | Advisor-Modelle |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Claude Haiku 4.5 (claude-haiku-4-5) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5)
Claude Opus 4.8 (claude-opus-4-8)
Claude Opus 4.7 (claude-opus-4-7)
Claude Opus 4.6 (claude-opus-4-6)
Claude Sonnet 5.5 (claude-sonnet-5-5)
Claude Sonnet 5 (claude-sonnet-5)
Claude Sonnet 4.6 (claude-sonnet-4-6)
Claude Haiku 5.5 (claude-haiku-5-5) |
| Claude Haiku 5.5 (claude-haiku-5-5) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5)
Claude Opus 4.8 (claude-opus-4-8)
Claude Opus 4.7 (claude-opus-4-7)
Claude Sonnet 5.5 (claude-sonnet-5-5)
Claude Sonnet 5 (claude-sonnet-5)
Claude Haiku 5.5 (claude-haiku-5-5) |
| Claude Sonnet 4.6 (claude-sonnet-4-6) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5)
Claude Opus 4.8 (claude-opus-4-8)
Claude Opus 4.7 (claude-opus-4-7)
Claude Opus 4.6 (claude-opus-4-6)
Claude Sonnet 5.5 (claude-sonnet-5-5)
Claude Sonnet 5 (claude-sonnet-5)
Claude Sonnet 4.6 (claude-sonnet-4-6)
Claude Haiku 5.5 (claude-haiku-5-5) |
| Claude Sonnet 5 (claude-sonnet-5) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5)
Claude Opus 4.8 (claude-opus-4-8)
Claude Opus 4.7 (claude-opus-4-7)
Claude Sonnet 5.5 (claude-sonnet-5-5)
Claude Sonnet 5 (claude-sonnet-5)
Claude Haiku 5.5 (claude-haiku-5-5) |
| Claude Sonnet 5.5 (claude-sonnet-5-5) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5)
Claude Sonnet 5.5 (claude-sonnet-5-5) |
| Claude Opus 4.6 (claude-opus-4-6) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5)
Claude Opus 4.8 (claude-opus-4-8)
Claude Opus 4.7 (claude-opus-4-7)
Claude Opus 4.6 (claude-opus-4-6)
Claude Sonnet 5.5 (claude-sonnet-5-5)
Claude Sonnet 5 (claude-sonnet-5)
Claude Haiku 5.5 (claude-haiku-5-5) |
| Claude Opus 4.7 (claude-opus-4-7) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5)
Claude Opus 4.8 (claude-opus-4-8)
Claude Opus 4.7 (claude-opus-4-7)
Claude Sonnet 5.5 (claude-sonnet-5-5) |
| Claude Opus 4.8 (claude-opus-4-8) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5)
Claude Opus 4.8 (claude-opus-4-8)
Claude Opus 4.7 (claude-opus-4-7)
Claude Sonnet 5.5 (claude-sonnet-5-5) |
| Claude Opus 5 (claude-opus-5) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5) |
| Claude Opus 5.5 (claude-opus-5-5) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5) |
| Claude Fable 5 (claude-fable-5) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5) |
| Claude Mythos 5 (claude-mythos-5) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1)
Claude Mythos 5 (claude-mythos-5)
Claude Fable 5 (claude-fable-5)
Claude Opus 5.5 (claude-opus-5-5)
Claude Opus 5 (claude-opus-5) |
| Claude Fable 5.1 (claude-fable-5-1) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1) |
| Claude Mythos 5.1 (claude-mythos-5-1) | Claude Mythos 5.1 (claude-mythos-5-1)
Claude Fable 5.1 (claude-fable-5-1) |
Wenn du ein ungültiges Paar anforderst, gibt die API einen `400 invalid_request_error` zurück, der die nicht unterstützte Kombination benennt.
### Plattformverfügbarkeit
Das Advisor-Tool ist als Beta auf der Claude API und auf [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) verfügbar. Auf Amazon Bedrock, Google Cloud und Microsoft Foundry ist es derzeit nicht verfügbar.
## Advisor in Claude Managed Agents
Sessions in [Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview) unterstützen ebenfalls einen Advisor, der als Teil des Agenten statt als Tool-Definition konfiguriert wird: Setze `"advisor": {"type": "enabled", "model": ...}` im `multiagent`-Block des Agenten, und der primäre Thread der Session kann dieses Modell mitten im Turn konsultieren. Die Einstellung akzeptiert keine der Optionen `max_uses`, `max_tokens` oder `caching`, und Ratschläge werden als Thread-Events im Event-Stream der Session statt als `advisor_tool_result`-Blöcke in der Antwort geliefert. Siehe [Der Session einen Advisor geben](https://platform.claude.com/docs/de/managed-agents/multiagent-orchestration#give-the-session-an-advisor).
## Nächste Schritte
Speichere und rufe Informationen über Konversationen hinweg mit einem clientseitigen Memory-Verzeichnis ab.
Arbeite mit von Anthropic ausgeführten Tools: server\_tool\_use-Blöcke, pause\_turn-Fortsetzung und Domain-Filterung.
Verzeichnis der von Anthropic bereitgestellten Tools und Referenz für optionale Eigenschaften von Tool-Definitionen.
Steuere mit dem Effort-Parameter, wie viele Token Claude beim Antworten verwendet, und wäge dabei zwischen Gründlichkeit der Antwort und Token-Effizienz ab.