Install command
Not provided
agentsSource-backedReview first Safety · Privacy ✓
Extended Thinking Orchestrator - Agents
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.
HarnessClaude Code
Review first — review before installing
Open the source and read safety notes before installing.
Citation facts
Source-backed facts for citing this resource, derived directly from the registry — also available as plain text for AI assistants.
- Source URLs
- https://platform.claude.com/docs/en/build-with-claude/extended-thinking, https://github.com/JSONbored/awesome-claude/blob/main/content/agents/extended-thinking-orchestrator.mdx
- 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.
- Author
- JSONbored
- Claim status
- unclaimed
- Last verified
- 2025-10-25
Decision playbook
Review trust signals before you adopt
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.
Compare context
Selected
0
Current score
68
Baseline
—
Delta
No baseline selected
No major trust-signal divergence detected in the current selection.
Source and provenance checks
CompleteConfirm ownership and provenance before trusting install instructions.
- Done
Source link availableRequired
Open the canonical repository and verify ownership.
- Done
Source provenance statusRequired
Marked as source-backed.
- Done
Metadata reviewed
Registry metadata indicates a reviewed listing.
Safety and privacy checks
Required checks missingValidate risk disclosures before installation or API wiring.
- Pending
Safety notes presentRequired
No safety notes listed.
- Done
Privacy notes presentRequired
Review data handling notes before connecting accounts or secrets.
- Done
Trust level risk gateRequired
Trust level does not block evaluation.
Package and install checks
Needs reviewCheck package metadata and artifact integrity signals.
- Done
Install payload available
Install or copy payload is available for review.
- Pending
Package verification flag
No package verification flag provided.
- Pending
Checksum metadata
No checksum provided for downloaded artifact.
Compare-driven decision checks
Needs reviewUse compare context to validate trade-offs before adoption.
- Pending
Compare tray has multiple entries
Add at least one more entry to compare trust differences.
- Pending
Baseline comparison available
No baseline peer selected yet.
- Pending
Diverging trust signals identified
No major trust-signal divergence found.
Setup at a glance
Copy & paste
Copy-ready — paste the snippet to get started.
Config snippet
Not provided
Copy snippet
Provided
Prerequisites
None
Platforms
1 listed
Difficulty
100/100
Adoption plan
Balanced adoption plan
Current risk score 30/100. Use staged verification before broader rollout.
Adoption blockers
- Safety notes are missing.
Pre-adoption checks
Validate source and review signals before any execution.
- Done
Confirm source provenanceRequired
Source URL/provenance metadata is present.
- Done
Confirm metadata review state
Listing has review metadata.
- Done
Verify install payload
Install/config payload exists and can be inspected.
Security checks
Confirm safety, privacy, and package integrity signals.
- Pending
Review safety notesRequired
Safety notes missing; review source code paths before execution.
- Done
Review privacy notesRequired
Privacy notes are present.
- Pending
Verify package integrity metadata
No package verification/checksum metadata.
Rollout
Adopt in controlled steps based on the selected plan.
- Pending
Run in isolated sandbox firstRequired
Use a constrained sandbox and observe behavior across multiple tasks.
- Pending
Roll out graduallyRequired
Roll out to a small cohort before wider usage.
- Pending
Set monitoring and fallback
Define rollback path and monitor errors after adoption.
Evidence readiness
Evidence readiness matrix · balanced
Missing required evidence: Safety notes. Risk score 31.
Source provenance
PresentSource repository/provenance is listed.
Required in this preset
Metadata review
PresentReview metadata is present.
Required in this preset
Safety notes
MissingSafety notes are missing.
Required in this preset
Privacy notes
PresentPrivacy notes are present.
Optional in this preset
Package integrity
MissingPackage integrity metadata is missing.
Optional in this preset
Install payload
PresentInstall payload is available.
Required in this preset
Required gaps: Safety notes
Decision timeline
Decision timeline · balanced
Blocking gaps: Review safety notes. Risk 28.
triage
Confirm source provenanceRequired
Source/provenance metadata is available.
triage
Check metadata review statusRequired
Review metadata is available.
verify
Review safety notesRequired
Safety notes are missing.
verify
Review privacy notes
Privacy notes are available.
verify
Validate package integrity metadata
Package integrity metadata is missing.
rollout
Verify install payload and commandsRequired
Install payload is available.
Blockers: Review safety notes
Safety & privacy surface
Safety & privacy surface
1 privacy note across 1 risk area. Review closely: credentials & tokens.
- PrivacyCredentials & tokensExtended 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.
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.
Schema details
- Install type
- copy
- Reading time
- 5 min
- Difficulty score
- 100
- Troubleshooting
- Yes
- Breaking changes
- No
Skill and platform metadata
Retrieval sources
https://platform.claude.com/docs/en/build-with-claude/extended-thinkinghttps://code.claude.com/docs/en/best-practices
Full copyable content
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.About this resource
What this agent does
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.
What extended thinking is
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.
Choosing the right depth
| 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.
Working with the API
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.
Troubleshooting
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).
Best practices
- Match depth to genuine difficulty, not to how important the task feels.
- Escalate with a focused follow-up ("think harder about the concurrency edge cases") rather than re-running everything at maximum depth.
- Treat the keyword levels as relative; don't quote specific token budgets you can't verify.
- For unattended or batch runs, pick a fixed depth per task type so cost stays predictable.
Source citations
Add this badge to your README
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)How it compares
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 | Claude Code | Claude Code | Claude Code | Claude Code |
| 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 |
Signals
Loading live community signals…
More like this, weekly
A short, calm digest of reviewed Claude resources. Unsubscribe any time.