---
title: タスクバジェット
url: https://platform.claude.com/docs/ja/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が次の人間の応答を待つために出力を確定する前に、複数のツール呼び出しと判断を行うエージェントワークフローで最も効果を発揮します。次のような場合に使用してください。

* 長期的なタスクにおいて、Claudeにトークン消費を自己調整させたい場合。
* タスクごとに予測可能なコストまたはレイテンシの上限を適用したい場合。
* バジェットに近づいたときに、アクションの途中で打ち切るのではなく、モデルに適切に終了させたい場合（調査結果の要約、進捗の報告など）。

タスクバジェットは[effortパラメータ](https://platform.claude.com/docs/ja/build-with-claude/effort)を補完します。effortはClaudeが各ステップについてどれだけ徹底的に推論するかを制御し、タスクバジェットはエージェントループ全体でClaudeが実行できる作業の総量に上限を設けます。

## タスクバジェットの設定

`output_config`に`task_budget`を追加し、ベータヘッダーを含めます。

<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`オブジェクトには3つのフィールドがあります。

* `type`：常に`"tokens"`です。
* `total`：思考、ツール呼び出し、ツール結果、出力を含め、エージェントループ全体でClaudeが使用できるトークン数です。
* `remaining`（オプション）：前のリクエストから引き継がれたバジェットの残量です。省略した場合は`total`がデフォルトになります。

## バジェットのカウントダウンの仕組み

Claudeは、会話全体を通じてサーバー側で挿入されるバジェットカウントダウンマーカーを確認します。このマーカーは現在のエージェントループに残っているトークン数を示し、モデルが思考、ツール呼び出し、出力を生成するたびに、またツール結果を処理するたびに更新されます。Claudeはこのシグナルを使ってペースを調整し、バジェットが消費されるにつれて適切に作業を終えます。

<Note>
  **カウントダウンはモデルにのみ表示されます。** APIレスポンスには残りバジェットのフィールドは含まれません。レスポンスの`usage`オブジェクトには`task_budget`の情報はなく、SDKにもそのためのアクセサはありません。クライアント側で消費量を追跡するには、[現在の使用量を測定する](https://platform.claude.com/docs/ja/build-with-claude/task-budgets#measure-your-current-usage)に示すようにループ内のリクエスト全体のトークン使用量を合計するか、[コンパクションをまたいでバジェットを引き継ぐ](https://platform.claude.com/docs/ja/build-with-claude/task-budgets#carrying-a-budget-across-compaction-with-remaining)場合に`remaining`で独自の値を渡してください。
</Note>

<Warning>
  **カウントダウンは、現在のエージェントループでClaudeが処理したトークンを反映するものであり、リクエスト間で再送信するトークンではありません。** クライアントがフォローアップリクエストのたびに会話履歴全体を送信する場合、クライアント側のトークン数はClaudeが追跡しているバジェットと異なる可能性があります。履歴全体を再送信しながら`remaining`も減算すると、モデルには実際より少ないバジェットが伝わり、カウントダウンが本来より速く減少するため、Claudeはバジェットが実際に許容するよりも早く作業を切り上げてしまいます。クライアント側でカウントダウンを再現しようとするのではなく、十分なバジェットを設定し、モデルにカウントダウンに基づいて自己調整させてください。
</Warning>

### ターンとしてカウントされるもの

予算は1つのエージェントターン（エージェントループとも呼ばれます）を対象とします。これは、ツール結果を含まない1つのユーザーメッセージに応答してClaudeが行うすべての処理です。1つのターンは複数のリクエストにまたがることがあります。

ツール結果を含まないユーザーメッセージは、新しい予算で新しいターンを開始します。現時点では、以前のターンの履歴がコンテキストに残っている間は、カウントダウンはその履歴も引き続きカウントします。よくあるケースは、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." }
  ]
}
```

ターン中のサーバー側の[「compaction」（コンパクション）](https://platform.claude.com/docs/ja/build-with-claude/compaction-threshold)はバジェットをリセットしません。コンパクション前にそのターンで消費されたトークンは、引き続きバジェットに対してカウントされます。ターン開始前のトークンは、ターン開始時のコンパクションでそれらが要約された場合でもカウントされません。現時点では、この除外はサーバー側のコンパクションをまたいで引き継がれるバジェットにのみ適用されます。以前のターンの履歴は、コンテキストに残っている間は引き続きカウントされます。

### 具体例：リクエスト間での予算のカウント

タスク予算は、リクエストのペイロードに含まれるものではなく、Claudeが**見る**もの（思考、ツール呼び出しと結果、テキスト）をカウントします。エージェントループでは、クライアントがリクエストのたびに会話全体を再送信するためペイロードは増え続けますが、予算は新しい分だけ、つまりClaudeが生成するトークンと、Claudeがまだ見ていないコンテンツの分だけ減少します。次の例は、3つのリクエストで構成される1つの[エージェントターン](https://platform.claude.com/docs/ja/build-with-claude/task-budgets#what-counts-as-a-turn)です。最初のリクエストはユーザーメッセージを含み、続く2つのリクエストはそれぞれツール結果を追加した履歴を再送信します。

`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は思考と2回目のツール呼び出し（`grep -rn "eval(" src/`）にさらに4,000トークンを使用します。カウントダウンは`remaining` ≈ 88,200付近で終わります。

**リクエスト3。** 2回目のツール結果（1,200トークンのgrep出力）を追加した履歴全体を再度送信します。Claudeは6,000トークンの最終的な調査結果レポートを書き、`stop_reason: "end_turn"`で停止します。`remaining` ≈ 81,000です。

3つのリクエストを並べると、ペイロードサイズと予算消費の違いが明確になります。

| リクエスト  | リクエストペイロード（送信した入力トークンの概算）    | このリクエストで予算に対してカウントされたトークン               | 処理後の予算`remaining` |
| ------ | ---------------------------- | --------------------------------------- | ----------------- |
| 1      | 約20                          | 5,000（思考 + `tool_use`）                  | 約95,000           |
| 2      | 約7,800（リクエスト1のメッセージ + ツール結果） | 6,800（ツール結果2,800 + 思考と`tool_use` 4,000） | 約88,200           |
| 3      | 約13,000（履歴全体 + 2回目のツール結果）    | 7,200（ツール結果1,200 + `text` 6,000）        | 約81,000           |
| **合計** | **リクエスト全体で約20,820を送信**       | **予算に対して19,000をカウント**                   | 該当なし              |

クライアントは元のユーザーメッセージを3回、最初のアシスタントメッセージを2回送信しましたが、それぞれ1回だけカウントされました。クライアントが送信したペイロードの累計はこれより大きく、リクエスト2と3でプロンプトキャッシングされた入力はさらに大きかったにもかかわらず、予算は100,000トークンのうち19,000トークンしか消費していません。

### `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/ja/build-with-claude/task-budgets#measure-your-current-usage)と同じ方法で測定します。追加した要約を含め、送信するメッセージにまだ残っているものは除外してください。それらのトークンはサーバー自身がカウントするためです。この値は、このように履歴を置き換えたときにのみ更新し、リクエストごとに減算しないでください。得られた`remaining`は、コンパクションを行うリクエストだけでなく、すべてのリクエストで渡してください。

リクエストのたびにコンパクションされていない履歴全体を再送信するループでは、`remaining`を省略し、サーバーにカウントダウンを追跡させてください。

## 会話の途中でバジェットを変更する

`task_budget`はリクエストレベルの設定です。タスクの途中でバジェットを変更するには（たとえば、ユーザーがリクエストの範囲を広げたときに延長するなど）、次のリクエストの`output_config`に新しい`task_budget`を設定します。キャッシングへの影響に注意してください。バジェットの値はレンダリングされたプロンプトに含まれるため、変更された値は古い値で作成されたキャッシュエントリと一致しません（下記の[機能サポート](https://platform.claude.com/docs/ja/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`は個々のリクエストに上限を設けるため、2つの値は独立しています。一方が他方以下である必要はありません。

<Warning>
  **タスクに対して小さすぎるバジェットは、拒否のような動作を引き起こす可能性があります。** 求められている作業に対して明らかに不十分なバジェット（たとえば、数時間かかるエージェントコーディングタスクに対して20,000トークンのバジェット）をClaudeが見た場合、完了できない作業を開始するのではなく、タスクの試行自体を断ったり、範囲を大幅に縮小したり、部分的な結果で早期に停止したりすることがあります。バジェットを設定した後に予期しない拒否や早期停止が見られた場合は、他のパラメータをデバッグする前にバジェットを引き上げてください。固定のデフォルト値ではなく、実際のタスク長の分布に基づいてバジェットのサイズを決めてください。[バジェットの選択](https://platform.claude.com/docs/ja/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/ja/build-with-claude/task-budgets#feature-support)を参照）。これより小さい値を指定すると400エラーが返されます。

## 他のパラメータとの相互作用

* **`max_tokens`：** タスク予算とは独立しています。`max_tokens`は生成トークンに対するリクエストごとの厳密な上限であり、`task_budget`はエージェントループ全体（多数のリクエストにまたがる可能性があります）に対する助言的な上限です。`xhigh`または`max`のeffortでは、各リクエストでClaudeが思考し行動する余地を確保するため、`max_tokens`を64k以上に設定してください。
* **[Effort](https://platform.claude.com/docs/ja/build-with-claude/effort)：** effortは、Claudeがステップごとにどれだけ深く推論するかを制御します。タスク予算は、エージェントループ全体でClaudeが行う作業の総量を制御します。この2つは補完的であり、effortは深さを、タスク予算は幅を調整します。
* **[適応型思考](https://platform.claude.com/docs/ja/build-with-claude/thinking)：** タスク予算は思考トークンもカウントに含めるため、予算が減るにつれて「adaptive thinking」（適応型思考）の量も縮小されます。
* **[プロンプトキャッシング](https://platform.claude.com/docs/ja/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/ja/overview)やCoworkのサーフェスではサポートされていません。[サポートされているモデル](https://platform.claude.com/docs/ja/build-with-claude/task-budgets#feature-support)でMessages APIを通じて直接タスクバジェットを使用してください。

## 次のステップ

<CardGroup>
  <Card title="Effort" icon="gauge" href="https://platform.claude.com/docs/ja/build-with-claude/effort">
    エージェントループの各ステップについて、Claudeがどれだけ徹底的に推論するかを制御します。
  </Card>

  <Card title="適応型思考" icon="brain" href="https://platform.claude.com/docs/ja/build-with-claude/thinking">
    拡張思考をいつ、どの程度使用するかをClaudeに判断させます。
  </Card>

  <Card title="コンパクション" icon="arrows-clockwise" href="https://platform.claude.com/docs/ja/build-with-claude/compaction">
    サーバー側のコンパクションで、長時間実行される会話のコンテキストを管理します。
  </Card>

  <Card title="プロンプトキャッシング" icon="database" href="https://platform.claude.com/docs/ja/build-with-claude/prompt-caching">
    プロンプトのプレフィックスをキャッシュすることで、繰り返されるプロンプトのコストとレイテンシを削減します。
  </Card>
</CardGroup>