Thinking Budget Orchestrator

---
name: thinking-budget-orchestrator
description: "Dynamic thinking budget orchestrator across late-2026 frontier models / Alokasi budget penalaran dinamis pada model frontier 2026."
author: "Roedy Rustam"
version: "4.8.0"

---

# thinking-budget-orchestrator — vibes-plug Skill

[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)

---

<a name="english"></a>
## English

### Orchestration & Integration
- **Upstream & Task Lifecycle**: `zero-to-prod-orchestrator` (Phase 4 AI agent integration), `brainstorming`, `session-memory-manager`.
- **Reasoning Scaling & Search**: `test-time-compute-optimizer` (MCTS & process reward models), `multi-agent-orchestration` (swarm reasoning budgets).
- **Frontier LLMs & Model Boosters**: `frontier-ai-models-expert` (Grok 4.7, Composer 2.5, Gemini 4 Argon, GPT-5.6 Sol, Claude Sonnet 5.5, Muse Wonder), `gemini-agent-booster` (native Gemini thinking allocation).
- **FinOps & Adaptive Execution**: `adaptive-model-cascade` (complexity threshold routing), `llm-finops-router` (cost tracking & budget caps), `kv-cache-prefix-optimizer` (cache locking).

### Description
Production architecture for dynamically allocating and controlling reasoning thinking tokens (Extended Thinking / Test-Time Compute) across late-2026 frontier models. Instead of static uniform token limits that either starve complex formal verifications or waste massive token budgets on simple queries, this skill evaluates structural task signals (AST blast radius, security boundaries, multi-agent topologies) and applies calibrated reasoning envelopes:
- `speed` (1K tokens): Ultra-fast AST checks, typos, documentation, and single unit tests (`Grok 4.7 High Fast`, `Composer 2.5 Fast`).
- `balanced` (8K tokens): Standard fullstack features, component assembly, and API contracts (`Gemini 4 Argon Medium`, `GPT-5.6 Sol Medium`, `Claude Opus 5.5 Medium` — fallback: `Gemini 3.8 Flash`, `Claude Opus 4.6`).
- `deep` (32K tokens): Multi-domain architecture refactoring, security audits, and generative UI synthesis (`Claude Sonnet 5.5 High`, `Claude Fable 5.1 High`, `Muse Wonder High`).
- `exhaustive` (64K tokens): Cryptographic proofs, SMT invariant solving, and distributed race-condition auditing (`Claude Sonnet 5.5 High`, `Gemini 4 Pro Deep Think` — fallback: `Gemini 3.8 Flash`).

### Hard Guardrails (Declarative Invariants)
- **Heuristic-Driven Thinking Envelope**: Extended thinking token budgets must be dynamically assigned based on AST blast radius and domain sensitivity (`speed` = 1,024, `balanced` = 8,192, `deep` = 32,768, `exhaustive` = 65,536). Static uniform token allocations across heterogeneous tasks are prohibited.
- **Mission-Critical Thinking Floor**: High-consequence tasks (FinTech billing state machines, cryptographic verification, formal SMT invariant proofs, security red-teaming) must NEVER disable thinking (`thinkingBudget: 0`) and must enforce a floor of $\ge 32,768$ thinking tokens (`deep` or `exhaustive`).
- **Leaf Worker Budget Pruning**: In multi-agent swarm topographies, leaf workers executing deterministic file reading, linting, or formatting must be constrained to `speed` ($1,024$) or `balanced` ($8,192$) profiles to avoid token waste.
- **Prompt Cache Prefix Invariant**: Thinking budget configurations must be passed via provider runtime options (`thinkingBudget`, `budget_tokens`, `reasoning_effort`) without altering the canonical system prompt, preventing KV-cache prefix invalidation.

### Non-Functional Requirements (NFR Contract)
- **Allocation Latency**: Complexity heuristic evaluation and budget profile resolution must complete within $< 10\text{ ms}$.
- **FinOps Optimization**: Dynamic budget envelopes must yield $\ge 50\%$ cost reductions on non-critical turn executions.

### Trigger Conditions
Activate this skill when:
- Designing prompt chains or agents utilizing models with thinking budget controls (e.g., `thinking: { type: "enabled", budget_tokens: N }` or `thinkingBudget: N`).
- Running multi-agent swarms where leaf worker agents require lightweight budgets while root critic agents require deep reasoning.
- Tuning inference latency and token expenditure across Grok 4.7, Gemini 4 Argon, GPT-5.6 Sol, Claude Sonnet 5.5, and Muse Wonder.
- Automating verification for high-consequence tasks (FinTech billing, cryptographic state machines, security audits).

---

### Core Concepts & Reasoning Profiles

