---
title: Бюджеты задач
url: https://platform.claude.com/docs/ru/build-with-claude/task-budgets
description: Задайте Claude рекомендательный бюджет токенов на весь агентный цикл, чтобы модель могла саморегулироваться при выполнении длительных агентных задач.
featureMetadata:
  status: beta
  betaHeader: task-budgets-2026-03-13
  supportedModels:
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-opus-5-5
    - claude-opus-5
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-sonnet-5-5
    - claude-haiku-5-5
---

«Task budgets» (бюджеты задач) позволяют сообщить Claude, сколько токенов у него есть на полный агентный цикл, включая размышления, вызовы инструментов, результаты инструментов и вывод. Модель видит текущий обратный отсчёт и использует его, чтобы расставлять приоритеты в работе и корректно завершать её по мере расходования бюджета.

## Когда использовать бюджеты задач

Бюджеты задач лучше всего подходят для агентных рабочих процессов, в которых Claude выполняет несколько вызовов инструментов и принимает несколько решений, прежде чем сформировать окончательный вывод и ожидать следующего ответа человека. Используйте их, когда:

* Вы хотите, чтобы Claude самостоятельно регулировал расход токенов в задачах с длинным горизонтом.
* У вас есть предсказуемый потолок стоимости или задержки на задачу, который нужно соблюдать.
* Вы хотите, чтобы модель корректно завершала работу (подводила итоги, сообщала о прогрессе) по мере приближения к бюджету, а не обрывалась посреди действия.

