---
title: Pemikiran diperpanjang
url: https://platform.claude.com/docs/id/build-with-claude/extended-thinking
description: Konfigurasikan pemikiran diperpanjang manual dengan anggaran budget_tokens tetap pada model Claude yang mendukungnya, lalu bermigrasi ke pemikiran adaptif.
featureMetadata:
  supportedModels:
    - claude-mythos-preview
    - claude-haiku-4-5-20251001
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: stable
    Amazon Bedrock: stable
    Amazon Bedrock (bedrock-runtime): stable
    Claude Platform on AWS: stable
    Claude Models on Google Cloud (Anthropic managed): stable
    Claude Models on Google Cloud (Google managed): stable
    Microsoft Foundry: stable
---

<Warning>
  Pemikiran diperpanjang adalah fitur lama.

  Pemikiran diperpanjang (`thinking.type: "enabled"` dengan `budget_tokens`) sudah deprecated. Model Claude 4.7 dan yang lebih baru tidak mendukungnya dan menolak permintaan yang menggunakannya dengan mengembalikan error 400.

  * Alternatif yang direkomendasikan: [Pemikiran adaptif](https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost)
  * Panduan migrasi: [Bermigrasi ke pemikiran adaptif](https://platform.claude.com/docs/id/build-with-claude/extended-thinking#migrating-to-adaptive-thinking)
</Warning>

“Extended thinking” (pemikiran diperpanjang) dalam mode manual memberi Anda kendali langsung atas seberapa banyak Claude berpikir. Anda menetapkan anggaran token pemikiran pada setiap permintaan dengan `thinking: {type: "enabled", budget_tokens: N}`, dan Claude berpikir dalam batas anggaran tersebut sebelum mulai menyusun jawaban akhirnya. Mode manual tetap berguna ketika beban kerja Anda memerlukan “latency” (latensi) yang dapat diprediksi atau kendali yang presisi atas biaya pemikiran. Halaman ini membahas cara menetapkan dan menyetel anggaran, interaksi mode manual dengan “interleaved thinking” (pemikiran berselang-seling) dan “prompt caching” (caching prompt), serta cara bermigrasi ke “adaptive thinking” (pemikiran adaptif).

Untuk mempelajari cara kerja pemikiran itu sendiri, termasuk blok pemikiran dan bentuk respons, parameter `display`, streaming, pemikiran dengan “tool use” (penggunaan alat), dan enkripsi, lihat [Pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking).

## Model yang didukung

Ketersediaan pemikiran diperpanjang untuk setiap model, termasuk model yang hanya memiliki mode pemikiran diperpanjang, tercantum dalam [tabel konfigurasi per model](https://platform.claude.com/docs/id/build-with-claude/thinking-troubleshooting#supported-models).

## Cara menggunakan pemikiran diperpanjang

Berikut adalah contoh penggunaan pemikiran diperpanjang di Messages API:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-sonnet-4-6",
      "max_tokens": 16000,
      "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
      },
      "messages": [
        {
          "role": "user",
          "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?"
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create --format yaml <<'YAML'
  model: claude-sonnet-4-6
  max_tokens: 16000
  thinking:
    type: enabled
    budget_tokens: 10000
  messages:
    - role: user
      content: Are there an infinite number of prime numbers such that n mod 4 == 3?
  YAML
  ```

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

  response = client.messages.create(
      model="claude-sonnet-4-6",
      max_tokens=16000,
      thinking={"type": "enabled", "budget_tokens": 10000},
      messages=[
          {
              "role": "user",
              "content": "Are there an infinite number of prime numbers such that n mod 4 == 3?",
          }
      ],
  )

  # Respons berisi blok pemikiran yang diringkas dan blok teks
  for block in response.content:
      match block.type:
          case "thinking":
              print(f"\nThinking summary: {block.thinking}")
          case "text":
              print(f"\nResponse: {block.text}")
  ```

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

  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 16000,
    thinking: {
      type: "enabled",
      budget_tokens: 10000
    },
    messages: [
      {
        role: "user",
        content: "Are there an infinite number of prime numbers such that n mod 4 == 3?"
      }
    ]
  });

  // Respons berisi blok pemikiran yang diringkas dan blok teks
  for (const block of response.content) {
    switch (block.type) {
      case "thinking":
        console.log(`\nThinking summary: ${block.thinking}`);
        break;
      case "text":
        console.log(`\nResponse: ${block.text}`);
        break;
    }
  }
  ```

  ```csharp C#
  AnthropicClient client = new();

  var response = await client.Messages.Create(new()
  {
      Model = Model.ClaudeSonnet4_6,
      MaxTokens = 16000,
      Thinking = new ThinkingConfigEnabled(budgetTokens: 10000),
      Messages =
      [
          new UserMessageParam
          {
              Content = "Are there an infinite number of prime numbers such that n mod 4 == 3?",
          },
      ],
  });

  // Respons berisi blok pemikiran yang diringkas dan blok teks
  foreach (var block in response.Content)
  {
      if (block.TryPickThinking(out var thinking))
      {
          Console.WriteLine($"\nThinking summary: {thinking.Thinking}");
      }
      else if (block.TryPickText(out var text))
      {
          Console.WriteLine($"\nResponse: {text.Text}");
      }
  }
  ```

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

  response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeSonnet4_6,
  	MaxTokens: 16000,
  	Thinking:  anthropic.ThinkingConfigParamOfEnabled(10000),
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Are there an infinite number of prime numbers such that n mod 4 == 3?")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }

  // Respons berisi blok pemikiran yang diringkas dan blok teks
  for _, block := range response.Content {
  	switch block := block.AsAny().(type) {
  	case anthropic.ThinkingBlock:
  		fmt.Printf("\nThinking summary: %s", block.Thinking)
  	case anthropic.TextBlock:
  		fmt.Printf("\nResponse: %s", block.Text)
  	}
  }
  ```

  ```java Java
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.models.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

  void main() {
      var client = AnthropicOkHttpClient.fromEnv();

      var params = MessageCreateParams.builder()
          .model(Model.CLAUDE_SONNET_4_6)
          .maxTokens(16_000)
          .enabledThinking(10_000)
          .addUserMessage("Are there an infinite number of prime numbers such that n mod 4 == 3?")
          .build();

      var response = client.messages().create(params);

      // Respons berisi blok pemikiran yang diringkas dan blok teks
      for (var block : response.content()) {
          block.thinking().ifPresent(thinkingBlock ->
              IO.println("\nThinking summary: " + thinkingBlock.thinking())
          );
          block.text().ifPresent(textBlock ->
              IO.println("\nResponse: " + textBlock.text())
          );
      }
  }
  ```

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

  $response = $client->messages->create(
      model: 'claude-sonnet-4-6',
      maxTokens: 16000,
      thinking: ['type' => 'enabled', 'budget_tokens' => 10000],
      messages: [
          [
              'role' => 'user',
              'content' => 'Are there an infinite number of prime numbers such that n mod 4 == 3?',
          ],
      ],
  );

  // Respons berisi blok pemikiran yang diringkas dan blok teks
  foreach ($response->content as $block) {
      echo match (true) {
          $block instanceof \Anthropic\Messages\ThinkingBlock => "\nThinking summary: {$block->thinking}",
          $block instanceof \Anthropic\Messages\TextBlock => "\nResponse: {$block->text}",
          default => '',
      };
  }
  ```

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

  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_SONNET_4_6,
    max_tokens: 16_000,
    thinking: {
      type: :enabled,
      budget_tokens: 10_000
    },
    messages: [
      {
        role: :user,
        content: "Are there an infinite number of prime numbers such that n mod 4 == 3?"
      }
    ]
  )

  # Respons berisi blok pemikiran yang diringkas dan blok teks
  response.content.each do |block|
    case block
    when Anthropic::Models::ThinkingBlock
      puts "\nThinking summary: #{block.thinking}"
    when Anthropic::Models::TextBlock
      puts "\nResponse: #{block.text}"
    end
  end
  ```
</CodeGroup>

Untuk mengaktifkan pemikiran diperpanjang manual, tambahkan objek `thinking` dengan `type` bernilai `enabled` beserta nilai `budget_tokens`.

Parameter `budget_tokens` menetapkan target berapa banyak token yang dapat digunakan Claude untuk proses penalaran internalnya. Anggaran yang lebih besar dapat meningkatkan kualitas respons dengan memungkinkan analisis yang lebih menyeluruh untuk masalah yang kompleks.

## Aturan dan penyetelan anggaran

`budget_tokens` harus memenuhi batasan berikut:

* **Minimal 1.024 token.** API menolak nilai yang lebih kecil.
* **Kurang dari `max_tokens`.** Token pemikiran dihitung terhadap batas `max_tokens` untuk giliran tersebut, sehingga anggaran harus menyisakan ruang untuk respons akhir. Satu-satunya pengecualian adalah [pemikiran berselang-seling dalam mode manual](https://platform.claude.com/docs/id/build-with-claude/extended-thinking#interleaved-thinking), di mana `budget_tokens` dapat melebihi `max_tokens` karena anggaran mencakup semua blok pemikiran dalam satu giliran asisten.
* **Tanpa pre-warming cache.** Karena `budget_tokens` harus kurang dari `max_tokens`, pemikiran diperpanjang tidak dapat digabungkan dengan `max_tokens: 0` ([pre-warming cache](https://platform.claude.com/docs/id/build-with-claude/prompt-caching#pre-warming-the-cache)).

Anggaran adalah target, bukan batas ketat. Penggunaan token aktual bervariasi tergantung tugas, dan Claude mungkin berhenti bernalar jauh sebelum anggaran habis; `max_tokens` tetap menjadi batas atas mutlak untuk total output.

Pada Claude Opus 4.5, satu-satunya model yang hanya mendukung pemikiran diperpanjang yang mendukung [effort](https://platform.claude.com/docs/id/build-with-claude/effort), effort membentuk respons secara keseluruhan sedangkan `budget_tokens` menetapkan kedalaman pemikiran; atur keduanya.

Untuk menyetel anggaran:

* Sesuaikan titik awal dengan tugas. Untuk tugas sederhana, mulailah mendekati minimum 1.024 token dan tingkatkan secara bertahap untuk menemukan rentang optimal bagi kasus penggunaan Anda. Untuk tugas kompleks, mulailah dengan anggaran yang lebih besar yaitu 16.000 token atau lebih dan sesuaikan dengan kebutuhan latensi dan kualitas Anda. Anggaran yang lebih tinggi memungkinkan penalaran yang lebih komprehensif, dengan hasil yang semakin berkurang tergantung pada tugas, dan dengan biaya berupa latensi yang meningkat. Untuk tugas penting, uji berbagai pengaturan untuk menemukan keseimbangan yang tepat.
* Untuk anggaran pemikiran di atas 32k, gunakan [pemrosesan batch](https://platform.claude.com/docs/id/build-with-claude/batch-processing) untuk menghindari masalah jaringan. Mendorong model berpikir melebihi 32k token menghasilkan permintaan yang berjalan lama, yang dapat terkena timeout sistem dan batas koneksi terbuka.

Untuk melacak biaya sebenarnya dari suatu anggaran, pantau field `usage.output_tokens_details.thinking_tokens` dalam respons. Field ini melaporkan berapa banyak token output yang ditagih yang merupakan penalaran internal. Saat streaming, rincian ini hanya muncul pada event `message_delta` terakhir.

Jika Anda siap meninggalkan anggaran manual, lihat [Bermigrasi ke pemikiran adaptif](https://platform.claude.com/docs/id/build-with-claude/extended-thinking#migrating-to-adaptive-thinking).

## Pemikiran berselang-seling dalam mode manual

“Interleaved thinking” (pemikiran berselang-seling) memungkinkan Claude berpikir di antara pemanggilan alat dalam satu giliran asisten, bernalar tentang setiap hasil alat sebelum menentukan apa yang harus dilakukan selanjutnya. Untuk konsepnya, struktur giliran, dan perilakunya pada model pemikiran adaptif, lihat [pemikiran berselang-seling](https://platform.claude.com/docs/id/build-with-claude/thinking#interleaved-thinking) dalam ikhtisar pemikiran. Bagian ini membahas cara mengaktifkannya saat Anda menggunakan pemikiran manual `type: "enabled"`.

Pada Claude Opus 4.5, Claude Sonnet 4.5 (deprecated), dan model Claude 4 sebelumnya, tambahkan [header beta](https://platform.claude.com/docs/id/api/beta-headers) `interleaved-thinking-2025-05-14` ke permintaan API Anda.

Generasi 4.6 berperilaku berbeda dalam mode manual:

* **Claude Sonnet 4.6**: header beta dengan `type: "enabled"` manual masih berfungsi tetapi sudah deprecated. Utamakan [pemikiran adaptif](https://platform.claude.com/docs/id/build-with-claude/thinking), yang berselang-seling secara otomatis tanpa header.
* **Claude Opus 4.6**: mode manual sama sekali tidak memiliki pemikiran berselang-seling. Hanya mode adaptifnya yang berselang-seling, jadi beralihlah ke `thinking: {type: "adaptive"}` jika Anda memerlukan penalaran di antara pemanggilan alat pada model ini.

Claude Haiku 4.5 tidak mendukung pemikiran berselang-seling. Pada Claude API, header beta diterima tetapi diabaikan.

Dua pertimbangan lain untuk pemikiran berselang-seling dalam mode manual:

* `budget_tokens` dapat melebihi `max_tokens` di sini; [aturan anggaran](https://platform.claude.com/docs/id/build-with-claude/extended-thinking#budget-rules-and-tuning) menjelaskan pengecualian ini.
* Pemikiran berselang-seling hanya didukung untuk [alat yang digunakan melalui Messages API](https://platform.claude.com/docs/id/agents-and-tools/tool-use/overview).

Cara platform memperlakukan header beta berbeda-beda. Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/id/build-with-claude/claude-platform-on-aws), dan [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/id/build-with-claude/claude-models-on-google-cloud/anthropic-managed) menerima `interleaved-thinking-2025-05-14` pada model apa pun dan mengabaikannya jika tidak didukung. Diterima tidak sama dengan berefek: pada model yang menolak `type: "enabled"` (4.7 dan yang lebih baru) atau tidak memiliki interleaving mode manual (Claude Opus 4.6), header tersebut tidak memiliki efek mode manual; pemikiran adaptif melakukan interleaving secara otomatis di sana.

Platform yang dioperasikan mitra, [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/id/build-with-claude/claude-models-on-google-cloud/google-managed) dan [Amazon Bedrock (`bedrock-mantle`)](https://platform.claude.com/docs/id/build-with-claude/claude-in-amazon-bedrock), menerima header tersebut pada model apa pun tanpa mengembalikan error, dan mengabaikannya pada model yang tidak mendukung pemikiran berselang-seling.

## Struktur giliran dalam mode manual

Aturan umum struktur giliran, termasuk loop penggunaan alat dalam satu giliran, penanganan konflik di tengah giliran, dan pengaktifan atau penonaktifan pemikiran di antara giliran, dijelaskan di [Pemikiran dengan penggunaan alat](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-with-tool-use).

Mode manual menambahkan satu persyaratan: giliran asisten terakhir dari permintaan dengan pemikiran aktif harus dimulai dengan blok pemikiran ([pemikiran adaptif](https://platform.claude.com/docs/id/build-with-claude/thinking) menghapus persyaratan tersebut). Mengubah konfigurasi pemikiran di antara giliran juga membatalkan caching prompt; lihat bagian berikut.

## Caching prompt dalam mode manual

Mode manual menambahkan satu aturan di atas perilaku caching yang berlaku untuk semua mode, seperti dijelaskan di [pemikiran dan caching prompt](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-and-prompt-caching). Mengubah `budget_tokens` di antara permintaan membatalkan breakpoint cache, sama seperti beralih mode pemikiran, karena nilai anggaran dirender ke dalam prompt. Breakpoint tingkat pesan selalu meleset setelah anggaran berubah. Apakah breakpoint alat dan prompt sistem juga meleset bergantung pada tempat model merender konfigurasi tersebut.

Dalam praktiknya, pilih satu anggaran dan pertahankan selama percakapan yang di-cache berlangsung. Contoh berikut menunjukkan pembatalan cache secara langsung: percakapan multi-giliran dengan caching tingkat pesan dijalankan pada Claude Sonnet 4.6, lalu anggaran pada permintaan ketiga diubah dari 4.000 menjadi 8.000 token:

```text Output wrap
First request - establishing cache
First response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Second request - same thinking parameters (cache hit expected)
Second response usage: { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Third request - different thinking budget (cache miss expected)
Third response usage: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }
```

Permintaan ketiga membuat ulang cache (`cache_creation_input_tokens=1370`, `cache_read_input_tokens=0`) karena anggaran berubah di antara permintaan. Untuk versi yang dapat dijalankan dari eksperimen yang sama dalam mode adaptif, di mana tingkat effort memainkan peran cache yang dimainkan `budget_tokens` di sini, lihat [Caching prompt](https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost#prompt-caching) di halaman pengarahan.

## Mekanisme bersama

Sebagian besar perilaku pemikiran berlaku untuk semua mode dan didokumentasikan satu kali di halaman [Pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking). Bagian-bagian berikut juga berlaku dalam mode manual:

* [Mengontrol tampilan pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#controlling-thinking-display)
* [Streaming pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#streaming-thinking)
* [Pemikiran dengan penggunaan alat](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-with-tool-use), termasuk [mempertahankan blok pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#preserving-thinking-blocks)
* [Pemikiran dan caching prompt](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-and-prompt-caching)
* [Pemikiran dan “context window” (jendela konteks)](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-and-the-context-window)
* [Enkripsi pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-encryption)
* [Harga](https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost#pricing) (di halaman [Mengarahkan pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost))

## Bermigrasi ke pemikiran adaptif

Jika model Anda hanya mendukung pemikiran diperpanjang, tidak ada tindakan yang diperlukan. Model-model ini adalah Claude Sonnet 4.5 (deprecated), Claude Opus 4.5, Claude Haiku 4.5, dan model Claude 4 sebelumnya. Pemikiran adaptif tidak tersedia pada model-model tersebut, dan `type: "adaptive"` [mengembalikan error 400](https://platform.claude.com/docs/id/build-with-claude/thinking-troubleshooting#error-thinking-type-adaptive). Pertahankan `budget_tokens` hingga Anda beralih ke model yang mendukung pemikiran adaptif, lalu terapkan pemetaan berikut.

Anda perlu bermigrasi dari `type: "enabled"` jika:

* Anda menggunakan Claude Opus 4.6 atau Claude Sonnet 4.6, di mana `budget_tokens` sudah deprecated.
* Anda menggunakan model bernomor 4.7 atau lebih tinggi, di mana `type: "enabled"` mengembalikan error 400. Contohnya termasuk Claude Opus 5.5, Claude Sonnet 5, Claude Sonnet 5.5, Claude Fable 5.2, Claude Fable 5.1, dan Claude Haiku 5.5.

Pemetaannya sederhana: hapus `budget_tokens`, atur `thinking: {type: "adaptive"}`, dan kendalikan kedalaman penalaran dengan `output_config: {effort: ...}` alih-alih anggaran token.

```json
{
  "model": "claude-sonnet-4-6",
  "max_tokens": 16000,
  "thinking": {
    "type": "enabled",
    "budget_tokens": 10000
  }
}
```

menjadi:

```json
{
  "model": "claude-sonnet-4-6",
  "max_tokens": 16000,
  "thinking": {
    "type": "adaptive"
  },
  "output_config": {
    "effort": "high"
  }
}
```

`effort: "high"` adalah default pada Claude Sonnet 4.6, sehingga menghilangkannya di sini menghasilkan perilaku yang identik; ini hanya ditampilkan untuk menunjukkan di mana kontrol kedalaman berada dalam mode adaptif. Claude Opus 5.5 dan Claude Haiku 5.5 memiliki default `"medium"`, dan model lain yang mendukung effort memiliki default `"high"` (lihat [Tingkat effort](https://platform.claude.com/docs/id/build-with-claude/effort#effort-levels)).

Harapkan perbedaan perilaku, bukan sekadar perubahan sintaks. Dengan anggaran tetap, Claude berpikir pada setiap permintaan. Dengan pemikiran adaptif, Claude menentukan apakah dan seberapa banyak berpikir pada setiap permintaan, dan pada pengaturan [effort](https://platform.claude.com/docs/id/build-with-claude/effort) yang lebih rendah Claude mungkin melewatkan pemikiran sepenuhnya pada input yang mudah. Anda juga dapat menghapus header beta `interleaved-thinking-2025-05-14` setelah bermigrasi: pemikiran adaptif berselang-seling secara otomatis, dan Claude API mengabaikan header tersebut pada model-model ini. Pemeliharaan blok pemikiran juga berubah. Claude Opus 4.5 dan model bernomor 4.6 ke atas mempertahankan blok pemikiran giliran sebelumnya dalam konteks dan menagihnya sebagai input. Claude Sonnet 4.5 (deprecated), Claude Haiku 4.5, dan model sebelumnya menghapusnya. Lihat [pemeliharaan blok pemikiran per model](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-block-preservation-by-model).

Beralih mode merupakan perubahan konfigurasi pemikiran, sehingga permintaan pertama setelah peralihan membatalkan breakpoint cache, seperti yang dijelaskan dalam [Caching prompt dalam mode manual](https://platform.claude.com/docs/id/build-with-claude/extended-thinking#extended-thinking-with-prompt-caching).

Untuk panduan lengkap, lihat [Pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking), [Effort](https://platform.claude.com/docs/id/build-with-claude/effort), dan [Panduan migrasi](https://platform.claude.com/docs/id/about-claude/models/migration-guide).

## Langkah selanjutnya

<CardGroup cols={3}>
  <Card title="Pemikiran" icon="brain" href="https://platform.claude.com/docs/id/build-with-claude/thinking">
    Pelajari cara kerja pemikiran: blok, tampilan, streaming, dan penggunaan alat.
  </Card>

  <Card title="Mengarahkan pemikiran" icon="compass" href="https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost">
    Biarkan Claude menentukan kapan dan seberapa banyak berpikir pada setiap permintaan.
  </Card>

  <Card title="Pemikiran dalam alur kerja alat dan multi-giliran" icon="wrench" href="https://platform.claude.com/docs/id/build-with-claude/thinking-tool-workflows">
    Pertahankan blok pemikiran dan kelola pemikiran di seluruh pemanggilan alat dan giliran.
  </Card>
</CardGroup>

## Ketersediaan

Pemikiran diperpanjang tersedia atau tidak digunakan lagi di model tertentu.

### Dukungan API

#### [Messages API](https://platform.claude.com/docs/id/build-with-claude/working-with-messages)

* Ketersediaan: Tersedia

| Status               | Model                                                                                                                                                                                                                                                                          |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Tersedia             | Claude Mythos Preview, [Claude Haiku 4.5](https://platform.claude.com/docs/id/models/haiku-4-5/overview), [Claude Opus 4.5](https://platform.claude.com/docs/id/models/opus-4-5/overview), [Claude Sonnet 4.5](https://platform.claude.com/docs/id/models/sonnet-4-5/overview) |
| Tidak digunakan lagi | [Claude Opus 4.6](https://platform.claude.com/docs/id/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/id/models/sonnet-4-6/overview)                                                                                                           |

#### [Managed Agents](https://platform.claude.com/docs/id/managed-agents/overview)

* Ketersediaan: Tidak tersedia
* Penggunaan: Pada model Claude 4.5, Managed Agents mengaktifkan sendiri pemikiran manual dengan anggaran tetap yang tidak dapat Anda ubah. Pada model yang lebih baru, Managed Agents menggunakan pemikiran adaptif. Gunakan [Effort](https://platform.claude.com/docs/id/build-with-claude/effort) sebagai gantinya.