```
TASK INGESTION
      │
      ▼
┌───────────────────────────┐
│ HEURISTIC COMPLEXITY AST  │  Extract signals: blast radius, keywords, dependencies
└─────────────┬─────────────┘
              │
  ┌───────────┼───────────┬───────────┐
  ▼           ▼           ▼           ▼
SPEED     BALANCED      DEEP      EXHAUSTIVE
(1,024)    (8,192)    (32,768)     (65,536)
  │           │           │           │
Grok 4.7 /  Gemini 4    Claude 5.5  Claude 5.5
Composer    Argon /     Sonnet /    Sonnet /
2.5 Fast    GPT-5.6 Sol Muse Wonder Gemini 4 Pro
```

#### 1. Token Budget Allocation Matrix

| Profile | Token Budget | Target Workload | Frontier Model Mapping |
|---|---|---|---|
| `speed` | 1,024 tokens | AST queries, documentation lookup, typos, single unit tests | Grok 4.7 High Fast / Composer 2.5 Fast |
| `balanced` | 8,192 tokens | Feature implementation, component assembly, standard CRUD | Gemini 4 Argon Medium / GPT-5.6 Sol Medium / Claude Opus 5.5 Medium *(Fallback: Gemini 3.8 Flash / Claude Opus 4.6)* |
| `deep` | 32,768 tokens | Architecture synthesis, cross-domain migrations, security audits, generative layout | Claude Sonnet 5.5 High / Claude Fable 5.1 High / Muse Wonder High |
| `exhaustive` | 65,536 tokens | Cryptographic verification, SMT invariant proving, distributed sagas | Claude Sonnet 5.5 High / Gemini 4 Pro Deep Think *(Fallback: Gemini 3.8 Flash)* |

#### 2. Native Multi-Provider Payload Generation (TypeScript)

```typescript
export type ReasoningProfile = 'speed' | 'balanced' | 'deep' | 'exhaustive';

export interface ThinkingConfig {
  profile: ReasoningProfile;
  budgetTokens: number;
}

export const BUDGET_TOKENS: Record<ReasoningProfile, number> = {
  speed: 1024,
  balanced: 8192,
  deep: 32768,
  exhaustive: 65536,
};

export function resolveThinkingBudget(task: string, userOverride?: ReasoningProfile): ThinkingConfig {
  const profile = userOverride || detectTaskComplexity(task);
  return {
    profile,
    budgetTokens: BUDGET_TOKENS[profile] || BUDGET_TOKENS.balanced,
  };
}

function detectTaskComplexity(task: string): ReasoningProfile {
  const lower = task.toLowerCase();
  if (/(invariant|formal|pqc|smt|z3|crypto|zero-day|exploit|consensus)/.test(lower)) return 'exhaustive';
  if (/(security|audit|red-team|refactor|migration|payment|gateway|doku|stripe|generative-ui)/.test(lower)) return 'deep';
  if (/(typo|lint|format|doc|readme|comment|ast-scan)/.test(lower)) return 'speed';
  return 'balanced';
}

export function formatProviderThinkingPayload(
  provider: 'anthropic' | 'google' | 'openai' | 'xai',
  config: ThinkingConfig
) {
  switch (provider) {
    case 'anthropic':
      return {
        thinking: {
          type: 'enabled',
          budget_tokens: config.budgetTokens,
        },
      };
    case 'google':
      return {
        generationConfig: {
          thinkingConfig: {
            thinkingBudget: config.budgetTokens,
          },
        },
      };
    case 'openai':
      return {
        reasoning_effort: config.budgetTokens >= 32768 ? 'high' : config.budgetTokens >= 8192 ? 'medium' : 'low',
      };
    case 'xai':
      return {
        thinking_mode: config.budgetTokens >= 8192 ? 'system2' : 'fast',
      };
    default:
      return {};
  }
}
```

---

### Best Practices

1. **Leaf Workers Use `speed` Profile**: Subagents performing file inspections or running test commands should never consume >1K thinking tokens.
2. **Critics and Auditors Use `deep` Profile**: Subagents reviewing pull requests, auditing security boundaries, or validating type safety must receive 32K thinking envelopes.
3. **Guard High Budgets with Circuit Breakers**: If a deep thinking call fails twice, do not retry with 64K tokens; step down to balanced mode and log telemetry.
4. **Coordinate Thinking Budget with KV-Cache**: Place dynamic thinking envelopes inside request configs while keeping system prompt prefixes statically cached.
5. **Availability Fallback Envelopes**: If Gemini 4 (Argon/Pro) is temporarily unprovisioned or quota-limited, automatically redirect thinking envelopes to Gemini 3.8 Flash. If Claude Opus 5.5 is unavailable, redirect reasoning workloads to Claude Opus 4.6.

