---
title: "max_tokens untuk model penalaran: cara menganggarkan"
description: "Kenapa model penalaran memberi balasan kosong saat max_tokens rendah, dan cara menentukan anggaran dari persentil terukur, context window, dan retry yang bertahap."
url: https://broadrouter.com/id/blog/reasoning-model-max-tokens-budget/
lang: id
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Diterjemahkan dari bahasa Inggris dengan bantuan AI. [Baca versi asli bahasa Inggris](https://broadrouter.com/blog/reasoning-model-max-tokens-budget/) (diperbarui 2026-11-15).

# Mengatur max\_tokens untuk model penalaran: metode penganggaran

Oleh tim BroadNet Inference · 6 menit baca · Dipublikasikan 2026-11-15

Pada model penalaran, max\_tokens membatasi proses berpikir dan jawaban sekaligus, sehingga batas yang ketat bisa menghentikan balasan sebelum ada teks yang terlihat. Ukur total completion token per jenis tugas, atur max\_tokens sekitar persentil ke-95 ditambah 20%, pastikan prompt plus max\_tokens muat di context window, dan ulangi balasan yang terpotong dengan anggaran dua kali lipat hingga batas keras.

## Poin penting

-   max\_tokens adalah plafon, bukan tagihan. Anda membayar token yang dihasilkan, jadi plafon yang longgar tidak menambah biaya untuk balasan yang selesai lebih awal.
-   Plafon yang ketat justru yang memakan biaya: balasan yang terpotong tetap menagih token berpikirnya, tidak mengembalikan jawaban, dan harus dikirim ulang.
-   Tentukan anggaran per jenis tugas dari log Anda sendiri: persentil ke-95 completion token ditambah margin 20% adalah titik awal yang baik.
-   Token prompt ditambah max\_tokens harus muat di context window: 262.144 token pada Qwen3.8 27B, 1.048.576 pada GLM 5.3 dan DeepSeek V4.1 Flash.
-   Anggap finish\_reason "length" sebagai sinyal: ulangi dengan anggaran dua kali lipat atau reasoning\_effort yang lebih rendah, dengan batas keras.

**Di halaman ini**

1.  Kenapa anggaran habis sebelum jawaban keluar?
2.  Apakah max\_tokens yang lebih besar lebih mahal?
3.  Bagaimana mengukur kebutuhan sebuah tugas?
4.  Bagaimana context window membatasi anggaran?
5.  Apa yang harus dilakukan jika balasan masih terpotong?
6.  Bagaimana streaming mengubah gambarannya?
7.  Nama parameter mana yang harus dikirim?
8.  Di mana posisi BroadNet Inference?

Model penalaran berpikir sebelum menjawab, dan di sebagian besar API kompatibel OpenAI keduanya diambil dari satu anggaran: `max_tokens`. Jika Anda mengaturnya seperti untuk model non-penalaran, beberapa ratus token untuk jawaban singkat, sebagian balasan akan kembali kosong dengan `finish_reason: "length"`. Perbaikan cepatnya ada di [kenapa model penalaran mengembalikan jawaban kosong](https://broadrouter.com/id/guides/reasoning-tokens-empty-response/). Artikel ini membahas metode di balik anggaran yang bisa diandalkan: ukur, tentukan dari persentil, patuhi context window, dan tangani balasan yang masih terpotong.

Untuk biaya penalaran dan cara menguranginya, lihat [token penalaran: kenapa Anda membayar output lebih banyak dari yang terlihat](https://broadrouter.com/id/blog/reasoning-tokens-cost/).

## Kenapa anggaran habis sebelum jawaban keluar?

Model menghasilkan secara berurutan: pertama penalarannya, lalu jawaban yang terlihat. Setiap token dari keduanya dihitung dalam `max_tokens`. Dokumentasi BroadNet menyatakan ini untuk DeepSeek V4.1 Flash, GLM 5.3, dan Qwen3.8 27B: “the reasoning counts toward max\_tokens” (Terjemahan BroadRouter: penalaran dihitung dalam max\_tokens), dan dengan batas kecil “the answer comes back empty” (Terjemahan BroadRouter: jawabannya kembali kosong). Referensi Chat Completions OpenAI mendefinisikan `max_completion_tokens` dengan cara yang sama, sebagai batas atas “including visible output tokens and reasoning tokens” (Terjemahan BroadRouter: termasuk token output yang terlihat dan token penalaran).

Jadi pertanyaannya bukan “seberapa panjang jawaban saya?” melainkan “seberapa panjang penalaran dan jawaban sekaligus, untuk tugas ini, pada effort ini?” Variasinya lebih besar dari yang diperkirakan orang. Panduan OpenAI menyebutkan model-modelnya bisa menghasilkan “anywhere from a few hundred to tens of thousands of reasoning tokens” (Terjemahan BroadRouter: mulai dari beberapa ratus hingga puluhan ribu token penalaran), tergantung masalahnya.

## Apakah max\_tokens yang lebih besar lebih mahal?

Tidak. Inilah alasan paling umum anggaran diatur terlalu ketat. [`max_tokens`](https://broadrouter.com/id/glossary/max-tokens/) adalah plafon. Anda ditagih untuk token yang benar-benar dihasilkan. Balasan yang butuh 1.800 token biayanya sama, baik plafonnya 4.000 maupun 40.000.

Yang membuat plafon ketat memakan biaya:

| Plafon vs kebutuhan | Yang Anda bayar | Yang Anda dapat |
| --- | --- | --- |
| Plafon di atas kebutuhan | Token yang dihasilkan | Jawabannya |
| Plafon di bawah kebutuhan | Seluruh plafon, semuanya penalaran | Tidak ada yang bisa dipakai, plus retry |

Ambil ilustrasi. Misalkan seperempat panggilan Anda butuh lebih dari 1.000 token. Dengan `max_tokens=1000`, setiap panggilan itu menagih 1.000 token output berupa proses berpikir, tidak mengembalikan apa pun, lalu diulang. Itu menambah rata-rata 250 token output terbuang per panggilan di seluruh panggilan, belum termasuk retry-nya sendiri, plus latensi permintaan kedua. Dengan plafon 4.000, tidak ada yang terbuang. Di [Qwen3.8 27B](https://broadrouter.com/id/models/qwen3.8-27b/), output seharga $2.17 per 1 juta token, jadi pemborosan ini menumpuk pada volume besar.

Risiko sebenarnya dari plafon tinggi adalah balasan yang lepas kendali: model yang berputar-putar atau berpikir berlebihan dan menghasilkan jauh lebih banyak dari yang dibutuhkan. Batas keras membatasinya. Tentukan batas itu dari data, seperti di bawah.

## Bagaimana mengukur kebutuhan sebuah tugas?

Jalankan prompt nyata untuk satu jenis tugas dengan plafon yang longgar, lalu catat completion token dan porsi penalarannya. Jika model melaporkannya, `usage.completion_tokens_details.reasoning_tokens` memberi bagian penalaran; dokumentasi BroadNet mencantumkan field itu.

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"

def measure(prompts, ceiling=16_000, **kw):
    """Run real prompts with a generous ceiling and return per-call token counts."""
    rows = []
    for p in prompts:
        r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
                                           messages=[{"role": "user", "content": p}], **kw)
        u, d = r.usage, r.usage.completion_tokens_details
        reasoning = (d.reasoning_tokens or 0) if d else 0
        rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
                     "finish": r.choices[0].finish_reason})
    return rows

def pct(values, q):
    values = sorted(values)
    return values[min(len(values) - 1, int(q * len(values)))]

def recommend(rows, margin=1.2):
    total = [r["reasoning"] + r["answer"] for r in rows]
    return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
            "max_tokens": int(pct(total, 0.95) * margin),
            "cut_off": sum(r["finish"] == "length" for r in rows)}

# print(recommend(measure(my_prompts)))                       # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))
```

Aturan agar angkanya bisa diandalkan:

1.  **Satu jenis tugas per run.** Klasifikasi, ekstraksi, code review, dan perencanaan punya distribusi yang sangat berbeda. Satu `max_tokens` global entah membuang uang untuk retry atau meloloskan balasan yang lepas kendali.
2.  **50 atau lebih prompt nyata.** Persentil ke-95 dari sepuluh sampel hanyalah sampel terbesar.
3.  **Jalankan di setiap tingkat effort yang Anda pakai.** `reasoning_effort="low"` mengubah distribusinya. BroadNet mendokumentasikan `low`; uji nilai lain sebelum Anda mengandalkannya.
4.  **Jika `cut_off` tidak nol, naikkan plafon dan jalankan lagi.** Sampel yang terpotong menyembunyikan panjang sebenarnya.
5.  **Jalankan ulang saat model atau prompt berubah.** Versi model baru bisa berpikir lebih banyak atau lebih sedikit.

Lalu atur `max_tokens` per tugas dari `recommend()`. Persentil ke-95 ditambah 20% membuat sebagian besar panggilan jauh di bawah plafon dan hanya mengirim panggilan panjang yang jarang ke jalur retry di bawah. [Alat anggaran token penalaran](https://broadrouter.com/tools/reasoning-token-budget/) yang gratis menghitungnya di browser Anda begitu angkanya sudah ada.

## Bagaimana context window membatasi anggaran?

Context window menampung prompt dan jawaban sekaligus. Feed harga BroadNet mendefinisikan `context_length` sebagai “the most tokens one request can hold, prompt and answer together” (Terjemahan BroadRouter: jumlah token terbanyak yang bisa ditampung satu permintaan, prompt dan jawaban sekaligus). Jadi:

**max\_tokens ≤ panjang context − token prompt**

| Model | Context | Ruang untuk max\_tokens dengan prompt 200.000 token |
| --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/id/models/glm-5.3/) | 1.048.576 | 848.576 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/id/models/deepseek-v4.1-flash/) | 1.048.576 | 848.576 |
| Qwen3.8 27B | 262.144 | 62.144 |

Ini penting untuk pekerjaan konteks panjang. Agent yang riwayatnya sudah tumbuh hingga 250.000 token di Qwen3.8 27B hanya punya sekitar 12.000 token tersisa untuk berpikir dan menjawab. Tugas konteks panjang juga cenderung butuh penalaran lebih banyak, jadi periksa sisa ruangnya saat panggilan dilakukan, bukan sekali saat startup. [Context window](https://broadrouter.com/id/glossary/context-window/) dan [kalkulator context window](https://broadrouter.com/tools/context-window-calculator/) membahas soal muat tidaknya.

## Apa yang harus dilakukan jika balasan masih terpotong?

Periksa `finish_reason` di setiap panggilan. Jika nilainya `length`, jawabannya hilang atau tidak lengkap, meskipun `content` berisi sedikit teks. Jangan mem-parse-nya seolah lengkap; objek JSON yang terpotong adalah sumber error hilir yang umum ([output terstruktur](https://broadrouter.com/id/blog/structured-output-json-schema/)).

Ulangi dengan anggaran dua kali lipat, dalam ruang yang diizinkan context, hingga batas keras:

```python
import json, urllib.request

FEED = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
CONTEXT = {m["id"]: m.get("context_length") for m in FEED["models"]}

def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
    """Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
    while True:
        r = client.chat.completions.create(model=model, messages=messages,
                                           max_tokens=budget, **kw)
        if r.choices[0].finish_reason != "length":
            return r
        room = CONTEXT[model] - r.usage.prompt_tokens        # context holds prompt + answer
        nxt = min(budget * 2, hard_cap, room)
        if nxt <= budget:
            raise RuntimeError(f"still cut off at max_tokens={budget}")
        print(f"cut off at {budget}, retrying with {nxt}")
        budget = nxt
```

Dua alternatif selain menggandakan, tergantung tugasnya:

-   **Ulangi dengan `reasoning_effort="low"`** pada anggaran yang sama. Untuk tugas sederhana, model sering berpikir berlebihan, dan effort yang lebih rendah menyelesaikannya tanpa plafon yang lebih besar.
-   **Pecah tugasnya.** Jika sebuah balasan terus menabrak batas yang tinggi, biasanya permintaannya meminta terlalu banyak sekaligus.

Catat setiap pemotongan beserta jenis tugasnya di log. Tingkat yang naik berarti prompt, model, atau data input berubah, dan anggarannya perlu diukur ulang. Retry adalah inferensi baru dan ditagih lagi, jadi batasi jumlah percobaannya, seperti di [agent yang berjalan lama: timeout dan retry](https://broadrouter.com/id/blog/long-running-agents-timeouts-retries/).

## Bagaimana streaming mengubah gambarannya?

Dengan `stream=True`, penalaran terjadi sebelum token pertama yang terlihat, sehingga model penalaran bisa tampak macet di awal. Di UI chat, tampilkan status “sedang berpikir” sampai konten tiba, dan atur timeout klien untuk waktu berpikir, bukan hanya untuk jawabannya.

Beberapa server juga men-stream teks penalaran itu sendiri, di field terpisah. Namanya tidak standar: API DeepSeek sendiri memakai `reasoning_content`, dan vLLM mengganti nama field-nya dari `reasoning_content` menjadi `reasoning`, dengan peringatan bahwa kode klien lama “could silently read an empty” (Terjemahan BroadRouter: bisa diam-diam membaca field kosong). Dokumentasi BroadNet tidak mendokumentasikan field teks penalaran, jadi jangan membangun fitur di atasnya tanpa memeriksa respons mentah untuk model Anda. Jika Anda membacanya, baca secara defensif:

```python
for chunk in stream:
    if chunk.choices:
        delta = chunk.choices[0].delta
        thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
        # log or display `thinking` only if your provider actually sends it
        if delta.content:
            print(delta.content, end="")
    elif chunk.usage:                                  # last chunk, with include_usage
        print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))
```

Usage di chunk terakhir memerlukan `stream_options={"include_usage": True}`, yang didokumentasikan BroadNet. Lebih lanjut tentang stream ada di [panduan streaming](https://broadrouter.com/id/guides/streaming-chat-completions/) dan [penjelasan SSE](https://broadrouter.com/id/blog/llm-streaming-sse-explained/).

## Nama parameter mana yang harus dikirim?

| API | Parameter | Termasuk penalaran |
| --- | --- | --- |
| OpenAI Chat Completions | `max_completion_tokens` (`max_tokens` deprecated) | Ya |
| OpenAI Responses | `max_output_tokens` | Ya |
| BroadNet Inference (Chat Completions) | `max_tokens`, sesuai dokumentasi | Ya |
| Server vLLM | `max_tokens`, plus `thinking_token_budget` opsional | Ya |

Saat memindahkan kode antarpenyedia, kirim nama yang didokumentasikan penyedia, dan pastikan dengan satu panggilan uji bahwa batasnya berlaku. Batas yang diam-diam diabaikan terlihat baik-baik saja sampai balasan yang lepas kendali muncul. [Checklist migrasi](https://broadrouter.com/id/blog/openai-compatible-api-migration-checklist/) membahas parameter lain yang berubah.

## Di mana posisi BroadNet Inference?

Tiga model penalaran BroadNet melaporkan token penalaran di `usage` jika model menyediakannya, sehingga pengukuran di atas berjalan sebagaimana tertulis. DeepSeek V4.1 Flash dan GLM 5.3 memberi ruang paling besar, dengan context 1.048.576 token. Qwen3.8 27B punya 262.144. Jika Anda tidak butuh penalaran untuk suatu tugas, [Gemma 4 VL 26B](https://broadrouter.com/id/models/gemma-4-vl-26b/) tidak tercantum sebagai model penalaran dan menghindari persoalan anggaran ini sama sekali. Pada [paket DeepSeek V4.1 Flash](https://broadrouter.com/id/guides/unlimited-llm-api-sessions/) harga tetap, token berpikir tidak dikenai biaya per token, tetapi balasan yang terpotong tetap membuang waktu, jadi penganggaran yang sama tetap berlaku. BroadNet tidak mendokumentasikan batas penalaran terpisah; jika Anda membutuhkannya, gunakan penyedia atau server self-hosted yang menawarkannya.

Alat gratis untuk topik ini (bahasa Inggris)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Alat gratis (bahasa Inggris)](https://broadrouter.com/tools/)

## Istilah dalam artikel ini

[Token](https://broadrouter.com/id/glossary/token/)

Token adalah satuan teks yang dibaca dan ditulis model bahasa: sebuah kata, bagian kata, tanda baca, atau urutan byte yang dihasilkan tokenizer model. API LLM menghitung, membatasi, dan biasanya menagih pemakaian dalam token.

[Context window (jendela konteks)](https://broadrouter.com/id/glossary/context-window/)

Context window adalah jumlah token maksimum yang bisa diolah model bahasa dalam satu permintaan. Cakupannya meliputi prompt, riwayat percakapan, definisi tool, gambar, dan output yang dihasilkan, termasuk token penalaran. Apa pun yang tidak muat harus dipotong, diringkas, atau dibagi ke beberapa permintaan.

[Token penalaran (reasoning tokens)](https://broadrouter.com/id/glossary/reasoning-tokens/)

Token penalaran adalah token yang dihasilkan model penalaran untuk mengerjakan suatu masalah sebelum menulis jawaban yang terlihat. Token ini biasanya ditagih sebagai token output, dihitung dalam batas output dan context window, dan bisa disembunyikan atau diringkas oleh API.

[max\_tokens](https://broadrouter.com/id/glossary/max-tokens/)

max\_tokens adalah parameter API LLM yang menetapkan jumlah token maksimum yang boleh dihasilkan model dalam satu respons. Saat generasi mencapai batas itu, proses berhenti dan respons ditandai terpotong, misalnya dengan finish\_reason bernilai "length".

[Token input dan output](https://broadrouter.com/id/glossary/input-and-output-tokens/)

Token input adalah token yang dibaca model bahasa dalam sebuah permintaan, termasuk system prompt, riwayat percakapan, definisi tool, dan gambar. Token output adalah token yang dihasilkannya sebagai balasan, termasuk penalaran. API LLM biasanya menghargainya secara terpisah, dan output biasanya lebih mahal.

[Streaming (respons streaming)](https://broadrouter.com/id/glossary/streaming/)

Streaming adalah cara mengembalikan respons model bahasa dalam potongan-potongan kecil selagi masih dihasilkan, bukan sebagai satu balasan utuh di akhir. API yang kompatibel dengan OpenAI melakukan streaming lewat server-sent events jika permintaan mengatur stream ke true.

[Chat Completions API](https://broadrouter.com/id/glossary/chat-completions-api/)

Chat Completions API adalah endpoint HTTP milik OpenAI, POST /v1/chat/completions, yang menerima nama model dan daftar pesan bertanda peran lalu mengembalikan pesan berikutnya dari model. Bentuk request dan response-nya menjadi format umum yang dipakai ulang oleh penyedia dan SDK yang kompatibel dengan OpenAI.

[vLLM](https://broadrouter.com/id/glossary/vllm/)

vLLM adalah library open-source untuk inferensi dan serving LLM, awalnya dikembangkan di Sky Computing Lab UC Berkeley. Ia mengelola memori KV cache dengan PagedAttention, mem-batch request yang masuk secara kontinu, mendukung banyak format kuantisasi, dan menyediakan server HTTP yang kompatibel dengan OpenAI.

## Pertanyaan umum

### Kenapa model penalaran saya mengembalikan respons kosong?

Model menghabiskan seluruh anggaran max\_tokens untuk penalaran tersembunyi sebelum sempat menulis jawaban. finish\_reason-nya lalu "length". Naikkan max\_tokens, turunkan reasoning\_effort, atau keduanya. Panduan singkat berisi perbaikan cepatnya ditautkan dari artikel ini.

### Berapa max\_tokens yang sebaiknya untuk model penalaran?

Ukur dulu. Jalankan 50 atau lebih prompt nyata dengan plafon yang longgar, ambil persentil ke-95 completion\_tokens untuk tugas itu, lalu tambahkan sekitar 20%. Dokumentasi BroadNet memberi 1.000 token atau lebih sebagai batas bawah; OpenAI menyarankan menyisihkan 25.000 saat mulai memakai model-modelnya.

### Apakah max\_tokens yang lebih tinggi lebih mahal?

Tidak dengan sendirinya. Anda ditagih untuk token yang dihasilkan model, bukan untuk plafonnya. Plafon yang lebih tinggi hanya lebih mahal jika balasan itu sebenarnya akan terpotong, dan dalam kasus itu balasan terpotong tetap akan membuat Anda membayar retry.

### Apakah max\_completion\_tokens sama dengan max\_tokens?

Di OpenAI, max\_completion\_tokens menggantikan max\_tokens yang sudah deprecated dan secara eksplisit mencakup token penalaran. Banyak penyedia kompatibel OpenAI justru mendokumentasikan max\_tokens. Dokumentasi BroadNet memakai max\_tokens dan menyatakan penalaran dihitung di dalamnya.

### Bisakah saya membatasi penalaran terpisah dari jawaban?

Hanya jika server mendukungnya. vLLM punya parameter thinking\_token\_budget, dan beberapa penyedia punya parameter sendiri. BroadNet mendokumentasikan reasoning\_effort yang diatur ke low, bukan batas penalaran terpisah, jadi anggarkan keduanya bersama.

## Baca juga

-   [Token penalaran: mengapa Anda membayar output lebih dari yang terlihat](https://broadrouter.com/id/blog/reasoning-tokens-cost/)
-   [Penjelasan streaming LLM: chunk SSE, delta, usage, dan pembatalan](https://broadrouter.com/id/blog/llm-streaming-sse-explained/)
-   [JSON mode vs json\_schema: output terstruktur yang andal](https://broadrouter.com/id/blog/structured-output-json-schema/)
-   [Agent yang berjalan lama: timeout, retry, dan checkpoint yang andal](https://broadrouter.com/id/blog/long-running-agents-timeouts-retries/)
-   [Pindah ke API kompatibel OpenAI: checklist migrasi](https://broadrouter.com/id/blog/openai-compatible-api-migration-checklist/)
-   [Hardware GPU dan pendekatan serving BroadNet, menurut BroadNet](https://broadrouter.com/id/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache respons API LLM untuk memangkas biaya: exact cache di Python](https://broadrouter.com/id/blog/cache-llm-responses-cut-cost/)
-   [Panduan: Kenapa model reasoning mengembalikan jawaban kosong](https://broadrouter.com/id/guides/reasoning-tokens-empty-response/)
-   [Panduan: Streaming chat completions dan menangani koneksi terputus](https://broadrouter.com/id/guides/streaming-chat-completions/)
-   [Panduan: Memakai OpenAI Python SDK dengan BroadNet Inference](https://broadrouter.com/id/guides/openai-python-sdk/)

Coba dengan beban kerja Anda yang sebenarnya. Akun baru mendapat kredit US$5 untuk Gemma dan transkripsi. DeepSeek, GLM, dan Qwen3.8 memerlukan top up.

[Mulai](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-reasoning-model-max-tokens-budget&utm_content=page-cta) ·

**Sumber**

-   [Referensi API BroadNet Inference: penalaran dihitung dalam max\_tokens, 1.000 token atau lebih, reasoning\_effort low, field usage (diakses 2026-11-15) (bahasa Inggris)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-reasoning-model-max-tokens-budget&utm_content=sources)
-   [Referensi field pricing.json BroadNet: context\_length mencakup prompt dan jawaban sekaligus (diakses 2026-11-15) (bahasa Inggris)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-reasoning-model-max-tokens-budget&utm_content=sources#pricing-json)
-   [Panduan reasoning OpenAI: respons tidak lengkap, sisihkan setidaknya 25.000 token saat memulai (diakses 2026-11-15)](https://developers.openai.com/api/docs/guides/reasoning)
-   [Referensi Chat Completions OpenAI: max\_completion\_tokens mencakup token penalaran; max\_tokens sudah deprecated (diakses 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [Dokumentasi API DeepSeek, thinking mode: field reasoning\_content, tingkat effort (diakses 2026-11-15)](https://api-docs.deepseek.com/guides/thinking_mode)
-   [Dokumentasi vLLM, reasoning outputs: field reasoning (dulu reasoning\_content), thinking\_token\_budget (diakses 2026-11-15)](https://docs.vllm.ai/en/latest/features/reasoning_outputs.html)
