--- title: Pemikiran url: https://platform.claude.com/docs/id/build-with-claude/thinking description: "Pahami cara kerja pemikiran Claude: mengaktifkannya, membaca output pemikiran, mengarahkan kedalaman pemikiran dengan effort, dan menggunakan pemikiran dengan alat, caching, dan streaming." --- Untuk mempelajari bagaimana "zero data retention" (retensi data nol), atau ZDR, berlaku untuk fitur ini, lihat [API dan retensi data](https://platform.claude.com/docs/id/manage-claude/api-and-data-retention). Model yang menjawab dalam satu kali proses harus melakukan semuanya dengan benar pada percobaan pertama: tanpa coretan kerja, tanpa pemeriksaan, dan tanpa mengubah arah di tengah jalan. Untuk sebuah pembuktian, bug yang rumit, atau tugas agentik yang panjang, pendekatan pertama sering kali bukan yang terbaik. "Thinking" (pemikiran) menghilangkan batasan tersebut. Saat pemikiran aktif, Claude menguraikan masalah dengan kata-katanya sendiri sebelum menjawab: ia menyatakan ulang apa yang diminta, mencoba berbagai pendekatan, memeriksa hasil antara, dan meninggalkan jalur yang ternyata tidak tepat. Pemikiran di awal tersebut tiba dalam blok konten `thinking` sebelum respons, dan Claude memanfaatkannya untuk menghasilkan jawaban akhir. Inilah sebabnya pemikiran meningkatkan kinerja pada tugas kompleks seperti matematika, pemrograman, analisis, dan pekerjaan agentik yang berjalan lama, yaitu tugas yang kualitas jawabannya bergantung pada pekerjaan antara yang jika tidak ada pemikiran akan dipadatkan ke dalam respons itu sendiri atau dilewati. Pemikiran memiliki biaya. Token yang dihabiskan Claude untuk bernalar ditagih sebagai token output, bahkan ketika teks pemikiran tidak dikembalikan kepada Anda, dan token tersebut dihitung terhadap `max_tokens` bersama teks respons. Halaman ini membahas perilaku pemikiran di seluruh permukaan API: cara mengaktifkannya, membaca outputnya, dan mengelola interaksinya dengan alat, "streaming" (pengaliran), caching, dan "context window" (jendela konteks). ## Cara kerja pemikiran ![Diagram: Claude menentukan apakah akan berpikir di awal ("up-front thinking" (pemikiran di awal)), dapat berpikir di antara pemanggilan alat ("tool calls" (pemanggilan alat)), dan mengembalikan blok pemikiran ("thinking blocks" (blok pemikiran)) sebelum teks](https://platform.claude.com/docs/id/images/how-thinking-works.svg) Apakah Claude berpikir pada permintaan tertentu, dan seberapa dalam, bergantung pada konfigurasi pemikiran Anda dan kompleksitas permintaan. Berikut tampilan pemikiran di awal dalam sebuah respons: satu atau lebih blok konten `thinking` tiba sebelum blok `text`. Blok pemikiran tetap merupakan konten yang dihasilkan, seperti blok `text` yang mengikutinya, tetapi dipisahkan dari respons kanonis. Setiap blok pemikiran juga membawa field `signature`, salinan terenkripsi dari penalaran lengkap yang Anda kirimkan kembali tanpa perubahan dalam percakapan multi-giliran dan penggunaan alat (lihat [Enkripsi pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-encryption)): ```json { "content": [ { "type": "thinking", "thinking": "Let me break this down. The question has two parts, so I'll start with the simpler one and use its result to constrain the second...", "signature": "WaUjzkypQ2mUEVM36O2Txu...." }, { "type": "text", "text": "Based on my analysis..." } ] } ``` Anda tidak selalu melihat teks ini, dan apa yang Anda lihat tidak pernah berupa rantai pemikiran mentah: teks dalam blok pemikiran adalah [ringkasan penalaran Claude](https://platform.claude.com/docs/id/build-with-claude/thinking#summarized-thinking). Field `display` pada konfigurasi pemikiran mengontrol apakah ringkasan tersebut dikembalikan sama sekali: `"summarized"` mengembalikannya, sedangkan `"omitted"`, default pada banyak model, mengembalikan blok pemikiran dengan field `thinking` yang kosong. Bagaimanapun juga, blok tersebut ditagih sama dan dikirimkan kembali dengan cara yang sama dalam percakapan multi-giliran. Lihat [Mengontrol tampilan pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#controlling-thinking-display) untuk default per model dan detailnya. Jika Claude menggunakan alat, pemikiran juga dapat muncul di antara pemanggilan alat. Lihat [Pemikiran dengan penggunaan alat](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-with-tool-use). Untuk format respons lengkap, lihat [referensi Messages API](https://platform.claude.com/docs/id/api/messages/create). ## Mengonfigurasi pemikiran Pada sebagian besar model, pemikiran aktif secara default atau hanya berjarak satu parameter. Tabel berikut menunjukkan apa yang dilakukan setiap model dengan setiap nilai `thinking` yang dapat dikirim oleh permintaan. Error 400 berarti API menolak permintaan tersebut, dan [Pemecahan masalah pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking-troubleshooting) memuat setiap error beserta perbaikannya. | Model | Tanpa field `thinking` | `"adaptive"` | `"enabled"` dengan `budget_tokens` | `"between_tools"` | `"disabled"` | | --------------------- | ---------------------- | ----------------- | ---------------------------------- | --------------------------------------------------------------- | ------------------------------------------------------- | | Claude Opus 5.5 | Pemikiran adaptif | Pemikiran adaptif | Error 400 | Error 400 | Error 400 | | Claude Sonnet 5.5 | Pemikiran adaptif | Pemikiran adaptif | Error 400 | Pemikiran di awal nonaktif pada effort `high` atau lebih rendah | Error 400 | | Claude Haiku 5.5 | Pemikiran adaptif | Pemikiran adaptif | Error 400 | Error 400 | Pemikiran nonaktif pada effort `high` atau lebih rendah | | Claude Fable 5.1 | Pemikiran adaptif | Pemikiran adaptif | Error 400 | Error 400 | Error 400 | | Claude Mythos 5.1 | Pemikiran adaptif | Pemikiran adaptif | Error 400 | Error 400 | Error 400 | | Claude Fable 5 | Pemikiran adaptif | Pemikiran adaptif | Error 400 | Error 400 | Error 400 | | Claude Mythos 5 | Pemikiran adaptif | Pemikiran adaptif | Error 400 | Error 400 | Error 400 | | Claude Opus 5 | Pemikiran adaptif | Pemikiran adaptif | Error 400 | Error 400 | Pemikiran nonaktif pada effort `high` atau lebih rendah | | Claude Sonnet 5 | Pemikiran adaptif | Pemikiran adaptif | Error 400 | Error 400 | Pemikiran nonaktif | | Claude Opus 4.8 | Pemikiran nonaktif | Pemikiran adaptif | Error 400 | Error 400 | Pemikiran nonaktif | | Claude Opus 4.7 | Pemikiran nonaktif | Pemikiran adaptif | Error 400 | Error 400 | Pemikiran nonaktif | | Claude Mythos Preview | Pemikiran adaptif | Pemikiran adaptif | Pemikiran diperpanjang | Error 400 | Error 400 | | Claude Opus 4.6 | Pemikiran nonaktif | Pemikiran adaptif | Pemikiran diperpanjang (usang) | Error 400 | Pemikiran nonaktif | | Claude Sonnet 4.6 | Pemikiran nonaktif | Pemikiran adaptif | Pemikiran diperpanjang (usang) | Error 400 | Pemikiran nonaktif | | Claude Opus 4.5 | Pemikiran nonaktif | Error 400 | Pemikiran diperpanjang | Error 400 | Pemikiran nonaktif | | Claude Sonnet 4.5 | Pemikiran nonaktif | Error 400 | Pemikiran diperpanjang | Error 400 | Pemikiran nonaktif | | Claude Haiku 4.5 | Pemikiran nonaktif | Error 400 | Pemikiran diperpanjang | Error 400 | Pemikiran nonaktif | Dalam tabel, "pada effort `high` atau lebih rendah" berarti permintaan berfungsi pada effort `low`, `medium`, dan `high` serta mengembalikan error 400 pada `xhigh` atau `max`. Pada Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, Claude Sonnet 5, Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, dan Claude Haiku 5.5, pemikiran sudah aktif dan tidak memerlukan konfigurasi. `display` secara default bernilai `"omitted"` pada model-model ini, sehingga teks pemikiran disembunyikan sampai Anda memilih untuk menampilkannya. Pilih untuk menampilkannya dengan `thinking: {"type": "adaptive", "display": "summarized"}`, seperti yang dilakukan contoh-contoh berikut. Pada Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, dan Claude Sonnet 4.6, pemikiran nonaktif sampai Anda menetapkan `thinking: {type: "adaptive"}`, yang memungkinkan Claude menentukan kapan dan seberapa dalam berpikir berdasarkan permintaan. Permintaan yang sama, dengan [string model](https://platform.claude.com/docs/id/models/overview) yang ditukar, akan mengaktifkannya di sana. Contoh-contoh berikut menetapkan `display: "summarized"` agar teks pemikiran terlihat, dan menggunakan `max_tokens` yang lapang: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 16000, "thinking": { "type": "adaptive", "display": "summarized" }, "messages": [ { "role": "user", "content": "What is the greatest common divisor of 1071 and 462?" } ] }' ``` ```bash CLI ant messages create \ --model claude-opus-5-5 \ --max-tokens 16000 \ --thinking '{type: adaptive, display: summarized}' \ --message '{role: user, content: "What is the greatest common divisor of 1071 and 462?"}' \ --transform content \ --format yaml ``` ```python Python client = anthropic.Anthropic() response = client.messages.create( model="claude-opus-5-5", max_tokens=16000, thinking={"type": "adaptive", "display": "summarized"}, messages=[ { "role": "user", "content": "What is the greatest common divisor of 1071 and 462?", } ], ) for block in response.content: match block.type: case "thinking": print(f"\nThinking: {block.thinking}") case "text": print(f"\nResponse: {block.text}") ``` ```typescript TypeScript const client = new Anthropic(); const response = await client.messages.create({ model: "claude-opus-5-5", max_tokens: 16000, thinking: { type: "adaptive", display: "summarized" }, messages: [ { role: "user", content: "What is the greatest common divisor of 1071 and 462?" } ] }); for (const block of response.content) { switch (block.type) { case "thinking": console.log(`\nThinking: ${block.thinking}`); break; case "text": console.log(`\nResponse: ${block.text}`); break; } } ``` ```csharp C# AnthropicClient client = new(); var parameters = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 16000, Thinking = new ThinkingConfigAdaptive { Display = Display.Summarized }, Messages = [ new() { Role = Role.User, Content = "What is the greatest common divisor of 1071 and 462?" } ] }; var message = await client.Messages.Create(parameters); foreach (var block in message.Content) { if (block.TryPickThinking(out ThinkingBlock? thinking)) { Console.WriteLine($"\nThinking: {thinking.Thinking}"); } else if (block.TryPickText(out TextBlock? text)) { Console.WriteLine($"\nResponse: {text.Text}"); } } ``` ```go Go client := anthropic.NewClient() response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 16000, Thinking: anthropic.ThinkingConfigParamUnion{ OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{ Display: anthropic.ThinkingConfigAdaptiveDisplaySummarized, }, }, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("What is the greatest common divisor of 1071 and 462?")), }, }) if err != nil { log.Fatal(err) } for _, block := range response.Content { switch v := block.AsAny().(type) { case anthropic.ThinkingBlock: fmt.Printf("\nThinking: %s", v.Thinking) case anthropic.TextBlock: fmt.Printf("\nResponse: %s", v.Text) } } ``` ```java Java import com.anthropic.models.messages.ThinkingConfigAdaptive; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(16000L) .thinking(ThinkingConfigAdaptive.builder() .display(ThinkingConfigAdaptive.Display.SUMMARIZED) .build()) .addUserMessage("What is the greatest common divisor of 1071 and 462?") .build(); Message response = client.messages().create(params); response.content().forEach(block -> { block.thinking().ifPresent(thinkingBlock -> IO.println("\nThinking: " + thinkingBlock.thinking()) ); block.text().ifPresent(textBlock -> IO.println("\nResponse: " + textBlock.text()) ); }); } ``` ```php PHP use Anthropic\Messages\TextBlock; use Anthropic\Messages\ThinkingBlock; $client = new Client(); $message = $client->messages->create( maxTokens: 16000, messages: [ [ 'role' => 'user', 'content' => 'What is the greatest common divisor of 1071 and 462?' ] ], model: 'claude-opus-5-5', thinking: ['type' => 'adaptive', 'display' => 'summarized'], ); foreach ($message->content as $block) { switch (true) { case $block instanceof ThinkingBlock: echo "\nThinking: " . $block->thinking; break; case $block instanceof TextBlock: echo "\nResponse: " . $block->text; break; } } ``` ```ruby Ruby client = Anthropic::Client.new message = client.messages.create( model: "claude-opus-5-5", max_tokens: 16000, thinking: { type: "adaptive", # Hash biasa seperti ini menerima display:. Kelas bertipe ThinkingConfigAdaptive # menuliskannya display_ (garis bawah di akhir) agar tidak membayangi Kernel#display milik Ruby. # Permintaan tetap mengirimkan display. display: "summarized" }, messages: [ { role: "user", content: "What is the greatest common divisor of 1071 and 462?" } ] ) message.content.each do |block| case block when Anthropic::Models::ThinkingBlock puts "\nThinking: #{block.thinking}" when Anthropic::Models::TextBlock puts "\nResponse: #{block.text}" end end ``` Menjalankan contoh ini mencetak pemikiran yang diringkas, lalu jawabannya: ```text Output wrap Thinking: Use Euclidean algorithm. 1071 = 2*462 + 147 462 = 3*147 + 21 147 = 7*21 + 0 GCD = 21 Response: ## Finding GCD of 1071 and 462 I'll use the **Euclidean algorithm**, repeatedly dividing and taking remainders... ``` Token pemikiran dihitung terhadap `max_tokens`, jadi tetapkan nilainya cukup tinggi untuk menyisakan ruang bagi pemikiran dan teks respons. Lihat [Kontrol biaya](https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost#cost-control) di halaman pengarahan dan [Pemikiran dan jendela konteks](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-and-the-context-window). ### Menonaktifkan pemikiran Pada Claude Sonnet 5, di mana pemikiran aktif secara default, Anda dapat menonaktifkannya: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-sonnet-5", "max_tokens": 4096, "thinking": {"type": "disabled"}, "messages": [ { "role": "user", "content": "Summarize this article in one sentence." } ] }' ``` ```bash CLI ant messages create \ --model claude-sonnet-5 \ --max-tokens 4096 \ --thinking '{type: disabled}' \ --message '{role: user, content: "Summarize this article in one sentence."}' ``` ```python Python client = anthropic.Anthropic() response = client.messages.create( model="claude-sonnet-5", max_tokens=4096, thinking={"type": "disabled"}, messages=[{"role": "user", "content": "Summarize this article in one sentence."}], ) ``` ```typescript TypeScript const client = new Anthropic(); const response = await client.messages.create({ model: "claude-sonnet-5", max_tokens: 4096, thinking: { type: "disabled" }, messages: [{ role: "user", content: "Summarize this article in one sentence." }] }); ``` ```csharp C# AnthropicClient client = new(); var parameters = new MessageCreateParams { Model = Model.ClaudeSonnet5, MaxTokens = 4096, Thinking = new ThinkingConfigDisabled(), Messages = [ new() { Role = Role.User, Content = "Summarize this article in one sentence." } ] }; var message = await client.Messages.Create(parameters); ``` ```go Go client := anthropic.NewClient() response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeSonnet5, MaxTokens: 4096, Thinking: anthropic.ThinkingConfigParamUnion{ OfDisabled: &anthropic.ThinkingConfigDisabledParam{}, }, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("Summarize this article in one sentence.")), }, }) if err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.messages.ThinkingConfigDisabled; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_SONNET_5) .maxTokens(4096L) .thinking(ThinkingConfigDisabled.builder().build()) .addUserMessage("Summarize this article in one sentence.") .build(); Message response = client.messages().create(params); } ``` ```php PHP $client = new Client(); $message = $client->messages->create( maxTokens: 4096, messages: [ [ 'role' => 'user', 'content' => 'Summarize this article in one sentence.' ] ], model: 'claude-sonnet-5', thinking: ['type' => 'disabled'], ); ``` ```ruby Ruby client = Anthropic::Client.new message = client.messages.create( model: "claude-sonnet-5", max_tokens: 4096, thinking: { type: "disabled" }, messages: [ { role: "user", content: "Summarize this article in one sentence." } ] ) ``` Claude Opus 5 juga memiliki pemikiran yang aktif secara default dan menerima `thinking: {type: "disabled"}` pada [effort](https://platform.claude.com/docs/id/build-with-claude/effort) `high` atau lebih rendah. Pada effort `xhigh` atau `max`, pemikiran tidak dapat dinonaktifkan: permintaan yang menggabungkan `thinking: {type: "disabled"}` dengan tingkat effort tersebut mengembalikan error 400. Pembatasan ini diberlakukan pada setiap permintaan. Dengan pemikiran dinonaktifkan, Claude Opus 5 sesekali dapat mengeluarkan pemanggilan alat sebagai teks biasa atau menyertakan tag XML internal dalam output yang terlihat. Lihat [Menjalankan dengan pemikiran dinonaktifkan](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-opus-5#running-with-thinking-disabled) untuk mitigasi melalui prompting. Claude Sonnet 5.5 juga memiliki pemikiran yang aktif secara default, dan model ini menolak `thinking: {type: "disabled"}` dengan error 400. Untuk menonaktifkan pemikiran di awal, kirimkan `thinking: {type: "between_tools"}` sebagai gantinya. Ini adalah pengaturan pemikiran terendah pada Claude Sonnet 5.5, dan diterima pada [effort](https://platform.claude.com/docs/id/build-with-claude/effort) `high` atau lebih rendah. Model tetap mengembalikan [pembaruan progres di antara pemanggilan alat](https://platform.claude.com/docs/id/build-with-claude/thinking#progress-updates). Tanpa alat, respons hanya berisi teks, seperti halnya `disabled` pada Claude Sonnet 5. Lihat [Menjalankan tanpa pemikiran di awal](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#running-without-up-front-thinking) untuk panduan prompting. Claude Haiku 5.5 juga memiliki pemikiran yang aktif secara default dan menerima `thinking: {type: "disabled"}` pada [effort](https://platform.claude.com/docs/id/build-with-claude/effort) `high` atau lebih rendah. Pada effort `xhigh` atau `max`, kombinasi tersebut mengembalikan error 400. Untuk mendapatkan pemikiran yang lebih sedikit, turunkan tingkat effort terlebih dahulu. Dengan pemikiran nonaktif, model dapat melewatkan pemanggilan alat yang dibutuhkannya ketika Anda juga meminta output JSON. [`output_config.effort` per pesan](https://platform.claude.com/docs/id/build-with-claude/effort#change-effort-mid-conversation-beta) yang berbeda dari tingkat yang sedang berlaku juga mengembalikan error 400 saat pemikiran nonaktif. Lihat [Gunakan effort untuk mengontrol thinking](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking) dan [Gunakan adaptive thinking dengan output JSON dan alat Anda sendiri](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#json-output-with-your-own-tools). Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Opus 5.5, dan Claude Mythos Preview menolak `thinking: {type: "disabled"}`. Pemikiran tidak dapat dinonaktifkan pada model-model ini. Untuk memeriksa apakah suatu model menerima `"disabled"` sebelum Anda mengirim permintaan, baca nilai `capabilities.thinking.types.disabled.supported` dari Models API. [Menggunakan Models API](https://platform.claude.com/docs/id/models/overview#using-the-models-api) menjelaskan field tersebut. Jika model Anda hanya mendukung pemikiran diperpanjang (lihat [tabel konfigurasi per model](https://platform.claude.com/docs/id/build-with-claude/thinking-troubleshooting#supported-models)), konfigurasikan dengan `type: "enabled"` dan nilai `budget_tokens` sebagai gantinya. Halaman [Pemikiran diperpanjang](https://platform.claude.com/docs/id/build-with-claude/extended-thinking) membahas konfigurasi tersebut. Dan jika konfigurasi pemikiran apa pun menghasilkan error 400, [Pemecahan masalah pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking-troubleshooting) mencocokkan setiap pesan error dengan perbaikannya. ## Membaca output pemikiran ### Mengontrol tampilan pemikiran Field `display` pada konfigurasi pemikiran mengontrol bagaimana konten pemikiran dikembalikan dalam respons API. `display` berfungsi di kedua mode: tetapkan bersama `type: "adaptive"` atau `type: "enabled"`. Field ini menerima nilai-nilai berikut: * `"summarized"`: blok pemikiran berisi teks [pemikiran yang diringkas](https://platform.claude.com/docs/id/build-with-claude/thinking#summarized-thinking), ringkasan yang mudah dibaca dari penalaran Claude. Ini adalah default pada Claude Opus 4.6, Claude Sonnet 4.6, dan model-model sebelumnya. * `"omitted"`: blok pemikiran dikembalikan dengan field `thinking` yang kosong. Field `signature` tetap membawa pemikiran lengkap yang terenkripsi untuk kesinambungan multi-giliran (lihat [Enkripsi pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-encryption)). Ini adalah default pada Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, Claude Sonnet 5, Claude Opus 4.8, Claude Opus 4.7, [Claude Mythos Preview](https://anthropic.com/glasswing), dan Claude Haiku 5.5. * `"updates"` (beta): blok penalaran dikembalikan dengan field `thinking` yang kosong, seperti pada `"omitted"`, dan [pembaruan progres](https://platform.claude.com/docs/id/build-with-claude/thinking#progress-updates) singkat yang ditulis beberapa model di antara pemanggilan alat dikembalikan sebagai teks yang dapat dibaca. Memerlukan header beta `thinking-display-updates-2026-08-18`. Tetapkan `display: "omitted"` ketika aplikasi Anda tidak menampilkan konten pemikiran kepada pengguna. Manfaat utamanya adalah waktu hingga token teks pertama yang lebih cepat saat streaming: server sepenuhnya melewatkan streaming token pemikiran dan hanya mengirimkan signature, sehingga respons teks akhir mulai di-stream lebih cepat. Dengan `display: "omitted"`, respons berisi blok `thinking` dengan field `thinking` yang kosong: ```json Output { "content": [ { "type": "thinking", "thinking": "", "signature": "EosnCkYICxIMMb3LzNrMu..." }, { "type": "text", "text": "The answer is 12,231." } ] } ``` Perhatikan hal-hal berikut saat bekerja dengan pemikiran yang dihilangkan: * Anda tetap dikenakan biaya untuk seluruh token pemikiran. Menghilangkan mengurangi latensi, bukan biaya. * Jika Anda mengirimkan kembali blok pemikiran dalam percakapan multi-giliran, kirimkan tanpa perubahan. Server mendekripsi `signature` untuk merekonstruksi pemikiran asli guna penyusunan prompt (lihat [Mempertahankan blok pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#preserving-thinking-blocks)). Teks apa pun yang Anda tempatkan di field `thinking` dari blok yang dihilangkan dan dikirim bolak-balik akan diabaikan. * `display` tidak valid dengan `thinking.type: "disabled"` (tidak ada yang perlu ditampilkan) dan dengan `thinking.type: "between_tools"` (hanya Claude Sonnet 5.5), yang tidak menerima field lain. Dengan `between_tools`, pembaruan progres tetap dikembalikan dengan teks ringkasan, seperti pada `display: "updates"` (lihat [Pembaruan progres](https://platform.claude.com/docs/id/build-with-claude/thinking#progress-updates)). * Saat menggunakan `thinking.type: "adaptive"` dan model melewatkan pemikiran untuk permintaan sederhana, tidak ada blok pemikiran yang dihasilkan terlepas dari nilai `display`. * Saat streaming dengan `display: "omitted"`, tidak ada teks pemikiran yang di-stream. Setiap blok pemikiran men-stream `thinking_delta` dengan string `thinking` kosong, lalu `signature_delta`-nya. Dengan `display: "updates"`, hanya [blok pembaruan progres](https://platform.claude.com/docs/id/build-with-claude/thinking#progress-updates) yang men-stream event `thinking_delta` yang membawa teks. Lihat [Streaming pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#streaming-thinking) untuk urutan event. Field `signature` identik apa pun nilai `display` yang Anda tetapkan. Mengganti nilai `display` di antara giliran dalam sebuah percakapan didukung. ### Pemikiran yang diringkas Ketika `display` bernilai `"summarized"`, teks pemikiran yang Anda terima adalah ringkasan dari seluruh proses pemikiran Claude, bukan rantai pemikiran mentah. Pemikiran yang diringkas memberikan manfaat kecerdasan penuh dari pemikiran sekaligus mencegah penyalahgunaan. Tidak ada pengaturan `display` yang mengembalikan rantai pemikiran mentah. Perhatikan hal-hal berikut saat bekerja dengan pemikiran yang diringkas: * Anda dikenakan biaya untuk seluruh token pemikiran yang dihasilkan oleh permintaan asli, bukan token ringkasan. Jumlah token output yang ditagih tidak sama dengan jumlah token yang Anda lihat dalam respons. * Pada Claude Opus 4.6, Claude Sonnet 4.6, dan model-model sebelumnya, beberapa baris pertama output pemikiran lebih panjang, memberikan penalaran terperinci yang sangat membantu untuk keperluan "prompt engineering" (rekayasa prompt). [Claude Mythos Preview](https://anthropic.com/glasswing) meringkas sejak token pertama, sehingga blok pemikirannya tidak menampilkan pembukaan panjang ini. * Peringkasan mempertahankan gagasan utama dari proses pemikiran Claude dengan tambahan latensi minimal, sehingga ringkasan dapat di-stream saat tiba. * Peringkasan diproses oleh model yang berbeda dari model yang Anda targetkan dalam permintaan Anda. Model pemikiran tidak melihat output yang diringkas. * Seiring upaya Anthropic untuk meningkatkan fitur pemikiran, perilaku peringkasan dapat berubah. Dalam kasus langka di mana Anda memerlukan akses ke output pemikiran lengkap, [hubungi tim penjualan Anthropic](mailto:sales@anthropic.com). Untuk melihat penalaran model, baca blok `thinking` alih-alih meminta penalaran dalam teks respons melalui prompt. Pada Claude Fable 5.1, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, dan Claude Fable 5, permintaan yang mencoba memancing penalaran internal model sebagai bagian dari teks respons dapat ditolak dengan `stop_details.category: "reasoning_extraction"`. Lihat [Kategori penolakan](https://platform.claude.com/docs/id/build-with-claude/refusals-and-fallback#refusal-response) untuk referensi field dan [Simpan penalaran di blok thinking](https://platform.claude.com/docs/id/build-with-claude/refusals-and-fallback#keep-reasoning-in-thinking-blocks) untuk apa yang sebaiknya diminta sebagai gantinya. ### Streaming pemikiran Pemikiran berfungsi dengan [streaming](https://platform.claude.com/docs/id/build-with-claude/streaming). Blok pemikiran di-stream sebagai event `thinking_delta` di dalam event `content_block_delta`, diikuti oleh satu event `signature_delta` tepat sebelum `content_block_stop` dari blok tersebut. Blok teks di-stream setelahnya seperti biasa. ![Diagram urutan event streaming dengan pemikiran: blok pemikiran ("thinking block" (blok pemikiran)) terbuka, delta pemikiran ("thinking deltas" (delta pemikiran)) membawa teks hanya ketika pengaturan display mengembalikan teks (summarized, atau updates untuk blok pembaruan progres), satu delta signature ("signature delta" (delta signature)) menutup blok, lalu delta teks ("text deltas" (delta teks)) di-stream](https://platform.claude.com/docs/id/images/how-thinking-streams.svg) Contoh-contoh berikut men-stream respons dengan pemikiran adaptif, mencetak delta pemikiran dan teks saat tiba: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 16000, "stream": true, "thinking": { "type": "adaptive", "display": "summarized" }, "messages": [ { "role": "user", "content": "What is the greatest common divisor of 1071 and 462?" } ] }' ``` ```bash CLI ant messages create \ --model claude-opus-5-5 \ --max-tokens 16000 \ --thinking '{type: adaptive, display: summarized}' \ --message '{role: user, content: "What is the greatest common divisor of 1071 and 462?"}' \ --stream \ --format jsonl ``` ```python Python client = anthropic.Anthropic() with client.messages.stream( model="claude-opus-5-5", max_tokens=16000, thinking={"type": "adaptive", "display": "summarized"}, messages=[ { "role": "user", "content": "What is the greatest common divisor of 1071 and 462?", } ], ) as stream: for event in stream: match event.type: case "content_block_start": print(f"\nStarting {event.content_block.type} block...") case "content_block_delta": delta = event.delta match delta.type: case "thinking_delta": print(delta.thinking, end="", flush=True) case "text_delta": print(delta.text, end="", flush=True) ``` ```typescript TypeScript const client = new Anthropic(); const stream = client.messages.stream({ model: "claude-opus-5-5", max_tokens: 16000, thinking: { type: "adaptive", display: "summarized" }, messages: [{ role: "user", content: "What is the greatest common divisor of 1071 and 462?" }] }); for await (const event of stream) { switch (event.type) { case "content_block_start": console.log(`\nStarting ${event.content_block.type} block...`); break; case "content_block_delta": switch (event.delta.type) { case "thinking_delta": process.stdout.write(event.delta.thinking); break; case "text_delta": process.stdout.write(event.delta.text); break; } break; } } ``` ```csharp C# AnthropicClient client = new(); var parameters = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 16000, Thinking = new ThinkingConfigAdaptive { Display = Display.Summarized }, Messages = [new() { Role = Role.User, Content = "What is the greatest common divisor of 1071 and 462?" }] }; await foreach (var rawEvent in client.Messages.CreateStreaming(parameters)) { if (rawEvent.TryPickContentBlockStart(out var start)) { Console.WriteLine($"\nStarting {start.ContentBlock.Type} block..."); } else if (rawEvent.TryPickContentBlockDelta(out var delta)) { if (delta.Delta.TryPickThinking(out var thinkingDelta)) { Console.Write(thinkingDelta.Thinking); } else if (delta.Delta.TryPickText(out var textDelta)) { Console.Write(textDelta.Text); } } } ``` ```go Go client := anthropic.NewClient() stream := client.Messages.NewStreaming(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 16000, Thinking: anthropic.ThinkingConfigParamUnion{ OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{ Display: anthropic.ThinkingConfigAdaptiveDisplaySummarized, }, }, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("What is the greatest common divisor of 1071 and 462?")), }, }) for stream.Next() { event := stream.Current() switch eventVariant := event.AsAny().(type) { case anthropic.ContentBlockStartEvent: fmt.Printf("\nStarting %s block...\n", eventVariant.ContentBlock.Type) case anthropic.ContentBlockDeltaEvent: switch deltaVariant := eventVariant.Delta.AsAny().(type) { case anthropic.ThinkingDelta: fmt.Print(deltaVariant.Thinking) case anthropic.TextDelta: fmt.Print(deltaVariant.Text) } } } if err := stream.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.messages.ThinkingConfigAdaptive; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(16000L) .thinking(ThinkingConfigAdaptive.builder() .display(ThinkingConfigAdaptive.Display.SUMMARIZED) .build()) .addUserMessage("What is the greatest common divisor of 1071 and 462?") .build(); try (var streamResponse = client.messages().createStreaming(params)) { streamResponse.stream().forEach(event -> { switch (event.type().value()) { case CONTENT_BLOCK_START -> { var startEvent = event.asContentBlockStart(); var block = startEvent.contentBlock(); switch (block.type().value()) { case THINKING -> IO.println("\nStarting thinking block..."); case TEXT -> IO.println("\nStarting text block..."); } } case CONTENT_BLOCK_DELTA -> { var deltaEvent = event.asContentBlockDelta(); deltaEvent.delta().thinking().ifPresent(td -> IO.print(td.thinking()) ); deltaEvent.delta().text().ifPresent(td -> IO.print(td.text()) ); } } }); } } ``` ```php PHP use Anthropic\Messages\RawContentBlockDeltaEvent; use Anthropic\Messages\RawContentBlockStartEvent; use Anthropic\Messages\TextDelta; use Anthropic\Messages\ThinkingDelta; $client = new Client(); $stream = $client->messages->createStream( maxTokens: 16000, messages: [ ['role' => 'user', 'content' => 'What is the greatest common divisor of 1071 and 462?'] ], model: 'claude-opus-5-5', thinking: ['type' => 'adaptive', 'display' => 'summarized'], ); foreach ($stream as $event) { switch (true) { case $event instanceof RawContentBlockStartEvent: echo "\nStarting {$event->contentBlock->type} block...\n"; break; case $event instanceof RawContentBlockDeltaEvent: switch (true) { case $event->delta instanceof ThinkingDelta: echo $event->delta->thinking; break; case $event->delta instanceof TextDelta: echo $event->delta->text; break; } break; } } ``` ```ruby Ruby client = Anthropic::Client.new stream = client.messages.stream( model: "claude-opus-5-5", max_tokens: 16000, # Hash biasa seperti ini menerima display:. Kelas bertipe ThinkingConfigAdaptive # menuliskannya display_ (garis bawah di akhir) agar tidak membayangi Kernel#display milik Ruby. # Permintaan tetap mengirimkan display. thinking: { type: "adaptive", display: "summarized" }, messages: [ { role: "user", content: "What is the greatest common divisor of 1071 and 462?" } ] ) stream.each do |event| case event when Anthropic::Streaming::ThinkingEvent print event.thinking when Anthropic::Streaming::TextEvent print event.text end end ``` Untuk menyusun kembali blok pemikiran lengkap beserta signature-nya setelah streaming, gunakan helper akumulasi pesan dari SDK Anda, `stream.get_final_message()` (typescript: `stream.finalMessage()`; ruby: `stream.accumulated_message`; csharp: `.Aggregate()`; go: `message.Accumulate(event)`; java, php: `MessageAccumulator`), alih-alih menggabungkan delta sendiri. ```sse Output event: message_start data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-opus-5-5", "stop_reason": null, "stop_sequence": null}} event: content_block_start data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": "", "signature": ""}} event: content_block_delta data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "I need to find the GCD of 1071 and 462 using the Euclidean algorithm.\n\n1071 = 2 × 462 + 147"}} event: content_block_delta data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n462 = 3 × 147 + 21\n147 = 7 × 21 + 0\n\nSo GCD(1071, 462) = 21"}} // Additional thinking deltas... event: content_block_delta data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b..."}} event: content_block_stop data: {"type": "content_block_stop", "index": 0} event: content_block_start data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}} event: content_block_delta data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "The greatest common divisor of 1071 and 462 is **21**."}} // Additional text deltas... event: content_block_stop data: {"type": "content_block_stop", "index": 1} event: message_delta data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}} event: message_stop data: {"type": "message_stop"} ``` Ketika `display: "omitted"` ditetapkan, blok pemikiran terbuka, sebuah `thinking_delta` dengan string `thinking` kosong tiba, satu `signature_delta` menyusul, dan blok ditutup. Streaming teks dimulai segera setelahnya: ```sse Output event: content_block_start data: {"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":"","signature":""}} event: content_block_delta data: {"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":""}} event: content_block_delta data: {"type":"content_block_delta","index":0,"delta":{"type":"signature_delta","signature":"EosnCkYICxIMMb3LzNrMu..."}} event: content_block_stop data: {"type":"content_block_stop","index":0} event: content_block_start data: {"type":"content_block_start","index":1,"content_block":{"type":"text","text":""}} ``` Dengan `display: "updates"` (beta), blok penalaran di-stream seperti pada `"omitted"`. Setiap [blok pembaruan progres](https://platform.claude.com/docs/id/build-with-claude/thinking#progress-updates) men-stream teksnya sebagai event `thinking_delta` sebelum blok `tool_use` yang diperkenalkannya. Jeda beberapa detik sebelum blok pembaruan progres terbuka adalah hal yang normal: ```sse Output event: content_block_start data: {"type":"content_block_start","index":1,"content_block":{"type":"thinking","thinking":"","signature":""}} event: content_block_delta data: {"type":"content_block_delta","index":1,"delta":{"type":"thinking_delta","thinking":"Confirmed the retry path never refreshes the expired token. Editing auth.py to add the refresh call."}} event: content_block_delta data: {"type":"content_block_delta","index":1,"delta":{"type":"signature_delta","signature":"Es8CCkYICxIM..."}} event: content_block_stop data: {"type":"content_block_stop","index":1} event: content_block_start data: {"type":"content_block_start","index":2,"content_block":{"type":"tool_use","id":"toolu_01D7FLrfh4GYq7yT1ULFeyMV","name":"edit_file","input":{}}} ``` Dengan `"updates"`, perlakukan sebuah blok sebagai pembaruan progres segera setelah salah satu event `thinking_delta`-nya membawa teks yang tidak kosong. Saat menggunakan streaming dengan pemikiran diaktifkan, Anda mungkin memperhatikan bahwa teks terkadang tiba dalam potongan yang lebih besar yang bergantian dengan pengiriman token demi token yang lebih kecil. Ini adalah perilaku yang diharapkan, terutama untuk konten pemikiran. Sistem streaming memproses konten dalam batch, yang dapat menunda dan mengelompokkan event streaming ke dalam pola pengiriman "berpotongan" ini. Untuk mekanisme streaming umum, lihat [Streaming Messages](https://platform.claude.com/docs/id/build-with-claude/streaming). ## Pemikiran dan effort Parameter `thinking` mengontrol apakah Claude berpikir dalam [blok thinking](https://platform.claude.com/docs/id/build-with-claude/thinking) sebelum menjawab; parameter `effort` mengontrol seberapa banyak upaya yang Claude curahkan untuk keseluruhan respons, yang dalam mode adaptif mencakup seberapa sering dan seberapa dalam Claude berpikir. Jangan berikan `adaptive` sebagai nilai `effort`: `adaptive` adalah mode berpikir, bukan tingkat upaya. Untuk mempelajari apa yang dilakukan setiap tingkat effort terhadap perilaku pemikiran, lihat [tabel perilaku pemikiran per tingkat](https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost#effort-levels) di halaman [Mengarahkan pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost). Halaman [Effort](https://platform.claude.com/docs/id/build-with-claude/effort) mendokumentasikan parameter itu sendiri, termasuk tingkat mana yang didukung setiap model. Pada Claude Opus 4.5, satu-satunya model khusus pemikiran diperpanjang yang mendukung effort, effort dikombinasikan dengan `budget_tokens`. Lihat [Aturan dan penyetelan anggaran](https://platform.claude.com/docs/id/build-with-claude/extended-thinking#budget-rules-and-tuning). Dengan kedua kontrol dipisahkan seperti ini, pilih yang sesuai dengan tujuan Anda: * **Biaya atau latensi lebih rendah pada beban kerja dengan pemikiran aktif:** turunkan `effort` terlebih dahulu. Ini memperkecil seluruh respons, termasuk pemikiran. * **Claude terlalu jarang atau terlalu dangkal berpikir:** naikkan `effort`, atau lihat [Mengarahkan seberapa sering Claude berpikir](https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost#tuning-thinking-behavior) di halaman pengarahan. * **Anda memerlukan pemikiran sepenuhnya nonaktif:** gunakan `thinking: {type: "disabled"}` pada model yang mengizinkannya (lihat [tabel konfigurasi per model](https://platform.claude.com/docs/id/build-with-claude/thinking-troubleshooting#supported-models)). Claude Sonnet 5.5 menolak `"disabled"`. Pengaturan terendahnya adalah `thinking: {type: "between_tools"}`, yang menonaktifkan pemikiran di awal. * **Anda memerlukan batas atas pengeluaran yang tegas:** gunakan `max_tokens`. Effort adalah panduan lunak. `max_tokens` adalah batas yang ketat. ## Pemikiran dengan penggunaan alat Pemikiran berfungsi bersama ["tool use" (penggunaan alat)](https://platform.claude.com/docs/id/agents-and-tools/tool-use/overview), memungkinkan Claude bernalar dalam memilih alat dan memproses hasil alat. Dua batasan berlaku: 1. **Batasan pilihan alat (mode manual):** penggunaan alat dengan pemikiran diperpanjang manual (`thinking: {type: "enabled"}`) hanya mendukung `tool_choice: {"type": "auto"}` (default) atau `tool_choice: {"type": "none"}`. Menggunakan `tool_choice: {"type": "any"}` atau `tool_choice: {"type": "tool", "name": "..."}` menghasilkan error karena opsi-opsi ini memaksa penggunaan alat, yang tidak kompatibel dengan pemikiran diperpanjang manual. Pemikiran adaptif, termasuk pada model di mana pemikiran aktif secara default, mendukung penggunaan alat yang dipaksakan, kecuali pada Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1, dan Claude Mythos 5.1 (lihat [Prefill respons dan penggunaan alat yang dipaksakan](https://platform.claude.com/docs/id/build-with-claude/thinking#limits-and-feature-compatibility)). Jika penggunaan alat yang dipaksakan diterima, respons dimulai dengan pemanggilan alat dan tidak memiliki blok `thinking`. 2. **Mempertahankan blok pemikiran:** saat Anda mengembalikan hasil alat, Anda harus mengirimkan kembali blok pemikiran dari pesan asisten ke API, lengkap dan tanpa modifikasi. Lihat [Mempertahankan blok pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#preserving-thinking-blocks). **Loop penggunaan alat adalah satu giliran asisten.** Dari perspektif model, giliran asisten tidak selesai sampai Claude menyelesaikan respons lengkapnya, yang dapat mencakup beberapa pemanggilan alat dan hasilnya. Seluruh urutan ini adalah satu giliran asisten: ```text wrap User: "What's the weather in Paris?" Assistant: [thinking] + [tool_use: get_weather] User: [tool_result: "20°C, sunny"] Assistant: [text: "The weather in Paris is 20°C and sunny"] ``` Seluruh giliran berjalan dalam satu mode pemikiran: Anda tidak dapat mengubah pemikiran di tengah giliran, termasuk selama loop penggunaan alat. Dalam mode diperpanjang (manual), API juga mewajibkan bahwa giliran asisten terakhir dari permintaan dengan pemikiran aktif dimulai dengan blok pemikiran. Mode adaptif melonggarkan hal ini: tidak ada giliran asisten yang perlu dimulai dengan blok pemikiran. **Konflik di tengah giliran ditangani dengan baik.** Jika Anda mengubah pemikiran di tengah giliran (misalnya, antara mengirim pemanggilan alat dan mengembalikan hasilnya), API tidak menghasilkan error. Sebaliknya, API secara diam-diam menonaktifkan pemikiran untuk permintaan tersebut. Untuk menjaga kualitas model, API dapat menghapus blok pemikiran yang akan menciptakan struktur giliran yang tidak valid, atau menonaktifkan pemikiran ketika riwayat percakapan tidak kompatibel dengan pemikiran yang diaktifkan. Untuk memastikan apakah pemikiran aktif, periksa keberadaan blok `thinking` dalam respons. **Ubah di antara giliran, bukan di dalamnya.** Rencanakan strategi pemikiran Anda di awal setiap giliran. Selesaikan giliran asisten, lalu ubah konfigurasi pemikiran untuk giliran berikutnya: ```text wrap User: "What's the weather?" Assistant: [tool_use] (thinking disabled) User: [tool_result] Assistant: [text: "It's sunny"] User: "What about tomorrow?" Assistant: [thinking] + [text: "..."] (thinking enabled - new turn) ``` Mengubah mode pemikiran juga membatalkan caching prompt. Lihat [Pemikiran dan caching prompt](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-and-prompt-caching). ### Mempertahankan blok pemikiran Saat Claude memanggil alat, Claude menjeda penyusunan responsnya untuk menunggu informasi eksternal. Saat Anda mengembalikan hasil alat, Claude melanjutkan penyusunan respons yang sama, sehingga penalaran sebelumnya harus tetap tersedia. Kirimkan setiap blok `thinking` kembali ke API secara lengkap dan tanpa modifikasi, bersama blok `tool_use` yang menyertainya. Hal ini penting karena dua alasan: 1. **Kesinambungan penalaran:** blok pemikiran merekam penalaran langkah demi langkah yang menghasilkan permintaan alat. Dengan menyertakannya, Claude dapat melanjutkan penalaran dari titik terakhir. 2. **Pemeliharaan konteks:** dalam struktur API, hasil alat muncul sebagai pesan pengguna, tetapi hasil tersebut merupakan bagian dari satu alur penalaran yang berkesinambungan. Mempertahankan blok pemikiran menjaga alur tersebut di seluruh pemanggilan API. Singkatnya: * **Wajib:** dalam giliran penggunaan alat, kirimkan kembali blok pemikiran. * **Direkomendasikan:** di seluruh giliran, kirimkan kembali semuanya. * **Diizinkan:** di luar penggunaan alat, Anda boleh menghilangkan pemikiran dari giliran sebelumnya. Anda tidak perlu memangkas pemikiran lama sendiri. Kirimkan kembali semua blok pemikiran dalam percakapan multi-giliran, dan API akan memfilternya secara otomatis. API menyimpan blok yang diperlukan untuk mempertahankan penalaran model dan hanya menagih token input untuk blok yang benar-benar ditampilkan kepada Claude. Blok dari giliran sebelumnya yang disimpan bergantung pada model. Lihat [Preservasi blok pemikiran berdasarkan model](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-block-preservation-by-model). Untuk mengganti perilaku default, gunakan [strategi context-editing `clear_thinking_20251015`](https://platform.claude.com/docs/id/build-with-claude/context-editing#thinking-block-clearing). Dalam pesan asisten terbaru, urutan blok `thinking` yang berurutan harus sama dengan yang dihasilkan model dalam permintaan asli. Anda tidak dapat menyusun ulang, mengedit, atau menghapus sebagian blok tersebut. Aturan ini juga berlaku untuk [blok `redacted_thinking`](https://platform.claude.com/docs/id/build-with-claude/thinking#redacted-thinking-blocks). Blok pemikiran yang dimodifikasi akan ditolak dengan error 400. Lihat [Error 400 menyatakan blok pemikiran tidak dapat dimodifikasi](https://platform.claude.com/docs/id/build-with-claude/thinking-troubleshooting#error-thinking-blocks-modified) untuk pesan error persisnya, penyebab umum, dan perbaikannya. Satu-satunya pengecualian: teks yang ditempatkan di field `thinking` kosong pada blok yang [dihilangkan](https://platform.claude.com/docs/id/build-with-claude/thinking#controlling-thinking-display) akan diabaikan, bukan ditolak. Untuk panduan lengkap dua giliran dengan kode di setiap SDK, lihat [Pemikiran dalam alur kerja alat dan multi-giliran](https://platform.claude.com/docs/id/build-with-claude/thinking-tool-workflows#two-turn-tool-use-round-trip). Panduan tersebut mendefinisikan sebuah alat, menerima respons berisi pemikiran dan penggunaan alat, lalu mengirimkan kembali giliran asisten bersama hasil alat. ### Pemikiran berselang "Interleaved thinking" (pemikiran berselang) memungkinkan Claude berpikir di antara pemanggilan alat, bernalar tentang setiap hasil alat sebelum bertindak berdasarkan hasil tersebut. Dengan pemikiran berselang, Claude dapat: * Bernalar tentang hasil pemanggilan alat sebelum menentukan apa yang harus dilakukan selanjutnya * Merangkai beberapa pemanggilan alat dengan langkah-langkah penalaran di antaranya * Membuat keputusan yang lebih bernuansa berdasarkan hasil antara Pemanggilan alat yang berurutan tidak memerlukan pemikiran berselang. Claude dapat merangkai pemanggilan alat dengan atau tanpa pemikiran berselang. Pemikiran berselang mengubah di mana blok pemikiran muncul di antara pemanggilan alat, bukan apakah pemanggilan alat dapat dirangkai. Dengan pemikiran adaptif, pemikiran berselang berlaku otomatis pada setiap model yang mendukung pemikiran adaptif. Tidak diperlukan header beta. Pada Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, Claude Opus 4.8, dan Claude Opus 4.7, penalaran di antara pemanggilan alat selalu muncul dalam blok pemikiran. Claude Haiku 4.5 tidak mendukung pemikiran berselang. Pada model yang menggunakan pemikiran diperpanjang manual, pemikiran berselang memerlukan header beta dan mengubah cara anggaran pemikiran dihitung. [Pemikiran berselang dalam mode manual](https://platform.claude.com/docs/id/build-with-claude/extended-thinking#interleaved-thinking) membahas aturan per model dan perilaku header khusus platform. Dengan pemikiran berselang, alokasi pemikiran dapat mencakup seluruh giliran asisten, bukan hanya satu respons. Pemikiran berselang hanya didukung untuk [alat yang digunakan melalui Messages API](https://platform.claude.com/docs/id/agents-and-tools/tool-use/overview). Untuk perbandingan yang menunjukkan apa yang diubah oleh pemikiran berselang dalam alur kerja dua alat, lihat [Bagaimana pemikiran berselang mengubah alur](https://platform.claude.com/docs/id/build-with-claude/thinking-tool-workflows#how-interleaved-thinking-changes-the-flow). ### Pembaruan progres di antara pemanggilan alat Pada Claude Fable 5.1, Claude Mythos 5.1, Claude Opus 5.5, Claude Sonnet 5.5, dan Claude Fable 5, model dapat menulis pembaruan progres di antara pemanggilan alat. Pembaruan progres adalah catatan tentang apa yang baru saja ditemukan model dan apa yang akan dilakukannya selanjutnya, ditulis untuk orang yang mengamati agen, bukan sebagai penalaran. Masing-masing dikembalikan sebagai blok `thinking` tersendiri dengan `signature`-nya sendiri, terpisah dari blok penalaran apa pun pada titik yang sama. Blok ini berada tepat sebelum blok `tool_use` atau `server_tool_use` yang diperkenalkannya. Paling banyak satu pembaruan progres mendahului setiap pemanggilan alat, dan model dapat melewatkan salah satunya. Pembaruan progres bukan [pemikiran berselang](https://platform.claude.com/docs/id/build-with-claude/thinking#interleaved-thinking): pembaruan ini muncul terlepas dari apakah blok penalaran muncul di antara pemanggilan alat, dan sebuah respons dapat berisi keduanya. Isi blok pembaruan progres bergantung pada [`display`](https://platform.claude.com/docs/id/build-with-claude/thinking#controlling-thinking-display): | `display` | Blok penalaran | Blok pembaruan progres | | ------------------------------------------ | ----------------------- | --------------------------------------------------------- | | `"omitted"` (default pada model-model ini) | Field `thinking` kosong | Field `thinking` kosong | | `"updates"` (beta) | Field `thinking` kosong | Teks ringkasan | | `"summarized"` | Teks ringkasan | Teks ringkasan, tidak dapat dibedakan dari blok penalaran | Pada Claude Sonnet 5.5, pengaturan pemikiran terendah adalah `thinking: {type: "between_tools"}`. Pengaturan ini menonaktifkan pemikiran di awal, dan setiap pembaruan progres dikembalikan dengan teks ringkasannya, seperti pada `display: "updates"`. `between_tools` hanya diterima pada [effort](https://platform.claude.com/docs/id/build-with-claude/effort) `high` atau lebih rendah. Pada `xhigh` atau `max`, permintaan dengan pengaturan ini mengembalikan error 400. `between_tools` tidak menerima field lain: `display`, `budget_tokens`, atau `block_binding` yang dikirim bersamanya mengembalikan error 400. Pengaturan ini tidak memerlukan header beta dan berfungsi di setiap platform yang menawarkan Claude Sonnet 5.5. Kirimkan kembali blok tanpa perubahan: blok pembaruan progres yang Anda kirimkan kembali memberikan model catatan lengkap yang ditulisnya, bukan ringkasannya. Gunakan `display: "updates"` untuk antarmuka agen yang menyembunyikan penalaran dan menampilkan baris status kepada pengguna di setiap langkah. Dengan pengaturan ini, setiap blok `thinking` dengan teks yang tidak kosong adalah pembaruan progres, jadi tampilkan blok tersebut dan tidak ada yang lain. Fitur ini masih beta dan memerlukan header beta `thinking-display-updates-2026-08-18` (untuk mengirimkannya di Amazon Bedrock, Google Cloud, atau Microsoft Foundry, lihat [Fitur beta di platform lain](https://platform.claude.com/docs/id/api/beta-headers#beta-features-on-other-platforms)). Tanpa header tersebut, nilai ini ditolak dengan error 400 `invalid_request_error` yang sama seperti nilai `display` yang tidak dikenal. ```json { "model": "claude-fable-5-1", "max_tokens": 16000, "thinking": { "type": "adaptive", "display": "updates" }, "tools": [ { "name": "edit_file", "description": "Replace the contents of a file in the repository.", "input_schema": { "type": "object", "properties": { "path": { "type": "string" }, "content": { "type": "string" } }, "required": ["path", "content"] } } ], "messages": [ { "role": "user", "content": "The login test fails after an hour of uptime. Find out why and fix it." } ] } ``` Dengan `"updates"`, awal respons yang mengikuti `tool_result` terlihat seperti ini. Blok pertama adalah penalaran dan tetap kosong, seperti pada `"omitted"`. Blok kedua membawa teks, jadi itu adalah pembaruan progres. Dengan `"summarized"`, kedua blok membawa teks, dan dengan `"omitted"` keduanya kosong. ```json Output { "content": [ { "type": "thinking", "thinking": "", "signature": "EqMBCkYICxIM..." }, { "type": "thinking", "thinking": "Confirmed the retry path never refreshes the expired token. Editing auth.py to add the refresh call.", "signature": "Es8CCkYICxIM..." }, { "type": "tool_use", "id": "toolu_01D7FLrfh4GYq7yT1ULFeyMV", "name": "edit_file", "input": { "path": "auth.py", "content": "..." } } ] } ``` Perhatikan hal-hal berikut saat bekerja dengan pembaruan progres: * Kirimkan kembali blok pembaruan progres tanpa perubahan bersama sisa giliran asisten, seperti blok `thinking` lainnya. * Teks yang Anda terima adalah ringkasan dari pembaruan progres, biasanya satu atau dua kalimat. Jangan mengandalkan panjangnya. Pembaruan progres dihitung terhadap `usage.output_tokens` dengan panjang penuhnya, bukan panjang ringkasannya. * Blok pembaruan progres dapat dikembalikan dengan field `thinking` kosong pada nilai `display` apa pun. Jangan tampilkan apa pun untuk blok yang kosong. Dengan `"updates"`, blok ini terlihat sama dengan blok penalaran kosong dan tidak memerlukan penanganan terpisah. * Ketika respons berhenti karena `max_tokens`, `model_context_window_exceeded`, atau `stop_sequence` segera setelah pemanggilan alat atau hasil alat, blok terakhirnya dapat berupa blok pembaruan progres yang menggantikan pekerjaan yang belum diselesaikan model. Dengan `"updates"` dan `"summarized"`, teksnya persis `This part of the response was interrupted before it finished.` dan Anda dapat menampilkannya seperti pembaruan lainnya. Dengan `"omitted"`, blok ini kosong. Untuk melanjutkan, kirimkan kembali giliran asisten tanpa perubahan dan tambahkan pesan `user` baru (dengan `tool_result` untuk setiap blok `tool_use` dalam giliran tersebut). * Saat [streaming](https://platform.claude.com/docs/id/build-with-claude/thinking#streaming-thinking), perkirakan jeda beberapa detik sebelum blok pembaruan progres terbuka. Lihat jejak `"updates"` di [Streaming pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#streaming-thinking). * Model-model ini menulis lebih sedikit pembaruan progres pada [effort](https://platform.claude.com/docs/id/build-with-claude/effort) yang lebih tinggi dan dalam rantai alat yang panjang. Jika antarmuka Anda bergantung pada pembaruan ini, lihat [Minta pembaruan progres yang ditujukan kepada pengguna](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-fable-5-1#ask-for-user-facing-progress-updates) atau, untuk Claude Opus 5.5, [Pembaruan progres untuk pengguna](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-opus-5-5#user-facing-progress-updates). Untuk Claude Sonnet 5.5, lihat [Pembaruan progres untuk pengguna](https://platform.claude.com/docs/id/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#user-facing-progress-updates). ### Preservasi blok pemikiran berdasarkan model Apakah blok pemikiran dari giliran asisten sebelumnya tetap berada dalam konteks secara default bergantung pada modelnya: * **Mempertahankan semua giliran sebelumnya:** Claude Opus 4.5 dan model Opus yang lebih baru, Claude Sonnet 4.6 dan model Sonnet yang lebih baru, Claude Haiku 5.5, Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, dan Claude Mythos Preview. * **Hanya mempertahankan giliran terakhir:** model Opus dan Sonnet yang lebih lama, serta semua model Haiku hingga Claude Haiku 4.5. Saat Anda mengirimkan kembali blok pemikiran yang lebih lama, API menghapusnya secara otomatis. Anda tidak perlu menghapusnya sendiri. Preservasi memberikan dua manfaat: * **Optimasi cache:** blok pemikiran yang dipertahankan memungkinkan cache hit selama penggunaan alat, karena blok tersebut dikirim kembali bersama hasil alat dan di-cache secara bertahap di sepanjang giliran asisten, sehingga menghemat token dalam alur kerja multilangkah. * **Tidak berdampak pada kecerdasan:** mempertahankan blok pemikiran tidak berdampak negatif pada kinerja model. Konsekuensinya adalah penggunaan konteks: percakapan panjang menghabiskan lebih banyak ruang konteks pada model yang mempertahankan semua giliran, karena blok pemikiran yang dipertahankan dihitung sebagai input seperti riwayat percakapan lainnya (lihat [Pemikiran dan jendela konteks](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-and-the-context-window)). Perilaku ini otomatis di kedua rezim. Tidak diperlukan perubahan kode atau header beta, dan Anda harus tetap mengirimkan kembali blok pemikiran yang lengkap dan tidak dimodifikasi seperti yang dijelaskan dalam [Mempertahankan blok pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#preserving-thinking-blocks). Untuk mengganti default ke arah mana pun, gunakan [pembersihan blok pemikiran](https://platform.claude.com/docs/id/build-with-claude/context-editing#thinking-block-clearing). **Beralih model di tengah percakapan.** Tetap kirimkan kembali blok pemikiran tanpa perubahan saat Anda beralih model, misalnya setelah [fallback penolakan classifier](https://platform.claude.com/docs/id/build-with-claude/refusals-and-fallback). Blok pemikiran hanya dapat dibaca oleh model yang menghasilkannya dan model tertentu lainnya, dan API mengabaikan atau membuang blok yang tidak dapat dibaca oleh model tujuan. Pada Claude Fable 5.1 dan Claude Mythos 5.1, arahnya penting: keduanya membaca blok pemikiran dari model sebelumnya, dan hanya keduanya yang saling membaca blok satu sama lain, sehingga beralih ke keduanya mempertahankan penalaran percakapan, sedangkan beralih dari keduanya ke model lain mana pun akan membuangnya (lihat [bagaimana blok yang dibuang ditagih dan dilaporkan](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#switching-models)). Claude Opus 5.5 membaca blok pemikiran Claude Opus 5 dan blok dari model Opus, Sonnet, dan Haiku sebelumnya, serta, di Claude API dan Google Cloud, blok dari Claude Haiku 5.5, tetapi tidak membaca blok dari model Claude Fable dan Claude Mythos; di Claude API, Claude Fable 5.1 dan Claude Mythos 5.1 membaca blok Claude Opus 5.5. Peralihan dari Claude Opus 5.5 naik ke Claude Fable 5.1 di Claude API mempertahankan penalaran giliran sebelumnya; peralihan dari Claude Fable 5.1 ke Claude Opus 5.5 membuangnya. Claude Sonnet 5.5 membaca blok pemikiran dari Claude Sonnet 5, Claude Opus 4.8, Claude Haiku 4.5, dan model sebelumnya, serta, di Claude API dan Google Cloud, dari Claude Haiku 5.5, tetapi tidak dari Claude Opus 5, Claude Opus 5.5, atau model Claude Fable maupun Claude Mythos mana pun. Di Claude API dan Google Cloud, Claude Opus 5.5 membaca blok Claude Sonnet 5.5 dan tidak ada model lain yang membacanya: peralihan dari Claude Sonnet 5.5 naik ke Claude Opus 5.5 di Claude API dan Google Cloud mempertahankan penalaran giliran sebelumnya, dan peralihan lain apa pun dari Claude Sonnet 5.5 membuangnya. Claude Haiku 5.5 membaca blok pemikiran dari Claude Sonnet 5, Claude Opus 4.8, Claude Haiku 4.5, dan model sebelumnya, tetapi tidak dari Claude Opus 5, Claude Opus 5.5, Claude Sonnet 5.5, atau model Claude Fable maupun Claude Mythos mana pun. Di Claude API dan Google Cloud, Claude Opus 5.5 dan Claude Sonnet 5.5 membaca blok Claude Haiku 5.5 dan tidak ada model lain yang membacanya. Hapus sendiri blok `thinking` dan `redacted_thinking` sebelumnya hanya untuk menghemat token input pada model yang mengabaikan alih-alih membuangnya, dan jangan pernah melakukannya saat menukarkan [kredit fallback](https://platform.claude.com/docs/id/build-with-claude/fallback-credit), yang mengharuskan body tidak berubah. ## Pemikiran yang dipertahankan [Pemikiran yang dipertahankan](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking) menentukan apakah model dapat menggunakan blok pemikiran yang Anda kirim kembali dari giliran sebelumnya. Mulai dari Claude Fable 5.1, API memeriksa `signature` dari setiap blok `thinking` atau `redacted_thinking` dalam permintaan untuk dua hal: * **Model yang menghasilkannya.** Setiap model membaca blok pemikirannya sendiri dan blok dari sekumpulan model lain yang tetap. Claude Fable 5.1 membaca blok dari Claude Opus 5 dan, di Claude API, dari Claude Opus 5.5; baik Claude Opus 5 maupun Claude Opus 5.5 tidak membaca blok dari Claude Fable 5.1. API membuang blok yang tidak dapat dibaca oleh model saat ini, tanpa error dan tanpa menagihnya. Lihat [Beralih model di tengah percakapan](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#switching-models). * **Semua yang dikirim sebelumnya.** Sebuah blok tetap valid hanya selama prompt `system` tingkat atas, `tools`, dan pesan-pesan sebelumnya tidak berubah. Jika salah satunya berubah, blok tersebut dan setiap blok pemikiran setelahnya menjadi tidak valid, dan API menolak permintaan dengan error 400 atau membuang blok yang tidak valid, sesuai pilihan Anda. Lihat [Menjaga prefiks tetap tidak berubah](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#prefix-check). Blok pemikiran dari Claude Sonnet 5.5 dan Claude Haiku 5.5 juga terikat pada akun yang menghasilkannya. Lihat [Blok pemikiran tetap berada di akun yang menghasilkannya](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#account-bound-thinking) untuk mengetahui di mana API menerapkan hal ini. Pemeriksaan model berlaku untuk setiap akun. API menerapkan pemeriksaan prefiks secara default untuk akun yang dibuat pada atau setelah 31 Agustus 2026, 00:00 UTC. Pada akun yang lebih lama, API menerapkan pemeriksaan hanya pada permintaan yang menetapkan `thinking.block_binding.prefix_mismatch_behavior`. Buat integrasi Anda bersifat append-only terlepas dari usia akun Anda, sehingga kode yang sama berfungsi di setiap akun, termasuk akun baru yang diterapkan secara default. Agar pemikiran tetap valid, kirimkan kembali setiap giliran asisten persis seperti yang Anda terima dan tambahkan pesan baru hanya di akhir `messages`. Jika kode Anda membangun array `messages` sendiri, halaman Pemikiran yang dipertahankan membahas: * [Apa yang dihitung sebagai edit](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#what-counts-as-an-edit), dan [cara memeriksa apakah kode Anda melakukannya](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#how-to-tell-whether-your-integration-is-impacted). * [Fitur API yang menggantikan setiap jenis edit umum](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#replace-prefix-edits): pesan sistem di tengah percakapan untuk instruksi baru dan pengingat per giliran, blok `tool_addition` dan `tool_removal` untuk perubahan alat, `output_config` per pesan untuk perubahan effort, serta compaction sisi server dan pengeditan konteks untuk pemangkasan. * [Compaction sisi klien](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#custom-compaction-on-the-client): pola mana yang menjaga pemikiran tetap valid dan mana yang tidak. * [Header beta `thinking-binding-controls-2026-08-01`](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#preserved-thinking-controls). Header ini menambahkan field `block_binding.prefix_mismatch_behavior` (`"error"` atau `"drop_block"`) ke konfigurasi pemikiran dan array `input_transformations` ke setiap respons. Array tersebut mencantumkan setiap blok pemikiran yang dibuang oleh API, atau yang gagal dalam pemeriksaan prefiks dan tetap diloloskan. ## Pemikiran dan caching prompt ["Prompt caching" (caching prompt)](https://platform.claude.com/docs/id/build-with-claude/prompt-caching) berinteraksi dengan pemikiran dalam beberapa cara tertentu. Aturan berikut berlaku di kedua mode pemikiran. **Perubahan konfigurasi membatalkan caching.** Konfigurasi pemikiran dan level [`effort`](https://platform.claude.com/docs/id/build-with-claude/effort) yang telah ditentukan dirender ke dalam prompt itu sendiri, sehingga mengubah salah satunya akan memulai prefiks cache baru. Beralih antara `adaptive`, `enabled`, dan `disabled`, mengubah `budget_tokens`, dan mengubah nilai effort semuanya membatalkan breakpoint cache: breakpoint tingkat pesan selalu miss, dan breakpoint alat serta prompt sistem juga dapat miss, tergantung di mana model merender konfigurasi tersebut. Anggap setiap perubahan pemikiran atau effort tingkat atas sebagai memulai cache dari awal. Pada model yang mendukung [effort per pesan](https://platform.claude.com/docs/id/build-with-claude/effort#change-effort-mid-conversation-beta), perubahan effort yang dibawa dalam pesan `role: "system"` di dalam `messages` membiarkan prefiks yang di-cache tetap utuh. Permintaan berturut-turut yang mempertahankan konfigurasi yang sama menjaga cache, dan menetapkan parameter secara eksplisit ke nilai default-nya setara dengan menghilangkannya. Blok pemikiran yang dibuang oleh API dalam [kondisi pemikiran yang dipertahankan](https://platform.claude.com/docs/id/build-with-claude/thinking#preserved-thinking) mana pun mengubah prefiks yang di-cache mulai dari posisi blok tersebut dan seterusnya. Blok yang dikirim kembali tanpa perubahan menjaga cache tetap utuh. Demonstrasi lengkap dengan output penggunaan tersedia di halaman [Mengarahkan pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking-steering-and-cost#prompt-caching). **Blok pemikiran di-cache bersama hasil alat.** Selama loop penggunaan alat, caching terjadi saat Anda membuat permintaan lanjutan yang menyertakan hasil alat. Pada titik itu, riwayat percakapan sebelumnya, termasuk blok pemikirannya, dapat di-cache, dan blok pemikiran yang di-cache tersebut dihitung sebagai token input dalam metrik penggunaan Anda saat dibaca dari cache. Hal ini terjadi secara otomatis, bahkan tanpa penanda `cache_control` eksplisit, dan berperilaku sama untuk pemikiran biasa maupun pemikiran berselang. Konsekuensinya: blok pemikiran yang tidak pernah Anda lihat lagi dalam respons tetap berkontribusi pada penggunaan token input saat dibaca dari cache. **Apakah blok sebelumnya berada dalam konteks sama sekali bergantung pada model.** [Default preservasi](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-block-preservation-by-model) mengatur hal ini. Pada model yang mempertahankan semua giliran, blok pemikiran dari giliran sebelumnya tetap di-cache dan berada dalam konteks. Pada model yang hanya mempertahankan giliran terakhir, begitu Anda mengirim pesan pengguna yang bukan hasil alat, semua blok pemikiran sebelumnya dihapus dari konteks. Pada model tersebut, percakapan seperti ini: ```text wrap User: ["What's the weather in Paris?"], Assistant: [thinking_block_1] + [tool_use block 1], User: [tool_result_1, cache=True], Assistant: [thinking_block_2] + [text block 2], User: [Text response, cache=True] ``` diproses seolah-olah blok pemikiran tidak pernah ada: ```text wrap User: ["What's the weather in Paris?"], Assistant: [tool_use block 1], User: [tool_result_1, cache=True], Assistant: [text block 2], User: [Text response, cache=True] ``` Pada model yang mempertahankan semua giliran, permintaan yang sama mempertahankan `thinking_block_1` dan `thinking_block_2` dalam konteks dan dalam cache. **Degradasi menghapus pemikiran dari riwayat yang dapat di-cache.** Jika pemikiran menjadi nonaktif di tengah giliran dan Anda mengirimkan konten pemikiran dalam giliran penggunaan alat saat ini, konten pemikiran tersebut dihapus dan pemikiran tetap nonaktif untuk permintaan itu (lihat [degradasi yang mulus](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-with-tool-use)). [Pemikiran berselang](https://platform.claude.com/docs/id/build-with-claude/thinking#interleaved-thinking) memperkuat efek pembatalan cache, karena blok pemikiran dapat muncul di antara beberapa pemanggilan alat. Tugas yang banyak melibatkan pemikiran sering kali membutuhkan waktu lebih lama untuk diselesaikan daripada masa berlaku cache default 5 menit. Pertimbangkan [durasi cache 1 jam](https://platform.claude.com/docs/id/build-with-claude/prompt-caching#1-hour-cache-duration) untuk mempertahankan cache hit di sepanjang sesi pemikiran yang lebih panjang dan alur kerja multilangkah. ## Pemikiran dan jendela konteks `max_tokens`, yang mencakup semua pemikiran yang dihasilkan Claude dalam giliran saat ini, diterapkan sebagai batas ketat. Pada model Claude 4.5 dan yang lebih baru, jika token input ditambah `max_tokens` melebihi ukuran "context window" (jendela konteks), API menerima permintaan tersebut. Jika pembuatan kemudian mencapai batas jendela konteks, pembuatan berhenti dengan `stop_reason: "model_context_window_exceeded"` alih-alih mengembalikan error. Pada model yang lebih lama, API mengembalikan error validasi sebagai gantinya. Lihat [Menangani alasan berhenti](https://platform.claude.com/docs/id/build-with-claude/handling-stop-reasons). Cara pemikiran dihitung terhadap jendela bergantung pada kapan pemikiran tersebut dihasilkan: * **Pemikiran giliran saat ini** selalu dihitung terhadap `max_tokens`, ditagih sebagai token output, dan menempati ruang jendela konteks untuk giliran yang menghasilkannya. * **Pemikiran giliran sebelumnya** bergantung pada [default preservasi](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-block-preservation-by-model). Pada [model yang mempertahankan semua giliran sebelumnya](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-block-preservation-by-model), blok pemikiran sebelumnya tetap berada dalam konteks, dihitung terhadap jendela, dan ditagih sebagai token input seperti riwayat percakapan lainnya. Pada model yang hanya mempertahankan giliran terakhir, API menghapus blok pemikiran yang lebih lama secara otomatis saat Anda mengirimkannya kembali, sehingga blok tersebut tidak menghabiskan ruang jendela atau token input. Dalam praktiknya: * Pada model yang mempertahankan semua giliran, anggarkan jendela konteks Anda seolah-olah pemikiran adalah riwayat percakapan biasa, karena memang demikian. Sesi agentik yang panjang mengakumulasi pemikiran dalam konteks. Gunakan [pembersihan blok pemikiran](https://platform.claude.com/docs/id/build-with-claude/context-editing#thinking-block-clearing) jika Anda perlu mengambil kembali ruang. * Pada model yang hanya mempertahankan giliran terakhir, pemikiran hanya merupakan biaya per giliran: pemikiran setiap giliran dihitung terhadap `max_tokens` giliran tersebut lalu keluar dari jendela. Diagram berikut mengilustrasikan rezim yang hanya mempertahankan giliran terakhir (penghapusan). Diagram pertama menunjukkan percakapan multi-giliran: blok pemikiran setiap giliran dihasilkan dalam output tetapi tidak dibawa ke input giliran berikutnya. ![Diagram pemikiran pada model yang menghapus blok pemikiran sebelumnya: blok pemikiran setiap giliran dihasilkan dalam output dan tidak dibawa ke input giliran berikutnya](https://platform.claude.com/docs/id/images/context-window-thinking.svg) Diagram kedua menunjukkan rezim yang sama dengan penggunaan alat: pemikiran tetap berada dalam konteks bersama hasil alatnya selama giliran asisten berlangsung, lalu keluar pada giliran pengguna berikutnya. ![Diagram pemikiran dengan penggunaan alat pada model yang menghapus blok pemikiran sebelumnya: pemikiran dipertahankan bersama hasil alatnya, lalu dibuang pada giliran pengguna berikutnya](https://platform.claude.com/docs/id/images/context-window-thinking-tools.svg) Gunakan [API penghitungan token](https://platform.claude.com/docs/id/build-with-claude/token-counting) untuk mendapatkan hitungan yang akurat untuk kasus penggunaan spesifik Anda, terutama untuk percakapan multi-giliran yang menyertakan pemikiran. ## Enkripsi pemikiran Konten pemikiran lengkap dienkripsi dan dikembalikan dalam field `signature` pada setiap blok pemikiran. API menggunakan signature tersebut untuk memverifikasi bahwa blok pemikiran dihasilkan oleh Claude saat Anda mengirimkannya kembali. Perhatikan hal-hal berikut saat bekerja dengan signature: * Mengirim kembali blok pemikiran hanya benar-benar diperlukan saat [menggunakan alat dengan pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-with-tool-use). Jika tidak, Anda dapat menghilangkan blok pemikiran dari giliran sebelumnya. Jika Anda mengirimkannya kembali, apakah API mempertahankan atau menghapusnya bergantung pada model (lihat [Preservasi blok pemikiran berdasarkan model](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-block-preservation-by-model)). Gunakan [pengeditan konteks](https://platform.claude.com/docs/id/build-with-claude/context-editing) untuk mengonfigurasi hal ini. * Saat mengirim kembali blok pemikiran, kirimkan semuanya persis seperti yang Anda terima, demi konsistensi dan untuk menghindari potensi masalah. * Saat [melakukan streaming respons](https://platform.claude.com/docs/id/build-with-claude/thinking#streaming-thinking), signature tiba sebagai `signature_delta` di dalam event `content_block_delta` tepat sebelum event `content_block_stop`. * Nilai `signature` jauh lebih panjang pada model Claude 4 dan yang lebih baru dibandingkan model sebelumnya. * Field `signature` bersifat opaque: jangan menafsirkan atau mem-parse-nya. * Nilai `signature` kompatibel lintas platform (Claude API, [Amazon Bedrock](https://platform.claude.com/docs/id/build-with-claude/claude-in-amazon-bedrock), dan [Google Cloud](https://platform.claude.com/docs/id/build-with-claude/claude-on-vertex-ai)). Nilai yang dihasilkan di satu platform berfungsi di platform lain, kecuali bahwa blok pemikiran dari Claude Sonnet 5.5 dan Claude Haiku 5.5 hanya berfungsi di akun yang menghasilkannya atau di akun yang terhubung dengannya. Lihat [Blok pemikiran tetap berada di akun yang menghasilkannya](https://platform.claude.com/docs/id/build-with-claude/preserved-thinking#account-bound-thinking). ## Blok pemikiran yang disunting Selain blok `thinking` biasa, API dapat mengembalikan blok `redacted_thinking` ketika sebagian penalaran Claude disunting demi keamanan. Blok `redacted_thinking` berisi konten pemikiran terenkripsi dalam field `data`, tanpa teks yang dapat dibaca: ```json { "type": "redacted_thinking", "data": "..." } ``` Field `data` bersifat opaque dan terenkripsi. Seperti field `signature` pada blok pemikiran biasa, kirimkan kembali blok `redacted_thinking` ke API tanpa perubahan saat melanjutkan percakapan multi-giliran dengan [alat](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-with-tool-use). Jika kode Anda memfilter blok konten berdasarkan tipe (misalnya, `block.type == "thinking"`) saat mengirim bolak-balik respons dengan penggunaan alat, sertakan juga blok `redacted_thinking`. Memfilter hanya dengan `block.type == "thinking"` akan secara diam-diam membuang blok `redacted_thinking` dan merusak protokol multi-giliran yang dijelaskan dalam [Mempertahankan blok pemikiran](https://platform.claude.com/docs/id/build-with-claude/thinking#preserving-thinking-blocks). Blok `redacted_thinking` adalah tipe blok konten tersendiri yang dikembalikan ketika pemikiran disunting demi keamanan. Ini berbeda dari opsi [`display: "omitted"`](https://platform.claude.com/docs/id/build-with-claude/thinking#controlling-thinking-display), yang mengembalikan blok `thinking` biasa dengan field `thinking` kosong. ## Batasan dan kompatibilitas fitur ### Parameter sampling Pada Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Mythos Preview, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5.5, Claude Sonnet 5, dan Claude Haiku 5.5, nilai `temperature`, `top_p`, atau `top_k` yang bukan default mengembalikan error 400 pada setiap permintaan, terlepas dari apakah pemikiran digunakan atau tidak. Pada model-model ini, default `top_p` adalah `0.99`, sehingga `top_p` bernilai `1` mengembalikan error 400, begitu pula permintaan yang menyertakan `temperature` dan `top_p` sekaligus, bahkan pada nilai default-nya. Lihat [Hapus parameter sampling](https://platform.claude.com/docs/id/models/haiku-5-5/migration-guide#remove-sampling-parameters). Pada model yang lebih lama, pembatasan hanya berlaku saat pemikiran aktif: `temperature` dan `top_k` tidak kompatibel dengan pemikiran, dan `top_p` diizinkan pada nilai antara 0,95 dan 1. ### Prefill respons dan penggunaan alat paksa Model Claude 4.6 dan yang lebih baru serta Claude Mythos Preview menolak giliran asisten terakhir yang di-prefill dengan error 400, baik pemikiran aktif maupun tidak (lihat [Prefill tidak didukung](https://platform.claude.com/docs/id/api/errors#prefill-not-supported)). Pada model yang lebih lama, Anda tidak dapat melakukan prefill respons asisten saat pemikiran aktif. Penggunaan alat paksa (`tool_choice: {"type": "any"}` atau `{"type": "tool", ...}`) tidak kompatibel dengan pemikiran diperpanjang manual tetapi berfungsi dengan pemikiran adaptif. Pengecualiannya adalah Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1, dan Claude Mythos 5.1, yang menolak penggunaan alat paksa pada setiap permintaan dengan error 400. Pada model-model tersebut, gunakan `tool_choice: {"type": "auto"}` dengan [penggunaan alat ketat](https://platform.claude.com/docs/id/agents-and-tools/tool-use/strict-tool-use) atau [output terstruktur](https://platform.claude.com/docs/id/build-with-claude/structured-outputs) sebagai gantinya. Jika penggunaan alat paksa diterima, respons dimulai dengan pemanggilan alat dan tidak memiliki blok `thinking`. Agar model dapat berpikir sebelum memanggil alat, gunakan `tool_choice: {"type": "auto"}` dan sebutkan dalam prompt kapan harus menggunakan alat tersebut. Lihat [Pemikiran dengan penggunaan alat](https://platform.claude.com/docs/id/build-with-claude/thinking#thinking-with-tool-use). ### Batas output Setiap model menerima `max_tokens` hingga batas atas yang tercantum di sini. Pada [Message Batches API](https://platform.claude.com/docs/id/build-with-claude/batch-processing#extended-output-beta), [header beta](https://platform.claude.com/docs/id/api/beta-headers) `output-300k-2026-03-24` menaikkan batas atas tersebut untuk model yang memiliki batas atas batch yang tercantum. | Model | Max output tokens | Batches beta ceiling | | :-------------------- | :---------------- | :------------------- | | Claude Fable 5.1 | 128K | — | | Claude Mythos 5.1 | 128K | — | | Claude Fable 5 | 128K | — | | Claude Mythos 5 | 128K | — | | Claude Mythos Preview | 128K | Not available | | Claude Opus 5.5 | 128K | 300K | | Claude Opus 5 | 128K | 300K | | Claude Opus 4.8 | 128K | 300K | | Claude Opus 4.7 | 128K | 300K | | Claude Opus 4.6 | 128K | 300K | | Claude Opus 4.5 | 64K | Not available | | Claude Sonnet 5.5 | 128K | 300K | | Claude Sonnet 5 | 128K | 300K | | Claude Sonnet 4.6 | 128K | 300K | | Claude Sonnet 4.5 | 64K | Not available | | Claude Haiku 5.5 | 128K | 300K | | Claude Haiku 4.5 | 64K | Not available | Lihat [ikhtisar model](https://platform.claude.com/docs/id/models/overview) untuk batasan pada model lama. ### Permintaan panjang SDK mewajibkan streaming ketika `max_tokens` lebih besar dari 21.333, untuk menghindari timeout HTTP pada permintaan yang berjalan lama. Ini adalah validasi sisi klien, bukan pembatasan API. Jika Anda tidak perlu memproses event secara bertahap, gunakan `.stream()` (java: `.createStreaming()`; csharp: `.CreateStreaming()`; go: `.NewStreaming()`; php: `->createStream()`) dengan `.get_final_message()` (typescript: `.finalMessage()`; ruby: `.accumulated_message`; csharp: `.Aggregate()`; go: `message.Accumulate(event)`; java, php: `MessageAccumulator`) untuk mendapatkan objek `Message` lengkap tanpa harus menyusunnya sendiri dari event individual. Lihat [Streaming Messages](https://platform.claude.com/docs/id/build-with-claude/streaming#get-the-final-message-without-handling-events). Perkirakan waktu respons yang lebih lama saat pemikiran aktif, karena pembuatan blok pemikiran menambah waktu pemrosesan. Untuk beban kerja yang mendorong pemikiran di atas sekitar 32k token per permintaan, gunakan [pemrosesan batch](https://platform.claude.com/docs/id/build-with-claude/batch-processing) untuk menghindari masalah jaringan: permintaan semacam itu dapat berjalan cukup lama hingga mencapai timeout sistem dan batas koneksi terbuka. ## Langkah selanjutnya Arahkan seberapa sering dan seberapa dalam Claude berpikir dengan tingkat effort, panduan prompt sistem, dan pengarahan per pesan, serta pahami biaya dan harga pemikiran. Telusuri perjalanan bolak-balik penggunaan alat dua giliran yang lengkap dan mempertahankan blok pemikiran dengan benar, serta lihat bagaimana pemikiran berselang mengubah alurnya. Cari tahu apakah integrasi Messages API Anda mengedit riwayat percakapan, dan ganti setiap pengeditan dengan fitur API yang menjaga blok pemikiran sebelumnya tetap valid. Diagnosis dan perbaiki kegagalan pemikiran yang paling umum: error 400 konfigurasi, blok pemikiran yang kosong atau hilang, penghentian karena max\_tokens, dan cache miss. Kendalikan berapa banyak token yang digunakan Claude saat merespons dengan parameter effort, dengan menyeimbangkan antara ketelitian respons dan efisiensi token.