### Sovereign Execution, Token Efficiency & Invariants
| Dimension | Sovereign Mandate & Deterministic Contract |
| :--- | :--- |
| **Frontier Model Cascade** | Medium / High (`GPT-5.6 Sol Medium`, `Gemini 4 Argon`, `Claude Sonnet 5.5 High`, `Grok 4.7 High Fast`) |
| **Availability Fallback** | `Gemini 4 Argon/Pro` -> `Gemini 3.8 Flash`; `Claude Opus 5.5` -> `Claude Opus 4.6` (Zero unhandled missing-model errors) |
| **KV-Cache & Token Protocol** | Pin static instructions & schemas at prompt prefix (`kv-cache-prefix-optimizer`); pass surgical `CONTEXT_MAP.md` slices (<250 tokens/call) during Swarm Fan-Out |
| **SaaT CLI & MCP Dispatch** | CLI: `vibes skill exec thinking-budget-orchestrator <audit\|eval\|verify\|generate\|blueprint>` / MCP: `vibes_skill_dispatch`, `vibes_ast_query`, `vibes_compile_cache`, `vibes_optimize_budget`, `vibes_verify_gate` |
| **NFR & Anti-Slop Invariants** | P99 API Gateway Latency < 85ms, OpenAPI 3.1 / TypeSpec strict schema parity, RFC 9457 Problem Details error contracts, Idempotency-Key enforcement; 100% complete zero-placeholder output verified via `node scripts/check-anti-slop.js --strict` |

---


---

<a name="bahasa-indonesia"></a>
## Bahasa Indonesia

### Integrasi Orkestrasi
- **Hulu & Siklus Hidup Tugas**: `zero-to-prod-orchestrator` (Integrasi agen AI Fase 4), `brainstorming`, `session-memory-manager`.
- **Penskalaan Penalaran & Pencarian**: `test-time-compute-optimizer` (MCTS & process reward models), `multi-agent-orchestration` (budget penalaran swarm).
- **LLM Frontier & Booster Model**: `frontier-ai-models-expert` (Grok 4.7, Composer 2.5, Gemini 4 Argon, GPT-5.6 Sol, Claude Sonnet 5.5, Muse Wonder), `gemini-agent-booster` (alokasi thinking Gemini native).
- **FinOps & Eksekusi Adaptif**: `adaptive-model-cascade` (routing ambang kompleksitas), `llm-finops-router` (pelacakan biaya & batas anggaran), `kv-cache-prefix-optimizer` (penguncian cache).

### Deskripsi
Arsitektur produksi untuk mengalokasikan dan mengendalikan token penalaran (*Extended Thinking* / *Test-Time Compute*) secara dinamis di seluruh LLM frontier akhir 2026. Alih-alih menggunakan batas token statis seragam yang membuang biaya komputasi atau membatasi penalaran mendalam pada sistem kritis, skill ini mengevaluasi sinyal struktural tugas dan menerapkan profil reasoning terkalibrasi:
- `speed` (1K token): Pemindaian AST kilat, typo, dokumentasi, dan unit test tunggal (`Grok 4.7 High Fast`, `Composer 2.5 Fast`).
- `balanced` (8K token): Fitur fullstack standar, perakitan komponen, dan kontrak API (`Gemini 4 Argon Medium`, `GPT-5.6 Sol Medium`, `Claude Opus 5.5 Medium` — fallback: `Gemini 3.8 Flash`, `Claude Opus 4.6`).
- `deep` (32K token): Refaktor arsitektur lintas domain, audit keamanan, dan sintesis UI generatif (`Claude Sonnet 5.5 High`, `Claude Fable 5.1 High`, `Muse Wonder High`).
- `exhaustive` (64K token): Pembuktian invarian matematis/SMT dan audit race-condition terdistribusi (`Claude Sonnet 5.5 High`, `Gemini 4 Pro Deep Think` — fallback: `Gemini 3.8 Flash`).

