---
title: Инструмент-советник
url: https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool
description: Объедините более быструю модель-исполнитель с более интеллектуальной моделью-советником, которая дает стратегические рекомендации в процессе генерации.
---
Инструмент советника позволяет более быстрой и дешевой **«executor model» (модели-исполнителю)** в процессе генерации обращаться за стратегическими рекомендациями к более интеллектуальной **«advisor model» (модели-советнику)**. Советник читает весь диалог, составляет план или корректирует курс, а исполнитель продолжает выполнение задачи.
Этот подход подходит для долгосрочных агентных рабочих нагрузок (агенты для программирования, использование компьютера, многоэтапные исследовательские конвейеры), где большинство ходов механические, но наличие отличного плана имеет решающее значение. Вы получаете качество, близкое к самостоятельной работе советника, при этом основная часть генерации токенов происходит по тарифам модели-исполнителя. Измеренные результаты, включая то, как выгода уменьшается по мере приближения собственных возможностей исполнителя к возможностям советника, см. в разделе [Оптимизация стоимости и интеллекта](https://platform.claude.com/docs/ru/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
```
Чтобы узнать, как «zero data retention» (нулевое хранение данных), или ZDR, применяется к этой функции, см. раздел [API и хранение данных](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention).
## Когда использовать
Советник подходит для следующих конфигураций:
* **Вы сейчас используете Sonnet для сложных задач:** добавьте советника более высокого уровня. С Opus общая стоимость останется примерно такой же или снизится; Claude Fable 5.1 дает максимальный прирост качества.
* **Вы сейчас используете Haiku и хотите повысить уровень интеллекта:** добавьте советника Opus или Fable. Стоимость будет выше, чем у одного Haiku, но ниже, чем при переходе исполнителя на более крупную модель.
Результаты зависят от задачи. Проводите оценку на собственной рабочей нагрузке.
Советник хуже подходит для однократных вопросов и ответов (планировать нечего) и для простых селекторов моделей, где пользователи сами выбирают баланс между стоимостью и качеством. Он также плохо подходит для нагрузок, где каждый ход действительно требует всех возможностей модели-советника.
## Быстрый старт
Инструмент советника находится в бета-версии. Включайте бета-заголовок `advisor-tool-2026-03-01` в свои запросы.
```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
```
Поле `content` ответа содержит блок `advisor_tool_result` с рекомендациями советника. Если советником выступает `claude-opus-5`, как в этом быстром старте, поле `content` блока содержит вариант `advisor_redacted_result`. Он зашифрован: исполнитель читает его на стороне сервера, а ваш клиент — нет. Чтобы видеть текст рекомендаций прямо в ответе, используйте в качестве модели-советника `claude-opus-4-8`: она возвращает вариант `advisor_result` в открытом виде. Обе структуры и то, какие модели-советники какой вариант возвращают, описаны в разделе [Варианты результата](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#result-variants). Полный список допустимых пар приведен в разделе [Совместимость моделей](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#model-compatibility).
## Как это работает
Когда вы добавляете инструмент советника в массив `tools`, модель-исполнитель сама решает, когда его вызвать, как и любой другой инструмент. Когда исполнитель вызывает советника:
1. Исполнитель выдает блок [`server_tool_use`](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/server-tools) с `name: "advisor"` и пустым `input`. Исполнитель определяет момент вызова, а контекст предоставляет сервер.
2. Anthropic выполняет на сервере отдельный проход вывода на модели-советнике. Советник работает со своей собственной «system prompt» (системной подсказкой), предоставленной Anthropic. На вход он получает полную стенограмму исполнителя в виде цитируемого контекста. Эта стенограмма включает вашу системную подсказку, определения инструментов, предыдущие ходы и результаты инструментов, а также текст, который исполнитель уже сгенерировал в текущем ходе.
3. Ответ советника возвращается исполнителю в виде блока `advisor_tool_result`.
4. Исполнитель продолжает генерацию с учетом рекомендаций.
Все это происходит внутри одного запроса `/v1/messages`, без дополнительных обращений с вашей стороны. Исключение — ход, приостановленный посреди вызова: его нужно возобновить последующим запросом (см. [Возобновление приостановленного хода](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#resuming-a-paused-turn)).
Сам советник работает без инструментов и без управления контекстом. Его блоки размышлений отбрасываются до возврата результата. До исполнителя доходит только текст рекомендаций.
## Параметры инструмента
| Параметр | Тип | По умолчанию | Описание |
| ------------ | -------------- | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | string | *обязательный* | Должен быть `"advisor_20260301"`. |
| `name` | string | *обязательный* | Должен быть `"advisor"`. |
| `model` | string | *обязательный* | Идентификатор модели-советника, например claude-opus-5. Подвывод оплачивается по тарифам этой модели. |
| `max_uses` | integer | без ограничений | Максимальное число вызовов советника в одном запросе. Когда исполнитель достигает этого лимита, последующие вызовы советника возвращают `advisor_tool_result_error` с `error_code: "max_uses_exceeded"`, и исполнитель продолжает работу без новых рекомендаций. Это лимит на запрос, а не на диалог. Ограничения на уровне диалога описаны в разделе [Контроль затрат](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#cost-control). |
| `max_tokens` | integer | лимит вывода модели-советника | Ограничивает общий вывод советника (размышления плюс текст) за один вызов. Минимум 1024. См. [Ограничение вывода советника](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#capping-advisor-output). |
| `caching` | object \| null | `null` (выкл.) | Включает [«prompt caching» (кэширование подсказок)](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching) для собственной стенограммы советника между вызовами в рамках одного диалога. См. [Кэширование подсказок советника](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#advisor-prompt-caching). |
Объект `caching` имеет вид `{"type": "ephemeral", "ttl": "5m" | "1h"}`. В отличие от `cache_control` в блоках контента, это не маркер точки останова, а переключатель «вкл./выкл.». Границы кэша определяет сервер.
Инструмент советника также принимает общие свойства, доступные в любом определении инструмента: `cache_control`, `allowed_callers`, `defer_loading` и `strict` (описано в разделе [структурированные выводы](https://platform.claude.com/docs/ru/build-with-claude/structured-outputs)). Их семантика описана в [справочнике по инструментам](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/tool-reference#tool-definition-properties).
## Структура ответа
### Успешный вызов советника
При вызове советника в контенте ассистента за блоком `server_tool_use` следует блок `advisor_tool_result`. В примере ниже показан вариант `advisor_result` в открытом виде, который возвращает советник Claude Opus 4.8. В [быстром старте](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#quick-start) используется Claude Opus 5, который вместо этого возвращает зашифрованный вариант `advisor_redacted_result`. Обе структуры приведены в разделе [Варианты результата](https://platform.claude.com/docs/ru/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` всегда пустое. Сервер автоматически формирует представление для советника из полной стенограммы. Ничто из того, что исполнитель помещает в `input`, до советника не доходит.
### Варианты результата
Поле `advisor_tool_result.content` представляет собой размеченное объединение. Для успешных вызовов вариант зависит от модели-советника:
| Вариант | Поля | Когда возвращается |
| ------------------------- | ---------------------------------- | ---------------------------------------------------------------------- |
| `advisor_result` | `text`, `stop_reason` | Модель-советник возвращает открытый текст (например, Claude Opus 4.8). |
| `advisor_redacted_result` | `encrypted_content`, `stop_reason` | Модель-советник возвращает зашифрованный вывод. |
Советники 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 и Claude Haiku 5.5 возвращают зашифрованный `advisor_redacted_result`. Все остальные модели-советники из [таблицы совместимости](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#model-compatibility) возвращают `advisor_result` в виде открытого текста. Чтобы читать текст рекомендаций в своих ответах, используйте советника, возвращающего открытый текст, например `claude-opus-4-8`, если строка вашего исполнителя в [таблице совместимости](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#model-compatibility) его содержит. Исполнители 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 сочетаются только с советниками, возвращающими зашифрованную форму, поэтому для этих исполнителей текст рекомендаций в ответе прочитать нельзя.
Ниже приведен один и тот же запрос, отправленный дважды и отличающийся только `model` советника в определении инструмента, — он демонстрирует оба варианта.
С `"model": "claude-opus-4-8"` рекомендации представлены открытым текстом:
```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..."
}
}
```
С `"model": "claude-opus-5"` рекомендации зашифрованы:
```json
{
"type": "advisor_tool_result",
"tool_use_id": "srvtoolu_abc123",
"content": {
"type": "advisor_redacted_result",
"encrypted_content": "EqQBCkYIBRgCIiQ5ZjE0N2M2OC0yYWIxLTRkZTktYjA3ZC1hZTUyMzkxYjhkMmU..."
}
}
```
Оба варианта результата содержат поле `stop_reason`, если вы задаете [`max_tokens`](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#capping-advisor-output) в определении инструмента, и не содержат его, если не задаете. В нем хранится причина остановки подвызова советника — обычно `"end_turn"` или `"max_tokens"` при достижении лимита. Значения совпадают с [`stop_reason`](https://platform.claude.com/docs/ru/build-with-claude/handling-stop-reasons) верхнего уровня в Messages API.
В `advisor_result` поле `text` содержит рекомендации в удобочитаемом виде. В `advisor_redacted_result` поле `encrypted_content` содержит непрозрачный блок данных, который вы не можете прочитать. На следующем ходе сервер расшифровывает его и подставляет открытый текст в подсказку исполнителя.
В обоих случаях передавайте контент обратно без изменений на последующих ходах. Если вы меняете модель-советника посреди диалога, используйте ветвление по `content.type`, чтобы обрабатывать обе структуры.
### Результаты с ошибками
Если вызов советника завершается неудачей, результат содержит ошибку:
```json
{
"type": "advisor_tool_result",
"tool_use_id": "srvtoolu_abc123",
"content": {
"type": "advisor_tool_result_error",
"error_code": "overloaded"
}
}
```
Исполнитель видит ошибку и продолжает работу без новых рекомендаций. Сам запрос при этом не завершается ошибкой.
| `error_code` | Значение |
| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| `max_uses_exceeded` | Запрос достиг лимита `max_uses`, заданного в определении инструмента. Последующие вызовы советника в том же запросе возвращают эту ошибку. |
| `too_many_requests` | Подвывод советника был ограничен по скорости. |
| `overloaded` | Подвывод советника упёрся в ограничения мощности. |
| `prompt_too_long` | Стенограмма превысила «context window» (контекстное окно) модели-советника. |
| `execution_time_exceeded` | Истекло время ожидания подвывода советника. |
| `model_not_found` | Настроенная модель-советник недоступна. |
| `unavailable` | Любой другой сбой советника. |
Вызовы советника расходуют «rate limit» (ограничение скорости) из того же пула для каждой модели, что и прямые вызовы модели-советника. Срабатывание ограничения скорости на советнике отображается как `too_many_requests` внутри результата инструмента. Срабатывание ограничения скорости на исполнителе приводит к сбою всего запроса с HTTP 429.
## Многоходовые диалоги
В последующих ходах передавайте в API весь контент ассистента, включая блоки `advisor_tool_result`. Передавайте блоки результатов без изменений. С советником Claude Opus 5 поле `content` блока результата содержит зашифрованный вариант `advisor_redacted_result`: на следующем ходе сервер расшифровывает его и подставляет рекомендации в подсказку исполнителя (см. [Варианты результата](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#result-variants)). Механика одинакова для любой модели-советника.
```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,
)
# Добавьте полное содержимое ответа, включая все блоки advisor_tool_result
messages.append({"role": "assistant", "content": response.content})
# Продолжите диалог
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
});
// Добавьте полное содержимое ответа, включая все блоки advisor_tool_result
messages.push({ role: "assistant", content: response.content });
// Продолжите диалог
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"]
});
// Добавьте полное содержимое ответа, включая все блоки advisor_tool_result
messages.Add(new BetaMessageParam
{
Role = Role.Assistant,
Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});
// Продолжите диалог
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)
}
// Добавьте полное содержимое ответа, включая все блоки advisor_tool_result.
messages = append(messages, response.ToParam())
// Продолжите диалог
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());
// Добавьте полное содержимое ответа, включая все блоки advisor_tool_result
messages.add(BetaMessageParam.builder()
.role(BetaMessageParam.Role.ASSISTANT)
.contentOfBetaContentBlockParams(
response.content().stream().map(BetaContentBlock::toParam).toList())
.build());
// Продолжите диалог
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'],
);
// Добавьте полное содержимое ответа, включая все блоки advisor_tool_result
$messages[] = ['role' => 'assistant', 'content' => $response->content];
// Продолжите диалог
$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"]
)
# Добавьте полное содержимое ответа, включая все блоки advisor_tool_result
messages << { role: "assistant", content: response.content }
# Продолжите диалог
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"]
)
```
В последующем ходе можно убрать инструмент советника из `tools`, даже если история сообщений все еще содержит блоки `advisor_tool_result`. Запрос будет принят, а исторические блоки сохранятся, но в этом ходе модель не сможет вызвать советника. Бета-заголовок `advisor-tool-2026-03-01` по-прежнему нужно отправлять, иначе эти блоки истории не будут приняты.
У инструмента советника нет встроенного лимита на уровне диалога. Чтобы ограничить число вызовов советника в рамках диалога, считайте их на стороне клиента. Когда вы достигнете своего предела, удалите инструмент советника из массива `tools`. Удалять блоки `advisor_tool_result` из истории сообщений не нужно.
### Возобновление приостановленного хода
Ответ может завершиться с `stop_reason: "pause_turn"`, пока вызов советника еще не выполнен. В этом случае ответ содержит блок `server_tool_use` советника без соответствующего `advisor_tool_result`.
Чтобы возобновить ход:
1. Добавьте это сообщение ассистента в `messages` без изменений, сохранив блок `server_tool_use`.
2. Отправьте запрос повторно с тем же инструментом советника и бета-заголовком.
Добавлять сообщение пользователя или блок `tool_result` не нужно. API выполнит ожидающий вызов советника и продолжит ход исполнителя в новом ответе. Возобновленный ход может снова приостановиться — в этом случае повторите те же действия.
Если не указать инструмент советника в запросе на возобновление, вернется ошибка 400 `invalid_request_error`: для ожидающего блока `server_tool_use` не будет определения инструмента. Поэтому включайте инструмент всякий раз, когда есть ожидающий вызов.
Если же исполнитель в том же ходе вызвал один из ваших инструментов, ответ завершится с `stop_reason: "tool_use"`, а вызов советника останется ожидающим. Отправьте блоки `tool_result` как обычно — ожидающий вызов советника выполнится в начале следующего запроса. См. [Сочетание серверных и клиентских инструментов в одном ходе](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/server-tools#mixing-server-tools-and-client-tools-in-one-turn).
### Напоминание посреди диалога для исполнителей, редко вызывающих советника
Если исполнитель Haiku не вызвал советника в своём первом ходе ассистента, добавьте короткое напоминание в виде дополнительного сообщения пользователя перед вторым ходом ассистента. Во внутренней поведенческой оценке Anthropic на исполнителях Claude Haiku 4.5 это повысило долю успешно выполненных задач примерно на 7 процентных пунктов. На исполнителях Sonnet текстовое напоминание не дало измеримого эффекта в тестах Anthropic. Приведённые далее соображения о моменте вызова особенно актуальны для Sonnet. Не применяйте напоминание к исполнителям Opus: на Opus оно немного снизило долю успешных выполнений.
При значении `NUDGE_TURN` по умолчанию, равном 2, напоминание обычно поступает после того, как модель сориентировалась в задаче, но до того, как она выбрала подход.
```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):
# Замените на свою диспетчеризацию инструментов. Возвращает по одному блоку tool_result на каждый блок tool_use.
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"},
# ... ваши другие инструменты
]
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})
# Пропустите это, если ваша системная подсказка уже указывает модели вызывать инструменты экономно.
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[] {
// Замените своей логикой вызова инструментов. Возвращает по одному блоку tool_result на каждый блок tool_use.
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" }
// ... ваши другие инструменты
];
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 });
}
// Пропустите это, если ваша системная подсказка уже велит модели вызывать инструменты экономно.
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
// Замените на свою диспетчеризацию инструментов. Возвращает по одному блоку tool_result на каждый блок tool_use.
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 }
// ... ваши другие инструменты
};
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 });
}
// Пропустите это, если ваша системная подсказка уже предписывает модели вызывать инструменты экономно.
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
)
// Замените на свою диспетчеризацию инструментов. Возвращает по одному блоку tool_result на каждый блок tool_use.
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,
}},
// ... ваши другие инструменты
}
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,
})
}
// Пропустите это, если ваша системная подсказка уже указывает модели вызывать инструменты экономно.
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
// Замените на свою диспетчеризацию инструментов. Возвращает по одному блоку tool_result на каждый блок tool_use.
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())
// ... ваши другие инструменты
);
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());
}
// Пропустите это, если ваша системная подсказка уже указывает модели вызывать инструменты экономно.
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
// Замените на свою диспетчеризацию инструментов. Возвращает по одному блоку tool_result на каждый блок tool_use.
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'],
// ... ваши другие инструменты
];
$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];
}
// Пропустите это, если ваша системная подсказка уже велит модели вызывать инструменты экономно.
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
# Замените на свою диспетчеризацию инструментов. Возвращает по одному блоку tool_result на каждый блок tool_use.
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" }
# ... ваши другие инструменты
]
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?
# Пропустите это, если ваша системная подсказка уже указывает модели вызывать инструменты экономно.
messages << { role: "user", content: NUDGE_TEXT } if turn == NUDGE_TURN - 1 && !advisor_called
end
```
Цикл завершается при любой причине остановки, кроме `tool_use` или `pause_turn`. Если `max_tokens` обрывает ответ, удалите усечённый ход ассистента из `messages` и [повторите попытку с более высоким `max_tokens`](https://platform.claude.com/docs/ru/build-with-claude/handling-stop-reasons#max-tokens). Если этот ход не содержит блока `tool_use`, вы можете вместо этого сохранить его и [продолжить ответ](https://platform.claude.com/docs/ru/build-with-claude/handling-stop-reasons#ensuring-complete-responses) новым сообщением пользователя. Повторная отправка усечённого хода ассистента в качестве последнего сообщения является [предзаполнением](https://platform.claude.com/docs/ru/api/errors#prefill-not-supported) («prefill»), которое Claude 4.6 и более поздние модели отклоняют.
Добавляйте напоминание отдельным сообщением пользователя после результатов инструментов, а не соседним блоком в том же сообщении. Последовательные сообщения пользователя допустимы. В тестах Anthropic на исполнителях Claude Haiku 4.5 и Sonnet они вели себя так же, как соседний блок. Форма отдельного сообщения также чётко отделяет напоминание от вывода инструментов.
**Компромиссы:** напоминание повышает частоту вызовов, что может привести к ненужной консультации на тривиально простых задачах. Если ваша рабочая нагрузка сочетает простые и сложные задачи, рассмотрите возможность увеличить `NUDGE_TURN` до 3, чтобы задачи из двух ходов завершались до срабатывания напоминания, или включайте напоминание по сигналу сложности задачи, который вы уже вычисляете. Если ваша системная подсказка уже содержит сдерживающие формулировки («используйте советника только при реальной неопределенности»), полностью откажитесь от напоминания, поскольку эти две инструкции противоречат друг другу.
Текстовое напоминание очень заметно для исполнителей Claude Haiku 4.5 и Sonnet: от 74 процентов (Sonnet) до 98 процентов (Claude Haiku 4.5) попыток с напоминанием в тестах Anthropic вызывали советника сразу на ходе 2. Если это происходит до того, как исполнитель прочитал задачу или собрал контекст, итоговый вызов советника получается малоконтекстным и может вытеснить более своевременный последующий вызов. Прежде чем добавлять напоминание, измерьте базовый ход первого вызова вашего исполнителя. Если исполнитель уже надёжно вызывает советника и его первый вызов обычно приходится на ход N, установите `NUDGE_TURN` больше N. В тестах Anthropic напоминание на ходе 2 в рабочих нагрузках, где базовый первый вызов приходился на ход 7 или позже, коррелировало со снижением эффективности выполнения задач на 3–4 процентных пункта. В рабочей нагрузке с просмотром веб-страниц, где базовая частота вызовов составляла 86 процентов, то же напоминание повысило вовлечённость без потерь в эффективности выполнения задач.
Чтобы принудительно вызвать консультацию в конкретном запросе вместо напоминания, установите `tool_choice` в `{"type": "tool", "name": "advisor"}` с учетом ограничений, описанных в разделе [Принудительное использование инструментов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/define-tools#forcing-tool-use). Принудительное использование инструментов нельзя сочетать с ручными расширенными размышлениями (`thinking: {type: "enabled"}`): если включить и то, и другое, API вернет `400 invalid_request_error`. Адаптивные размышления поддерживают принудительное использование инструментов. Исполнители Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1 и Claude Mythos 5.1 отклоняют типы `tool_choice` `tool` и `any`, поэтому для этих моделей используйте напоминание в подсказке.
## Потоковая передача
Подвывод советника не поддерживает «streaming» (потоковую передачу). Пока работает советник, поток исполнителя приостанавливается, а затем полный результат приходит одним событием.
Блок `server_tool_use` с `name: "advisor"` сигнализирует о начале вызова советника. Пауза начинается, когда этот блок закрывается (`content_block_stop`). Во время паузы в потоке приходят только стандартные SSE-сообщения `ping` для поддержания соединения, примерно каждые 30 секунд. При коротких вызовах советника ping-сообщений может не быть вовсе.
Когда советник завершает работу, `advisor_tool_result` приходит полностью сформированным в одном событии `content_block_start` (без дельт). Затем потоковая передача вывода исполнителя возобновляется.
Далее следует событие `message_delta` с обновленным массивом `usage.iterations`, отражающим количество токенов советника.
## Использование и оплата
Вызовы советника выполняются как отдельный подвывод и оплачиваются по тарифам модели-советника. Использование отражается в массиве `usage.iterations[]`:
```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
}
]
}
}
```
Поля `usage` верхнего уровня отражают только токены исполнителя. Токены советника не включаются в итоговые значения верхнего уровня, поскольку оплачиваются по другому тарифу. Итерации с `type: "advisor_message"` оплачиваются по тарифам модели-советника, а итерации с `type: "message"` — по тарифам модели-исполнителя.
Каждое поле `usage` верхнего уровня — это сумма значений этого поля по всем итерациям исполнителя, включая `input_tokens`, `output_tokens` и `cache_read_input_tokens`. Каждая итерация исполнителя заново отправляет растущий диалог, поэтому входные данные поздних итераций включают вывод ранних. Из-за этого суммарное значение `input_tokens` превышает размер любой отдельной подсказки. При построении логики учета затрат используйте `usage.iterations` для полной разбивки по итерациям.
Вывод советника обычно составляет от 400 до 700 текстовых токенов, или от 1 400 до 1 800 токенов в сумме с размышлениями. Экономия достигается за счет того, что советник не генерирует весь итоговый вывод: это делает исполнитель по более низкому тарифу.
Параметр `max_tokens` верхнего уровня применяется только к выводу исполнителя и не ограничивает токены подвывода советника. Чтобы напрямую ограничить вывод советника, задайте [`max_tokens` в определении инструмента](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#capping-advisor-output). Токены советника также не расходуют [бюджет задачи](https://platform.claude.com/docs/ru/build-with-claude/task-budgets), назначенный исполнителю.
[Priority Tier](https://platform.claude.com/docs/ru/api/service-tiers) применяется к каждой модели независимо. Обязательство Priority Tier для модели-исполнителя не распространяется на советника. Вызовы советника выполняются в Priority Tier, только если у вашей организации есть обязательство и для модели-советника.
## Кэширование подсказок советника
Существует два независимых уровня кэширования.
### Кэширование на стороне исполнителя
Блок `advisor_tool_result` кэшируется так же, как любой другой блок контента. Точка останова `cache_control`, размещенная после него в последующем ходе, дает попадание в кэш. Подсказка исполнителя всегда содержит рекомендации в открытом виде, независимо от того, получил ли ваш клиент `text` или `encrypted_content`. Поэтому кэширование работает одинаково для обоих вариантов результата.
### Кэширование на стороне советника
Задайте `caching` в определении инструмента, чтобы включить кэширование подсказок для собственной стенограммы советника между вызовами в рамках одного диалога:
```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" }
}
]
```
Подсказка советника при N-м вызове — это подсказка (N-1)-го вызова с добавленным еще одним сегментом, поэтому префикс стабилен между вызовами. При включенном `caching` каждый вызов советника записывает запись в кэш, а следующий вызов читает до этой точки и платит только за разницу. Вы увидите, что `cache_read_input_tokens` становится ненулевым на второй и последующих итерациях `advisor_message`.
**Когда включать:** запись в кэш обходится дороже, чем экономия от чтения, если советник вызывается два раза или меньше за диалог. Кэширование окупается примерно при трех вызовах советника, и дальше выгода растет. Включайте его для длинных агентных циклов и оставляйте выключенным для коротких задач.
**Сохраняйте согласованность:** задайте `caching` один раз и не меняйте его на протяжении всего диалога. Выключение и повторное включение посреди диалога приводит к промахам кэша.
[`clear_thinking`](https://platform.claude.com/docs/ru/build-with-claude/context-editing) со значением `keep`, отличным от `"all"`, сдвигает цитируемую стенограмму советника на каждом ходе, вызывая промахи кэша на стороне советника. Это влияет только на стоимость. Качество советов не страдает. Когда размышления включены без явной конфигурации `clear_thinking`, API по умолчанию использует `keep: {type: "thinking_turns", value: 1}`, что вызывает такое поведение (это значение по умолчанию для более ранних моделей Opus и Sonnet и для моделей Haiku вплоть до Claude Haiku 4.5; для Claude Opus 4.5 и более поздних моделей Opus, Claude Sonnet 4.6 и более поздних моделей Sonnet, а также Claude Haiku 5.5 по умолчанию сохраняются все ходы). Установите `keep: "all"`, чтобы сохранить стабильность кэша советника.
## Сочетание с другими инструментами
Инструмент советника сочетается с другими серверными и клиентскими инструментами. Добавьте их все в один массив `tools`:
```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" } }
}
}
]
```
Исполнитель может искать в интернете, вызывать советника и использовать ваши пользовательские инструменты в одном и том же ходе. План советника может влиять на то, к каким инструментам исполнитель обратится дальше.
| Функция | Взаимодействие |
| ------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Пакетная обработка](https://platform.claude.com/docs/ru/build-with-claude/batch-processing) | Поддерживается. `usage.iterations` отражается для каждого элемента. |
| [Подсчет токенов](https://platform.claude.com/docs/ru/build-with-claude/token-counting) | Возвращает только входные токены первой итерации исполнителя. Для приблизительной оценки для советника вызовите `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`), указав в `model` модель-советника и те же сообщения. |
| [Редактирование контекста](https://platform.claude.com/docs/ru/build-with-claude/context-editing) | `clear_tool_uses` не полностью совместим с блоками инструмента советника. Для `clear_thinking` см. предупреждение о кэшировании выше. |
| `pause_turn` | Незавершенный вызов советника завершает ответ с `stop_reason: "pause_turn"` и блоком `server_tool_use` без результата, если в том же ходе нет клиентского блока `tool_use`, ожидающего вашего результата. Советник выполняется при возобновлении. Если исполнитель в этом ходе также вызвал один из ваших инструментов, ответ вместо этого завершается с `stop_reason: "tool_use"`, а ожидающий вызов советника выполняется в начале вашего следующего запроса, после того как вы отправите блоки `tool_result`. См. [Возобновление приостановленного хода](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#resuming-a-paused-turn), [Сочетание серверных и клиентских инструментов в одном ходе](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/server-tools#mixing-server-tools-and-client-tools-in-one-turn) и [Серверные инструменты](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/server-tools#the-server-side-loop-and-pause-turn). |
## Рекомендации
### Подсказки для задач программирования и агентных задач
Инструмент советника поставляется со встроенным описанием, которое побуждает исполнителя вызывать его в начале сложных задач и при возникновении трудностей. Для исследовательских задач дополнительные подсказки обычно не нужны.
В задачах программирования и агентных задачах советник повышает интеллект при сопоставимой стоимости, если сокращает общее число вызовов инструментов и длину диалога. Этому способствуют два момента вызова:
1. Ранний первый вызов советника, после того как в стенограмме появилось несколько ознакомительных чтений.
2. Для сложных задач — финальный вызов советника, после того как в стенограмме появились записи файлов и результаты тестов.
Если ваш агент предоставляет другие инструменты планирования (например, инструмент списка задач), попросите модель вызывать советника до них, чтобы план советника передавался в эти инструменты. [Рекомендуемая системная подсказка](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#suggested-system-prompt-for-coding-tasks) закрепляет шаблон раннего вызова. Добавьте собственное предложение, указывающее на те инструменты планирования, которые предоставляет ваш агент.
#### Рекомендуемая системная подсказка для задач программирования
Без указаний в системной подсказке исполнитель в некоторых областях, особенно в программировании, вызывает советника реже, чем нужно. Если в задачах программирования вам нужны стабильные моменты вызова и примерно два-три вызова на задачу, добавьте следующие блоки в начало системной подсказки исполнителя. Они должны стоять перед любыми другими предложениями, упоминающими советника.
Указания по моменту вызова:
```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.
```
Как исполнителю следует относиться к рекомендациям (разместите сразу после блока о моменте вызова):
```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.
```
#### Альтернативная системная подсказка для Haiku на нагрузках программирования
Claude Haiku 4.5 применяет стандартные указания по советнику консервативно. Благодаря этому на исследовательских и справочных нагрузках частота вызовов остается уместно низкой. Однако на нагрузках программирования, где ранняя консультация с советником стабильно окупается, качество страдает. На внутреннем бенчмарке по программированию близкий вариант следующего блока повысил долю успешных задач Haiku примерно на 7,5 процентных пункта по сравнению со встроенным поведением по умолчанию. Исключение для операций только на чтение в жестком правиле было добавлено уже после измерений.
Используйте этот блок вместо приведенных выше блоков о моменте вызова и рекомендациях, если ваш исполнитель Haiku выполняет преимущественно задачи программирования или записи:
```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.
```
**Оговорка:** на внутреннем бенчмарке понимания при веб-поиске (n = 1 266) близкий вариант этого блока снизил точность примерно на 4 процентных пункта по сравнению со встроенным поведением по умолчанию. Если ваша нагрузка сочетает программирование со значительным объемом поиска или извлечения информации, используйте [рекомендуемые блоки](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#suggested-system-prompt-for-coding-tasks). Другой вариант — переключаться на этот блок по уже вычисляемому вами признаку типа нагрузки.
#### Увеличение числа вызовов советника у исполнителей Opus
Исполнители Opus обычно вызывают советника с уместной частотой без дополнительных подсказок. Если ваш исполнитель Opus на вашей нагрузке вызывает советника слишком редко, добавьте в системную подсказку следующую контрольную точку:
```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.
```
**Оговорка:** в тестах Anthropic близкий вариант этого блока повысил долю успешных задач, где советника вызывали слишком редко, примерно на 7–10 процентных пунктов. Исключение для операций только на чтение в жестком правиле было добавлено уже после измерений. Однако Opus стал вызывать советника слишком часто в задачах, где первое действие не требует планирования. На смешанной нагрузке итоговый эффект оказался примерно нулевым. Добавляйте этот блок, только если вы заметили, что Opus пропускает советника в задачах, где консультация помогла бы. Не добавляйте его по умолчанию.
#### Сокращение длины вывода советника
Вывод советника — главная статья его расходов, и `max_tokens` верхнего уровня его не ограничивает. Советник видит и вашу системную подсказку, и ваши сообщения пользователя как цитируемый контекст задачи исполнителя. Поэтому инструкции, обращенные непосредственно к советнику, выполняются гораздо надежнее, чем описания в третьем лице. Самое эффективное размещение из протестированных Anthropic — строка в сообщении пользователя:
```text wrap
(Advisor: please keep your guidance under 80 words — I need a focused starting point, not a comprehensive plan.)
```
Ваш агентный фреймворк может программно добавлять эту строку в начало сообщения перед отправкой запроса. Это мягкое ограничение: советник иногда его превышает, поэтому запрашивайте примерно 80 процентов от реального предела.
В тестах Anthropic эта строка также увеличила частоту обращений исполнителя к советнику, но итоговая общая стоимость все равно снизилась (консультаций больше, но каждая короче).
Для наилучшего баланса стоимости и качества сочетайте этот подход с указаниями по моменту вызова из раздела [Рекомендуемая системная подсказка для задач программирования](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#suggested-system-prompt-for-coding-tasks) (или с [альтернативным блоком для Haiku](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#alternative-system-prompt-for-haiku-on-coding-workloads), если вы используете его). Если нужен жесткий предел, а не мягкая просьба, см. [Ограничение вывода советника](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#capping-advisor-output).
### Ограничение вывода советника
Задайте `max_tokens` в определении инструмента, чтобы ограничить общий вывод советника (размышления плюс текст) за один вызов:
```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
}
]
```
Минимальное значение — 1024. Если задать `max_tokens` выше собственного лимита вывода модели-советника, вернется ошибка 400. Лимит применяется к каждому вызову советника независимо и не делится между вызовами в одном запросе.
Это не просто жесткое обрезание. Сервер также сообщает советнику оставшийся бюджет токенов, и советник подстраивает ответ под него.
**Рекомендуемое начальное значение:** `max_tokens: 2048`. В тестах Anthropic на сложном бенчмарке рассуждений (n = 40 на конфигурацию) это значение сократило средний вывод советника примерно в 7 раз по сравнению с отсутствием лимита. Обрезание при этом было почти нулевым, а заметного снижения качества не наблюдалось. Минимальное значение 1024 сократило вывод примерно в 10 раз, но обрезало около 10 процентов вызовов. При таком размере выборки различия в точности между всеми конфигурациями оставались в пределах шума. Проверяйте на собственной нагрузке.
| `max_tokens` | Средний вывод советника, токенов | Обрезанные вызовы |
| ------------ | -------------------------------- | ----------------- |
| не задан | \~4 200–5 900 | н/д |
| 2048 | \~630–840 | \~0% |
| 1024 | \~370–480 | \~10% |
Сложные задачи на рассуждение вызывают у советника значительно более длинный вывод, чем [типичные 1 400–1 800 токенов](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#usage-and-billing), указанные выше для более легких нагрузок. Используйте эту таблицу для оценки коэффициента экономии, а не как универсальный ориентир для объема вывода советника.
Когда советник достигает лимита, блок результата содержит `stop_reason: "max_tokens"` в обоих [вариантах результата](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#result-variants), независимо от модели-советника. По `stop_reason` можно обнаружить обрезанные рекомендации и решить, повысить ли лимит или позволить исполнителю продолжить с частичными указаниями. API также добавляет к тексту рекомендаций `[Advisor output truncated at max_tokens=2048.]` (с указанием вашего лимита), чтобы исполнитель видел обрезание в своем контексте. Если советник возвращает `advisor_result` в открытом виде, этот маркер виден и вашему клиенту. Оба сигнала появляются, только если вы задали `max_tokens` в определении инструмента.
```json
{
"type": "advisor_tool_result",
"tool_use_id": "srvtoolu_abc123",
"content": {
"type": "advisor_redacted_result",
"encrypted_content": "EqQBCkYIBRgCIiQ3YTAwMjY1Mi1mZjM5LTQ1NGUtODgxNC1kNjNjNTk1ZWI3Y...",
"stop_reason": "max_tokens"
}
}
```
Чтобы узнать, насколько близко каждый вызов подошел к лимиту, проверьте `output_tokens` в соответствующей записи `advisor_message` в `usage.iterations`.
В отличие от [подхода на основе подсказки](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#trimming-advisor-output-length), `max_tokens` — это жесткий предел, а не мягкая просьба. Используйте `max_tokens`, когда нужна гарантированная граница по стоимости или задержке. Используйте подход на основе подсказки (или оба вместе), когда хотите склонить советника к краткости, не рискуя обрывом на полуслове.
### Сочетание с настройками усилия
Для задач программирования сочетание Sonnet в роли «executor» (исполнитель) со средним уровнем [«effort» (усилие)](https://platform.claude.com/docs/ru/build-with-claude/effort) и Opus в роли «advisor» (советник) обеспечивает интеллект, сопоставимый с Sonnet при уровне усилия по умолчанию, но с меньшими затратами. Для максимального интеллекта оставьте для исполнителя уровень усилия по умолчанию.
### Контроль затрат
* Чтобы ограничить бюджет на уровне разговора, подсчитывайте вызовы советника на стороне клиента. Когда вы достигнете своего лимита, удалите инструмент советника из `tools`. Удалять блоки `advisor_tool_result` из истории сообщений не нужно (см. примечание в разделе [Многоходовые разговоры](https://platform.claude.com/docs/ru/agents-and-tools/tool-use/advisor-tool#multi-turn-conversations)).
* Включайте `caching` только для разговоров, в которых вы ожидаете три или более вызовов советника.
## Совместимость моделей
Модель-исполнитель (поле `model` верхнего уровня) и модель-советник (поле `model` внутри определения инструмента) должны образовывать допустимую пару. Советником должна быть Claude Sonnet 4.6 или более мощная модель, и она должна быть как минимум столь же мощной, как исполнитель. Модели с равными возможностями (например, Claude Opus 4.7 и Claude Opus 4.8) могут выступать советниками друг для друга.
| Модели-исполнители | Модели-советники |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 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) |
Если вы запросите недопустимую пару, API вернёт `400 invalid_request_error` с указанием неподдерживаемой комбинации.
### Доступность на платформах
Инструмент советника доступен в бета-версии в Claude API и на [Claude Platform on AWS](https://platform.claude.com/docs/ru/build-with-claude/claude-platform-on-aws). В настоящее время он недоступен в Amazon Bedrock, Google Cloud и Microsoft Foundry.
## Советник в Claude Managed Agents
Сессии [Claude Managed Agents](https://platform.claude.com/docs/ru/managed-agents/overview) также поддерживают советника, который настраивается как часть агента, а не как определение инструмента: задайте `"advisor": {"type": "enabled", "model": ...}` в блоке `multiagent` агента, и основной поток сессии сможет консультироваться с этой моделью посреди хода. Эта настройка не принимает параметры `max_uses`, `max_tokens` или `caching`, а советы доставляются как события потока в потоке событий сессии, а не как блоки `advisor_tool_result` в ответе. См. [Предоставление сессии советника](https://platform.claude.com/docs/ru/managed-agents/multiagent-orchestration#give-the-session-an-advisor).
## Следующие шаги
Сохраняйте и извлекайте информацию между разговорами с помощью каталога памяти на стороне клиента.
Работайте с инструментами, выполняемыми Anthropic: блоки server\_tool\_use, продолжение pause\_turn и фильтрация доменов.
Каталог инструментов, предоставляемых Anthropic, и справочник по необязательным свойствам определения инструментов.
Управляйте с помощью параметра effort тем, сколько токенов Claude использует при ответе, находя баланс между полнотой ответа и эффективностью использования токенов.