Бюджеты задач дополняют [параметр effort](https://platform.claude.com/docs/ru/build-with-claude/effort): effort управляет тем, насколько тщательно Claude рассуждает на каждом шаге, а бюджеты задач ограничивают общий объём работы, который Claude может выполнить за агентный цикл.

## Установка бюджета задачи

Добавьте `task_budget` в `output_config` и включите бета-заголовок:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -N \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: task-budgets-2026-03-13" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 128000,
      "stream": true,
      "messages": [{
        "role": "user",
        "content": "Review the codebase and propose a refactor plan."
      }],
      "output_config": {
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 64000}
      }
    }'
  ```

  ```bash CLI
  ant beta:messages create --beta task-budgets-2026-03-13 \
    --stream --format jsonl <<'YAML' | jq 'select(.type == "message_delta").usage'
  model: claude-opus-5-5
  max_tokens: 128000
  messages:
    - role: user
      content: Review the codebase and propose a refactor plan.
  output_config:
    effort: high
    task_budget:
      type: tokens
      total: 64000
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  with client.beta.messages.stream(
      model="claude-opus-5-5",
      max_tokens=128000,
      output_config={
          "effort": "high",
          "task_budget": {"type": "tokens", "total": 64000},
      },
      messages=[
          {"role": "user", "content": "Review the codebase and propose a refactor plan."}
      ],
      betas=["task-budgets-2026-03-13"],
  ) as stream:
      response = stream.get_final_message()

  print(response.usage)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const stream = client.beta.messages.stream({
    model: "claude-opus-5-5",
    max_tokens: 128000,
    output_config: {
      effort: "high",
      task_budget: { type: "tokens", total: 64000 }
    },
    messages: [{ role: "user", content: "Review the codebase and propose a refactor plan." }],
    betas: ["task-budgets-2026-03-13"]
  });

  const response = await stream.finalMessage();
  console.log(response.usage);
  ```

  ```csharp C#

  var client = new AnthropicClient();

  var responseUpdates = client.Beta.Messages.CreateStreaming(new MessageCreateParams
  {
      Model = Messages::Model.ClaudeOpus5_5,
      MaxTokens = 128000,
      Messages = [new() { Role = Role.User, Content = "Review the codebase and propose a refactor plan." }],
      OutputConfig = new BetaOutputConfig
      {
          Effort = Effort.High,
          TaskBudget = new BetaTokenTaskBudget { Total = 64000 },
      },
      Betas = ["task-budgets-2026-03-13"],
  });

  var response = await responseUpdates.Aggregate();
  Console.WriteLine(response.Usage);
  ```

  ```go Go
  client := anthropic.NewClient()

  stream := client.Beta.Messages.NewStreaming(context.TODO(), anthropic.BetaMessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 128000,
  	Betas:     []anthropic.AnthropicBeta{"task-budgets-2026-03-13"},
  	Messages: []anthropic.BetaMessageParam{{
  		Role: anthropic.BetaMessageParamRoleUser,
  		Content: []anthropic.BetaContentBlockParamUnion{{
  			OfText: &anthropic.BetaTextBlockParam{Text: "Review the codebase and propose a refactor plan."},
  		}},
  	}},
  	OutputConfig: anthropic.BetaOutputConfigParam{
  		Effort: anthropic.BetaOutputConfigEffortHigh,
  		TaskBudget: anthropic.BetaTokenTaskBudgetParam{
  			Total: 64000,
  		},
  	},
  })

  message := anthropic.BetaMessage{}
  for stream.Next() {
  	event := stream.Current()
  	if err := message.Accumulate(event); err != nil {
  		panic(err)
  	}
  }
  if stream.Err() != nil {
  	panic(stream.Err())
  }

  fmt.Printf("Usage: input_tokens=%d, output_tokens=%d\n", message.Usage.InputTokens, message.Usage.OutputTokens)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(128000L)
      .addUserMessage("Review the codebase and propose a refactor plan.")
      .outputConfig(BetaOutputConfig.builder()
          .effort(BetaOutputConfig.Effort.HIGH)
          .taskBudget(BetaTokenTaskBudget.builder().total(64000L).build())
          .build())
      .addBeta("task-budgets-2026-03-13")
      .build();

  BetaMessageAccumulator accumulator = BetaMessageAccumulator.create();
  try (StreamResponse<BetaRawMessageStreamEvent> stream =
          client.beta().messages().createStreaming(params)) {
      stream.stream().forEach(accumulator::accumulate);
  }

  BetaMessage response = accumulator.message();
  IO.println(response.usage());
  ```

  ```php PHP
  use Anthropic\Beta\Messages\BetaRawMessageDeltaEvent;

  $client = new Client();

  $stream = $client->beta->messages->createStream(
      model: 'claude-opus-5-5',
      maxTokens: 128000,
      messages: [
          ['role' => 'user', 'content' => 'Review the codebase and propose a refactor plan.'],
      ],
      outputConfig: [
          'effort' => 'high',
          'taskBudget' => ['type' => 'tokens', 'total' => 64000],
      ],
      betas: ['task-budgets-2026-03-13'],
  );

  // Последнее событие message_delta содержит суммарное использование токенов для запроса.
  $usage = null;
  foreach ($stream as $event) {
      if ($event instanceof BetaRawMessageDeltaEvent) {
          $usage = $event->usage;
      }
  }

  echo $usage;
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  stream = client.beta.messages.stream(
    model: "claude-opus-5-5",
    max_tokens: 128_000,
    messages: [
      { role: "user", content: "Review the codebase and propose a refactor plan." }
    ],
    output_config: {
      effort: :high,
      task_budget: { type: :tokens, total: 64_000 }
    },
    betas: ["task-budgets-2026-03-13"]
  )

  response = stream.accumulated_message

  puts response.usage
  ```
</CodeGroup>

Объект `task_budget` имеет три поля:

* `type`: всегда `"tokens"`.
* `total`: количество токенов, которое Claude может потратить за агентный цикл, включая размышления, вызовы инструментов, результаты инструментов и вывод.
* `remaining` (необязательно): остаток бюджета, перенесённый из предыдущего запроса. Если не указано, по умолчанию равно `total`.

## Как работает обратный отсчёт бюджета

Claude видит маркер обратного отсчёта бюджета, который внедряется на стороне сервера на протяжении всего разговора. Маркер показывает, сколько токенов осталось в текущем агентном цикле, и обновляется по мере того, как модель генерирует размышления, вызовы инструментов и вывод, а также по мере обработки результатов инструментов. Claude использует этот сигнал, чтобы распределять усилия и корректно завершать работу по мере расходования бюджета.

<Note>
  **Обратный отсчёт виден только модели.** Ответы API не содержат поля с оставшимся бюджетом: в объекте `usage` ответа нет информации о `task_budget`, и в SDK нет метода доступа к ней. Чтобы отслеживать расход на стороне клиента, суммируйте использование токенов по всем запросам в вашем цикле, как показано в разделе [Измерьте текущее использование](https://platform.claude.com/docs/ru/build-with-claude/task-budgets#measure-your-current-usage), или передавайте собственное значение через `remaining` при [переносе бюджета через компактизацию](https://platform.claude.com/docs/ru/build-with-claude/task-budgets#carrying-a-budget-across-compaction-with-remaining).
</Note>

<Warning>
  **Обратный отсчёт отражает токены, которые Claude обработал в текущем агентном цикле, а не токены, которые вы повторно отправляете между запросами.** Если ваш клиент отправляет полную историю разговора в каждом последующем запросе, подсчёт токенов на стороне клиента может отличаться от бюджета, который отслеживает Claude. Если вы при этом ещё и уменьшаете `remaining`, повторно отправляя полную историю, модель видит заниженный бюджет, и обратный отсчёт убывает быстрее, чем должен, из-за чего Claude завершает работу раньше, чем на самом деле позволяет бюджет. Задайте щедрый бюджет и позвольте модели саморегулироваться по обратному отсчёту, вместо того чтобы пытаться воспроизводить его на стороне клиента.
</Warning>

### Что считается ходом

Бюджет охватывает один "agentic turn" (агентный ход), также называемый агентным циклом. Это всё, что Claude делает в ответ на одно пользовательское сообщение без результатов инструментов. Один ход может включать несколько запросов.

Пользовательское сообщение без результатов инструментов начинает новый ход с новым бюджетом. Сейчас обратный отсчёт по-прежнему учитывает историю предыдущих ходов, пока она остаётся в контексте. Типичный случай — новое сообщение после того, как Claude завершил свой ход, например из-за исчерпания бюджета:

```json
{ "role": "user", "content": "Continue." }
```

Пользовательское сообщение с блоками `tool_result` продолжает текущий ход, поскольку ваш клиент обрабатывает вызовы инструментов, относящиеся к этому ходу:

```json
{
  "role": "user",
  "content": [
    { "type": "tool_result", "tool_use_id": "toolu_01", "content": "<npm audit output>" }
  ]
}
```

Это верно, даже если сообщение помимо результатов инструментов содержит новый контент:

```json
{
  "role": "user",
  "content": [
    { "type": "tool_result", "tool_use_id": "toolu_01", "content": "<npm audit output>" },
    { "type": "text", "text": "Also check the Dockerfile." }
  ]
}
```

Серверное [сжатие](https://platform.claude.com/docs/ru/build-with-claude/compaction-threshold) во время хода не сбрасывает бюджет: токены, израсходованные в ходе до сжатия, по-прежнему учитываются. Токены, появившиеся до начала хода, не учитываются, даже если их резюмирует сжатие в начале хода. Сейчас это исключение действует только для бюджета, переносимого через серверное сжатие. История предыдущих ходов по-прежнему учитывается, пока она остаётся в контексте.

### Разобранный пример: подсчёт бюджета по запросам

Бюджет задачи учитывает то, что Claude **видит** (размышления, вызовы и результаты инструментов, текст), а не содержимое полезной нагрузки вашего запроса. В агентном цикле клиент повторно отправляет весь разговор в каждом запросе, поэтому полезная нагрузка постоянно растёт. Бюджет же уменьшается только на новое: на токены, которые генерирует Claude, и на контент, которого он ещё не видел. Ниже разобран один [агентный ход](https://platform.claude.com/docs/ru/build-with-claude/task-budgets#what-counts-as-a-turn) из трёх запросов. Первый содержит пользовательское сообщение, а два следующих повторно отправляют историю с добавленным результатом инструмента.

Рассмотрим цикл с `task_budget: {type: "tokens", total: 100000}` и единственным инструментом `bash`.

**Запрос 1.** Вы отправляете начальный запрос:

```json
{
  "messages": [
    { "role": "user", "content": "Audit this repo for security issues and report findings." }
  ]
}
```

Claude размышляет, затем выдаёт вызов инструмента и останавливается с `stop_reason: "tool_use"`:

```json
{
  "role": "assistant",
  "content": [
    {
      "type": "thinking",
      "thinking": "I'll start by listing dependencies to look for known-vulnerable packages..."
    },
    {
      "type": "tool_use",
      "id": "toolu_01",
      "name": "bash",
      "input": { "command": "cat package.json && npm audit --json" }
    }
  ]
}
```

Предположим, что это сообщение ассистента (размышления плюс вызов инструмента) содержит в сумме 5 000 сгенерированных токенов. К концу генерации обратный отсчёт, который видел Claude, дошёл примерно до `remaining` ≈ 95 000.

**Запрос 2.** Ваш клиент запускает инструмент, а затем повторно отправляет полную историю с добавленным результатом инструмента:

```json
{
  "messages": [
    { "role": "user", "content": "Audit this repo for security issues and report findings." },
    {
      "role": "assistant",
      "content": [
        { "type": "thinking", "thinking": "I'll start by listing dependencies..." },
        {
          "type": "tool_use",
          "id": "toolu_01",
          "name": "bash",
          "input": { "command": "cat package.json && npm audit --json" }
        }
      ]
    },
    {
      "role": "user",
      "content": [
        {
          "type": "tool_result",
          "tool_use_id": "toolu_01",
          "content": "<2,800 tokens of npm audit output>"
        }
      ]
    }
  ]
}
```

Повторно отправленные сообщения из запроса 1 заново не учитываются. Однако результат инструмента размером 2 800 токенов — это новый контент, и он расходует бюджет. Claude тратит ещё 4 000 токенов на размышления и второй вызов инструмента (`grep -rn "eval(" src/`). Обратный отсчёт доходит примерно до `remaining` ≈ 88 200.

**Запрос 3.** Полная история снова отправляется повторно, теперь с добавленным вторым результатом инструмента (1 200 токенов вывода grep). Claude пишет итоговый отчёт о находках объёмом 6 000 токенов и останавливается с `stop_reason: "end_turn"`. `remaining` ≈ 81 000.

Если сравнить три запроса, разница между размером полезной нагрузки и расходом бюджета становится наглядной:

| Запрос    | Полезная нагрузка запроса (примерное число отправленных входных токенов) | Токены, учтённые в бюджете в этом запросе                            | `remaining` бюджета после запроса |
| --------- | ------------------------------------------------------------------------ | -------------------------------------------------------------------- | --------------------------------- |
| 1         | \~20                                                                     | 5 000 (размышления + `tool_use`)                                     | \~95 000                          |
| 2         | \~7 800 (сообщения из запроса 1 + результат инструмента)                 | 6 800 (2 800 результат инструмента + 4 000 размышления и `tool_use`) | \~88 200                          |
| 3         | \~13 000 (полная история + второй результат инструмента)                 | 7 200 (1 200 результат инструмента + 6 000 `text`)                   | \~81 000                          |
| **Итого** | **\~20 820 отправлено во всех запросах**                                 | **19 000 учтено в бюджете**                                          | Н/Д                               |

Ваш клиент отправил исходное пользовательское сообщение трижды, а первое сообщение ассистента — дважды, но каждое из них было учтено один раз. Из бюджета израсходовано 19 000 из 100 000 токенов. При этом суммарная полезная нагрузка, переданная клиентом, была больше, а входные данные, закэшированные с помощью "prompt caching" (кэширования подсказок) в запросах 2 и 3, — ещё больше.

### Перенос бюджета через компактизацию с помощью `remaining`

Ваш код может сжимать или переписывать историю сообщений между запросами (например, резюмируя более ранние сообщения). В этом случае сервер не знает, сколько бюджета было израсходовано до сжатия. Передайте `remaining` в следующем запросе, чтобы обратный отсчёт продолжился с того места, где вы остановились, а не сбросился до `total`:

<CodeGroup exclude="shell">
  ```python Python
  # Токены, потраченные до сжатия, отслеживаются на стороне клиента
  tokens_spent_so_far = 45000

  output_config = {
      "effort": "high",
      "task_budget": {
          "type": "tokens",
          "total": 128000,
          "remaining": 128000 - tokens_spent_so_far,
      },
  }
  ```

  ```typescript TypeScript
  // Токены, потраченные до сжатия, отслеживаются на стороне клиента
  const tokensSpentSoFar = 45000;

  const outputConfig = {
    effort: "high",
    task_budget: {
      type: "tokens",
      total: 128000,
      remaining: 128000 - tokensSpentSoFar
    }
  };
  ```

  ```csharp C#
  // Токены, потраченные до сжатия, отслеживаются на стороне клиента
  var tokensSpentSoFar = 45000;

  var outputConfig = new BetaOutputConfig
  {
      Effort = Effort.High,
      TaskBudget = new BetaTokenTaskBudget
      {
          Total = 128000,
          Remaining = 128000 - tokensSpentSoFar,
      },
  };
  ```

  ```go Go
  // Токены, потраченные до уплотнения, отслеживаются на стороне клиента
  tokensSpentSoFar := int64(45000)

  outputConfig := anthropic.BetaOutputConfigParam{
  	Effort: anthropic.BetaOutputConfigEffortHigh,
  	TaskBudget: anthropic.BetaTokenTaskBudgetParam{
  		Total:     128000,
  		Remaining: anthropic.Int(128000 - tokensSpentSoFar),
  	},
  }
  ```

  ```java Java
  // Токены, потраченные до уплотнения, отслеживаются на стороне клиента
  long tokensSpentSoFar = 45000;

  BetaOutputConfig outputConfig = BetaOutputConfig.builder()
      .effort(BetaOutputConfig.Effort.HIGH)
      .taskBudget(BetaTokenTaskBudget.builder()
          .total(128000L)
          .remaining(128000L - tokensSpentSoFar)
          .build())
      .build();
  ```

  ```php PHP
  // Токены, потраченные до сжатия, отслеживаются на стороне клиента
  $tokensSpentSoFar = 45000;

  $outputConfig = [
      'effort' => 'high',
      'taskBudget' => [
          'type' => 'tokens',
          'total' => 128000,
          'remaining' => 128000 - $tokensSpentSoFar,
      ],
  ];
  ```

  ```ruby Ruby
  # Токены, потраченные до сжатия, отслеживаются на стороне клиента
  tokens_spent_so_far = 45_000

  output_config = {
    effort: :high,
    task_budget: {
      type: :tokens,
      total: 128_000,
      remaining: 128_000 - tokens_spent_so_far
    }
  }
  ```
</CodeGroup>

В этом примере токены, израсходованные до сжатия, — это использование всех сообщений, которые вы к этому моменту удалили из истории. Измеряйте его так, как описано в разделе [Измерение текущего использования](https://platform.claude.com/docs/ru/build-with-claude/task-budgets#measure-your-current-usage). Не учитывайте то, что по-прежнему присутствует в отправляемых сообщениях, включая добавленное вами резюме: эти токены сервер подсчитывает сам. Обновляйте это значение только при такой замене истории и не уменьшайте его с каждым запросом. Передавайте полученное значение `remaining` в каждом запросе, а не только в том, где происходит сжатие.

Если цикл в каждом запросе повторно отправляет полную несжатую историю, не указывайте `remaining` и позвольте серверу самому вести обратный отсчёт.

## Изменение бюджета в середине разговора

`task_budget` — это настройка уровня запроса. Чтобы изменить бюджет в процессе выполнения задачи, например расширить его, когда пользователь расширяет запрос, задайте новый `task_budget` в `output_config` в следующем запросе. Учитывайте последствия для кэширования: значение бюджета участвует в сформированной подсказке, поэтому изменённое значение не совпадает с записями кэша, созданными при старом значении (см. раздел [Поддержка функции](https://platform.claude.com/docs/ru/build-with-claude/task-budgets#feature-support) ниже).

## Бюджеты задач носят рекомендательный, а не принудительный характер

Бюджеты задач — это **мягкая подсказка, а не жёсткий лимит**. Claude может иногда превышать бюджет, если находится в середине действия, прерывание которого было бы более разрушительным, чем его завершение. Принудительным ограничением на общее количество выходных токенов по-прежнему остаётся `max_tokens`, который обрезает ответ с `stop_reason: "max_tokens"` при достижении.

Для жёсткого ограничения стоимости или задержки сочетайте бюджеты задач с разумным значением `max_tokens`:

* Используйте `task_budget`, чтобы дать Claude ориентир для распределения темпа.
* Используйте `max_tokens` как абсолютный потолок, предотвращающий неконтролируемую генерацию.

Поскольку `task_budget` охватывает весь агентный цикл (потенциально множество запросов), а `max_tokens` ограничивает каждый отдельный запрос, эти два значения независимы; одно не обязано быть равным другому или меньше него.

<Warning>
  **Бюджет, слишком малый для задачи, может вызвать поведение, похожее на отказ.** Когда Claude видит бюджет, явно недостаточный для запрашиваемой работы (например, бюджет в 20 000 токенов для многочасовой агентной задачи по программированию), он может вовсе отказаться от попытки выполнить задачу, агрессивно сузить её объём или остановиться раньше с частичным результатом, вместо того чтобы начинать работу, которую не сможет завершить. Если после установки бюджета вы наблюдаете неожиданные отказы или преждевременные остановки, увеличьте бюджет, прежде чем отлаживать другие параметры. Подбирайте размер бюджетов исходя из фактического распределения длительности ваших задач, а не фиксированного значения по умолчанию; см. раздел [Выбор бюджета](https://platform.claude.com/docs/ru/build-with-claude/task-budgets#choosing-a-budget).
</Warning>

## Выбор бюджета

Правильный бюджет зависит от того, сколько работы в настоящее время выполняет ваш агентный цикл. Вместо того чтобы гадать, сначала измерьте существующее использование токенов, а затем настраивайте исходя из этого.

### Измерьте текущее использование

Запустите репрезентативную выборку задач **без** установленного `task_budget` и запишите общее количество токенов, которое Claude тратит на задачу. Для агентного цикла суммируйте `usage.output_tokens` по всем запросам в цикле, плюс токены результатов инструментов, которые вы добавляете между запросами:

<CodeGroup exclude="shell:cURL">
  ```bash CLI
  ant messages create --transform 'usage.output_tokens' <<'YAML'
  model: claude-opus-5-5
  max_tokens: 4096
  messages:
    - role: user
      content: Review the codebase and propose a refactor plan.
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {"role": "user", "content": "Review the codebase and propose a refactor plan."}
      ],
  )

  # Суммируйте output_tokens (текст + размышления + вызовы инструментов) по всем запросам в вашем цикле.
  print(response.usage.output_tokens)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [{ role: "user", content: "Review the codebase and propose a refactor plan." }]
  });

  // Суммируйте output_tokens (текст + размышления + вызовы инструментов) по всем запросам в вашем цикле.
  console.log(response.usage.output_tokens);
  ```

  ```csharp C#

  var client = new AnthropicClient();

  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [new() { Role = Role.User, Content = "Review the codebase and propose a refactor plan." }],
  });

  // Суммируйте OutputTokens (текст + размышления + вызовы инструментов) по всем запросам в вашем цикле.
  Console.WriteLine(response.Usage.OutputTokens);
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Review the codebase and propose a refactor plan.")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  // Суммируйте OutputTokens (текст + размышления + вызовы инструментов) по всем запросам в вашем цикле.
  fmt.Println(response.Usage.OutputTokens)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(4096L)
      .addUserMessage("Review the codebase and propose a refactor plan.")
      .build();

  Message response = client.messages().create(params);
  // Суммируйте outputTokens (текст + размышления + вызовы инструментов) по всем запросам в вашем цикле.
  IO.println(response.usage().outputTokens());
  ```

  ```php PHP
  $client = new Client();

  $response = $client->messages->create(
      model: 'claude-opus-5-5',
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Review the codebase and propose a refactor plan.'],
      ],
  );

  // Суммируйте outputTokens (текст + размышления + вызовы инструментов) по всем запросам в вашем цикле.
  echo $response->usage->outputTokens . "\n";
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Review the codebase and propose a refactor plan." }
    ]
  )

  # Суммируйте output_tokens (текст + размышления + вызовы инструментов) по всем запросам в вашем цикле.
  puts response.usage.output_tokens
  ```
</CodeGroup>

Выполните это на репрезентативном наборе задач и запишите распределение. Начните с p99 вашего расхода токенов на задачу, чтобы понять, как предоставление модели бюджета задачи может изменить её поведение, а затем тестируйте большие или меньшие значения по мере необходимости.

Минимально допустимое значение `task_budget.total` — **20 000 токенов** для всех моделей, поддерживающих бюджеты задач (см. раздел [Поддержка функции](https://platform.claude.com/docs/ru/build-with-claude/task-budgets#feature-support)). При меньших значениях возвращается ошибка 400.

## Взаимодействие с другими параметрами

* **`max_tokens`:** не зависит от бюджетов задач. `max_tokens` — это жёсткое ограничение на число сгенерированных токенов в одном запросе, а `task_budget` — рекомендательное ограничение на весь агентный цикл (который может включать множество запросов). При уровне effort `xhigh` или `max` установите `max_tokens` не менее 64k, чтобы у Claude было достаточно места для размышлений и действий в каждом запросе.
* **[Effort](https://platform.claude.com/docs/ru/build-with-claude/effort):** effort определяет, насколько глубоко Claude рассуждает на каждом шаге. Бюджеты задач определяют, какой общий объём работы Claude выполняет за агентный цикл. Эти параметры дополняют друг друга: effort настраивает глубину, а бюджеты задач — широту.
* **["Adaptive thinking" (адаптивные размышления)](https://platform.claude.com/docs/ru/build-with-claude/thinking):** бюджеты задач учитывают токены размышлений, поэтому по мере исчерпания бюджета адаптивные размышления сокращаются.
* **[Кэширование подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching):** маркер обратного отсчёта бюджета внедряется на стороне сервера в каждый запрос, поэтому он различается от запроса к запросу. Если ваш клиент уменьшает `task_budget.remaining` в каждом последующем запросе, изменённое значение делает недействительным любой префикс кэша, который его содержит. Чтобы сохранить кэширование, задайте бюджет один раз в начальном запросе и позвольте модели ориентироваться на серверный обратный отсчёт, не изменяя бюджет на стороне клиента.

## Поддержка функции

| Модель            | Поддержка                                             |
| ----------------- | ----------------------------------------------------- |
| Claude Fable 5.1  | Бета (установите заголовок `task-budgets-2026-03-13`) |
| Claude Mythos 5.1 | Бета (установите заголовок `task-budgets-2026-03-13`) |
| Claude Opus 5.5   | Бета (установите заголовок `task-budgets-2026-03-13`) |
| Claude Opus 5     | Бета (установите заголовок `task-budgets-2026-03-13`) |
| Claude Fable 5    | Бета (установите заголовок `task-budgets-2026-03-13`) |
| Claude Mythos 5   | Бета (установите заголовок `task-budgets-2026-03-13`) |
| Claude Sonnet 5.5 | Бета (установите заголовок `task-budgets-2026-03-13`) |
| Claude Sonnet 5   | Не поддерживается                                     |
| Claude Haiku 5.5  | Бета (установите заголовок `task-budgets-2026-03-13`) |
| Claude Opus 4.8   | Бета (установите заголовок `task-budgets-2026-03-13`) |
| Claude Opus 4.7   | Бета (установите заголовок `task-budgets-2026-03-13`) |
| Claude Opus 4.6   | Не поддерживается                                     |
| Claude Sonnet 4.6 | Не поддерживается                                     |
| Claude Haiku 4.5  | Не поддерживается                                     |

Бюджеты задач не поддерживаются в [Claude Code](https://code.claude.com/docs/ru/overview) и Cowork. Используйте бюджеты задач напрямую через Messages API на [поддерживаемой модели](https://platform.claude.com/docs/ru/build-with-claude/task-budgets#feature-support).

## Следующие шаги

<CardGroup>
  <Card title="Effort" icon="gauge" href="https://platform.claude.com/docs/ru/build-with-claude/effort">
    Управляйте тем, насколько тщательно Claude рассуждает на каждом шаге агентного цикла.
  </Card>

  <Card title="Адаптивные размышления" icon="brain" href="https://platform.claude.com/docs/ru/build-with-claude/thinking">
    Позвольте Claude определять, когда и в каком объёме использовать расширенные размышления.
  </Card>

  <Card title="Компактизация" icon="arrows-clockwise" href="https://platform.claude.com/docs/ru/build-with-claude/compaction">
    Управляйте контекстом в длительных разговорах с помощью серверной компактизации.
  </Card>

  <Card title="Кэширование подсказок" icon="database" href="https://platform.claude.com/docs/ru/build-with-claude/prompt-caching">
    Снижайте стоимость и задержку для повторяющихся подсказок за счёт кэширования префиксов подсказок.
  </Card>
</CardGroup>