### Hard Guardrails (Invarian Deklaratif - Bahasa Indonesia)
- **Envelope Penalaran Berbasis Heuristik**: Alokasi token penalaran *Extended Thinking* wajib ditentukan secara dinamis berdasarkan radius dampak AST dan sensitivitas domain (`speed` = 1.024, `balanced` = 8.192, `deep` = 32.768, `exhaustive` = 65.536). Alokasi batas seragam statis dilarang keras.
- **Ambang Bawah Penalaran Tugas Kritis**: Tugas berkonsekuensi tinggi (state machine billing FinTech, verifikasi kriptografi, pembuktian invarian SMT formal, audit keamanan) TIDAK BOLEH menonaktifkan thinking (`thinkingBudget: 0`) dan wajib menetapkan batas bawah minimal $\ge 32.768$ token thinking (`deep` atau `exhaustive`).
- **Pemangkasan Budget Daun Swarm**: Pada topologi swarm multi-agen, agen pelaksana (daun) yang menjalankan pembacaan berkas deterministik atau formatting wajib dibatasi pada profil `speed` ($1.024$) atau `balanced` ($8.192$) guna mencegah pemborosan token.
- **Invarian Prefix Prompt Cache**: Konfigurasi budget penalaran harus diteruskan melalui opsi runtime provider (`thinkingBudget`, `budget_tokens`, `reasoning_effort`) tanpa mengubah teks prompt sistem kanonikal, menjaga validitas prefix KV-cache.

### Non-Functional Requirements (Kontrak NFR - Bahasa Indonesia)
- **Latensi Resolusi**: Evaluasi heuristik kompleksitas dan penetapan profil budget harus selesai dalam waktu $< 10\text{ ms}$.
- **Optimalisasi FinOps**: Penerapan alokasi budget dinamis harus mampu menghemat biaya token $\ge 50\%$ pada giliran non-kritis.

### Kondisi Pemicu
- Merancang alur agen yang memanfaatkan kontrol thinking budget native API.
- Menjalankan swarm multi-agen di mana subagen pelaksana membutuhkan budget ringan sedangkan agen auditor membutuhkan budget mendalam.
- Mengoptimalkan efisiensi biaya token dan latensi P99 pada pipeline AI enterprise.
- Memvalidasi logika berisiko tinggi (state machine finansial, billing SaaS, kriptografi).

### Implementasi Pola Kunci Alokasi Budget Penalaran (TypeScript)

```typescript
export type ProfilPenalaran = 'speed' | 'balanced' | 'deep' | 'exhaustive';

export interface KonfigurasiPenalaran {
  profil: ProfilPenalaran;
  budgetTokens: number;
}

export function tentukanBudgetPenalaran(deskripsiTugas: string): KonfigurasiPenalaran {
  const teks = deskripsiTugas.toLowerCase();

  // 1. Tugas formal matematika/kriptografi: Berikan budget maksimal
  if (/(invarian|formal|pqc|smt|z3|kriptografi|konsensus)/.test(teks)) {
    return { profil: 'exhaustive', budgetTokens: 65536 };
  }
  // 2. Audit keamanan, payment, UI generatif, dan migrasi arsitektur: Budget mendalam
  if (/(keamanan|audit|red-team|refaktor|migrasi|payment|doku|stripe|generative-ui)/.test(teks)) {
    return { profil: 'deep', budgetTokens: 32768 };
  }
  // 3. Perbaikan typo, formatting, dan dokumentasi: Budget super cepat
  if (/(typo|lint|format|dokumentasi|readme|ast-scan)/.test(teks)) {
    return { profil: 'speed', budgetTokens: 1024 };
  }
  // 4. Default pengembangan fitur fullstack: Budget seimbang
  return { profil: 'balanced', budgetTokens: 8192 };
}
```

### Matriks Eksekusi Berdaulat, Efisiensi Token & Invarian
| Dimensi | Mandat Berdaulat & Kontrak Deterministik |
| :--- | :--- |
| **Kaskade Model Frontier** | Medium / High (`GPT-5.6 Sol Medium`, `Gemini 4 Argon`, `Claude Sonnet 5.5 High`, `Grok 4.7 High Fast`) |
| **Invarian Fallback Ketersediaan** | `Gemini 4 Argon/Pro` -> `Gemini 3.8 Flash`; `Claude Opus 5.5` -> `Claude Opus 4.6` (Bebas gagal saat model belum tersedia/kuota penuh) |
| **Protokol Hemat Token & KV-Cache** | Kunci instruksi & skema statis di prefix awal (`kv-cache-prefix-optimizer`); kirim potongan `CONTEXT_MAP.md` (<250 token/panggilan) saat Fan-Out |
| **Eksekusi SaaT CLI & MCP** | CLI: `vibes skill exec thinking-budget-orchestrator <audit\|eval\|verify\|generate\|blueprint>` / MCP: `vibes_skill_dispatch`, `vibes_ast_query`, `vibes_compile_cache`, `vibes_optimize_budget`, `vibes_verify_gate` |
| **Invarian NFR & Anti-Slop** | Latensi P99 API < 85ms, paritas skema ketat OpenAPI 3.1 / TypeSpec, kontrak error RFC 9457 Problem Details, penegakan Idempotency-Key; kode 100% tuntas tanpa placeholder diverifikasi melalui `node scripts/check-anti-slop.js --strict` |