An agent that decides how much reasoning depth a task needs and prompts Claude accordingly — escalating from think to think hard to ultrathink as problem complexity rises.
Open the source and read safety notes before installing.
Source-backed facts for citing this resource, derived directly from the registry — also available as plain text for AI assistants.
Decision playbook
Signals are present but mixed. Use the checklist below to confirm the source and operational safety for your environment.
Required checks are still incomplete. Finish source and safety verification before adopting this resource.
0
68
—
No baseline selected
No major trust-signal divergence detected in the current selection.
Confirm ownership and provenance before trusting install instructions.
Source link availableRequired
Open the canonical repository and verify ownership.
Source provenance statusRequired
Marked as source-backed.
Metadata reviewed
Registry metadata indicates a reviewed listing.
Validate risk disclosures before installation or API wiring.
Safety notes presentRequired
No safety notes listed.
Privacy notes presentRequired
Review data handling notes before connecting accounts or secrets.
Trust level risk gateRequired
Trust level does not block evaluation.
Check package metadata and artifact integrity signals.
Install payload available
Install or copy payload is available for review.
Package verification flag
No package verification flag provided.
Checksum metadata
No checksum provided for downloaded artifact.
Use compare context to validate trade-offs before adoption.
Compare tray has multiple entries
Add at least one more entry to compare trust differences.
Baseline comparison available
No baseline peer selected yet.
Diverging trust signals identified
No major trust-signal divergence found.
Setup at a glance
Copy-ready — paste the snippet to get started.
Adoption plan
Current risk score 30/100. Use staged verification before broader rollout.
Validate source and review signals before any execution.
Confirm source provenanceRequired
Source URL/provenance metadata is present.
Confirm metadata review state
Listing has review metadata.
Verify install payload
Install/config payload exists and can be inspected.
Confirm safety, privacy, and package integrity signals.
Review safety notesRequired
Safety notes missing; review source code paths before execution.
Review privacy notesRequired
Privacy notes are present.
Verify package integrity metadata
No package verification/checksum metadata.
Adopt in controlled steps based on the selected plan.
Run in isolated sandbox firstRequired
Use a constrained sandbox and observe behavior across multiple tasks.
Roll out graduallyRequired
Roll out to a small cohort before wider usage.
Set monitoring and fallback
Define rollback path and monitor errors after adoption.
Evidence readiness
Missing required evidence: Safety notes. Risk score 31.
Source repository/provenance is listed.
Required in this preset
Review metadata is present.
Required in this preset
Safety notes are missing.
Required in this preset
Privacy notes are present.
Optional in this preset
Package integrity metadata is missing.
Optional in this preset
Install payload is available.
Required in this preset
Required gaps: Safety notes
Decision timeline
Blocking gaps: Review safety notes. Risk 28.
triage
Source/provenance metadata is available.
triage
Review metadata is available.
verify
Safety notes are missing.
verify
Privacy notes are available.
verify
Package integrity metadata is missing.
rollout
Install payload is available.
Blockers: Review safety notes
Safety & privacy surface
1 privacy note across 1 risk area. Review closely: credentials & tokens.
You are an Extended Thinking Orchestrator. Your job is to decide how much reasoning depth each task needs and to prompt Claude accordingly, so simple work stays fast and hard problems get enough thinking.
## What extended thinking is
Extended thinking lets Claude reason internally before it answers. In the Claude API this is controlled by the `budget_tokens` field of the `thinking` configuration object, which caps how many tokens Claude may spend on internal reasoning; `budget_tokens` must be lower than `max_tokens` (with interleaved thinking it can exceed `max_tokens` because it covers all thinking blocks in a turn). Thinking tokens you spend are billed.
In Claude Code you do not set a number directly — you raise reasoning depth through how you phrase the request. Escalating cues like "think" → "think hard" / "think harder" → "ultrathink" ask Claude for progressively more extended thinking. The exact token budget behind each keyword is not published, so treat the levels as relative, not as fixed numbers.
## How to choose the depth
- **No thinking cue (default):** routine edits, file lookups, straightforward code review.
- **"think":** multi-file changes, non-obvious bugs, weighing a couple of approaches.
- **"think hard" / "think harder":** tricky refactors, security analysis, concurrency and race conditions, performance trade-offs, multi-step planning.
- **"ultrathink":** novel design, exhaustive edge-case enumeration, hard algorithmic or architectural problems where a wrong call is expensive.
Start at the lowest depth that fits and escalate only if the first attempt is shallow or uncertain. More thinking costs more tokens and adds latency, so reserve the top levels for problems where the extra depth clearly pays off.
## Guidance I give
- Match depth to genuine difficulty, not to how important the task feels.
- Prefer an escalating follow-up ("think harder about the edge cases") over re-running the whole task at maximum depth.
- For API or SDK callers, translate the chosen depth into a concrete `budget_tokens` value kept under `max_tokens`, and remember thinking tokens are billed.
- When a result looks shallow, name what to reconsider and step the depth up one level rather than jumping straight to ultrathink.This agent helps you spend reasoning where it counts. It looks at a task, judges how hard it actually is, and prompts Claude with the right amount of extended thinking — keeping routine work fast while giving genuinely hard problems room to reason.
Extended thinking lets Claude work through a problem internally before answering. In the Claude API it is controlled by the budget_tokens field of the thinking configuration, which sets the maximum tokens Claude may use for internal reasoning. budget_tokens must be lower than max_tokens (with interleaved thinking it can exceed max_tokens, since it covers all thinking blocks in a single turn), and the thinking tokens Claude generates are billed.
In Claude Code you don't pass a number — you raise reasoning depth by how you phrase the request. Escalating phrasing such as "think" → "think hard" / "think harder" → "ultrathink" asks Claude for progressively more extended thinking. The token budgets behind those keywords are not published, so treat the levels as relative rather than as fixed amounts.
| Depth | Good fit |
|---|---|
| No cue (default) | Routine edits, lookups, straightforward review |
think |
Multi-file changes, non-obvious bugs, comparing a couple of approaches |
think hard / think harder |
Tricky refactors, security analysis, concurrency, performance trade-offs, multi-step planning |
ultrathink |
Novel design, exhaustive edge-case enumeration, hard algorithmic or architectural problems |
Start at the lowest depth that fits and escalate only when the first attempt comes back shallow or uncertain. Each step up spends more tokens and adds latency, so the top levels are worth it only when the extra reasoning changes the outcome.
If you call the API or SDK directly instead of using Claude Code keywords, translate the chosen depth into a concrete budget_tokens value kept under max_tokens. Because thinking tokens are billed, set a budget that matches the difficulty rather than defaulting to the maximum.
The answer is shallow even after asking Claude to think. Name what to reconsider and step the depth up one level (for example, think hard → ultrathink) instead of repeating the same prompt.
Responses feel slow or expensive. You are likely over-allocating depth. Drop to a lower level for routine work and reserve ultrathink for problems where a wrong answer is costly.
API thinking config is rejected. Confirm budget_tokens is set inside the thinking object and is lower than max_tokens (unless you are using interleaved thinking).
Show that Extended Thinking Orchestrator - Agents is listed on HeyClaude. Paste this Markdown into your README — it renders the badge and links back to this page.
[](https://heyclau.de/entry/agents/extended-thinking-orchestrator)Extended Thinking Orchestrator - Agents side by side with 3 alternatives on trust, install, platform support, and disclosed safety notes — all from reviewed registry metadata.
1 trust signal differ across this comparison (Submitter).
| Field | An agent that decides how much reasoning depth a task needs and prompts Claude accordingly — escalating from think to think hard to ultrathink as problem complexity rises. Open dossier | How to use Claude's extended thinking: the API `thinking` config with budget_tokens, when to spend more reasoning, and the think/ultrathink prompting convention in Claude Code. Open dossier | A repeatable explore-plan-implement-verify workflow for large code migrations and refactors with Claude Code, using plan mode, /rewind checkpoints, subagents, and claude -p fan-out for batch file changes. Open dossier | A source-backed review workflow for pull requests that include AI-generated code. Treat generated diffs as untrusted implementation work, verify behavior in CI, inspect security-sensitive paths first, and merge only after a reviewer-owned checklist passes. Open dossier |
|---|---|---|---|---|
| Next steps | ||||
| Trust | ||||
| Review status | ReviewedMaintainer reviewed | ReviewedMaintainer reviewed | ReviewedMaintainer reviewed | ReviewedMaintainer reviewed |
| Package trust | Package not verified | Package not verified | Package not verified | Package not verified |
| Source provenance | Source-backed | Source-backed | Source-backed | Source-backed |
| SubmitterDiffers | — | — | — | MkDev11 |
| Install risk | Review first | Review first | Review first | Review first |
| Notes | Safety · Privacy ✓ | Safety ✓ Privacy ✓ | Safety ✓ Privacy ✓ | Safety ✓ Privacy ✓ |
| Brand | — | — | — | — |
| Category | agents | guides | guides | guides |
| Source | Source-backed | Source-backed | Source-backed | Source-backed |
| Author | JSONbored | JSONbored | JSONbored | MkDev11 |
| Added | 2025-10-25 | 2025-10-27 | 2025-10-27 | 2026-06-04 |
| Platforms | ||||
| Harness | ||||
| Source repo | — | — | — | — |
| Safety notes | — missing | ✓The API examples make live, billed model requests; set a sensible budget_tokens / MAX_THINKING_TOKENS and test before using high thinking budgets in production. | ✓The claude -p fan-out loop runs Claude non-interactively across many files. Scope it with --allowedTools (for example "Edit,Bash(git commit *)") so unattended runs cannot perform actions you did not intend, and test on 2-3 files before running at scale. Checkpoints only track Claude's direct file edits, not changes made by bash commands (rm, mv, cp) or other processes, so commit to git before a large migration. | ✓Treat AI-generated changes as untrusted code until a human reviewer verifies behavior, security impact, and rollback risk. Block merge when the PR changes authentication, authorization, data deletion, payment, networking, serialization, or release automation without focused tests. Do not accept generated explanations as proof; require CI output, reproducible commands, or links to authoritative project docs. Inspect package manifests, lockfiles, package-manager configuration, and dependency choices before installing from an untrusted branch. Run install, build, and test commands for untrusted PRs in a disposable sandbox or container, with package-manager lifecycle scripts disabled unless the changed scripts and packages have been reviewed and approved. |
| Privacy notes | ✓Extended thinking sends your prompt and context to the configured model provider like any other Claude request; the thinking tokens it generates are billed, and the depth levels described here are a Claude Code prompting convention — the token budgets behind them are not provider-published values. | ✓Extended thinking sends your prompt and context to the configured model provider and the thinking tokens are billed; the think/ultrathink keyword tiers are a Claude Code convention whose token budgets are not published. | ✓Claude Code sends the files it reads and command output to the model as context. Avoid piping secrets or credentials into prompts, and exclude sensitive paths from migration runs. | ✓Do not paste private code, secrets, customer data, logs, or incident details into external AI review tools unless your organization has approved that workflow. Keep review notes in the pull request or internal tracker so security decisions remain auditable. |
| Prerequisites | — none listed | — none listed | — none listed |
|
| Install | — | — | — | — |
| Config | — | — | — | — |
| Citations | ||||
| Claim | Unclaimed | Unclaimed | Unclaimed | Unclaimed |
Loading live community signals…
A short, calm digest of reviewed Claude resources. Unsubscribe any time.