Enables AI agents to perform advanced reasoning by generating, judging, ranking, and mutating candidate answers using the OpenDeepThink algorithm.
Also known as linxule/deepthonk
- Stars
- 0
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 0.4.0
- Last commit
- Nov 9, 2026
- License
- MIT
What is DeepThonk MCP?
DeepThonk enables AI agents to perform advanced reasoning by generating, judging, ranking, and mutating candidate answers using the OpenDeepThink algorithm.
Summary generated from the project's README
About DeepThonk MCP server
DeepThonk provides a way for AI agents to perform complex reasoning by implementing the OpenDeepThink algorithm. It works by running a population of candidate answers through a cycle of pairwise judging, Bradley-Terry ranking, and critique-guided mutation. This approach allows agents to achieve high-quality results for difficult tasks like coding, planning, or verifiable reasoning by using breadth and judgment rather than a single expensive model call.
The server can be used locally via a CLI or as an MCP server connected to hosts like Claude Desktop, Cursor, or Claude Code. It supports various providers, including DeepSeek and any OpenAI-compatible endpoint. Users can configure specific models for different roles, such as a fast model for generation and a stronger model for judging. The system requires API keys provided through environment variables in the host process.
Agents can interact with the engine through specific tools to plan budgets, start background runs, poll status, or inspect intermediate artifacts. Every step of the process, including scores, comparisons, and population snapshots, is exposed as an MCP resource for full transparency during the reasoning process.
What you can do with it
- 1Estimate reasoning costsAn agent can use the plan tool to calculate the number of model calls and sequential rounds required for a specific profile before starting a paid run.
- 2Refine existing answersAn agent can take a single candidate answer and apply critique-guided mutation to improve its quality.
- 3Rank multiple candidate solutionsA user can provide a set of potential answers to be ranked using pairwise judging and the Bradley-Terry algorithm.
Written from the project's README. Every use case is checked against a quote from it.
How to install DeepThonk MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall DeepThonk MCP in Claude Code
$ claude mcp add --env 'DEEPSEEK_API_KEY=<YOUR_DEEPSEEK_API_KEY>' --env 'DEEPTHONK_API_KEY=<YOUR_DEEPTHONK_API_KEY>' --env 'OPENROUTER_API_KEY=<YOUR_OPENROUTER_API_KEY>' deepthonk -- npx -y deepthonkInstall DeepThonk MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"deepthonk": {
"command": "npx",
"args": [
"-y",
"deepthonk"
],
"env": {
"DEEPSEEK_API_KEY": "<YOUR_DEEPSEEK_API_KEY>",
"DEEPTHONK_API_KEY": "<YOUR_DEEPTHONK_API_KEY>",
"OPENROUTER_API_KEY": "<YOUR_OPENROUTER_API_KEY>"
}
}
}
}Install DeepThonk MCP in VS Code
.vscode/mcp.json
{
"servers": {
"deepthonk": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"deepthonk"
],
"env": {
"DEEPSEEK_API_KEY": "<YOUR_DEEPSEEK_API_KEY>",
"DEEPTHONK_API_KEY": "<YOUR_DEEPTHONK_API_KEY>",
"OPENROUTER_API_KEY": "<YOUR_OPENROUTER_API_KEY>"
}
}
}
}Install DeepThonk MCP in VS Code CLI
$ code --add-mcp '{"name":"deepthonk","type":"stdio","command":"npx","args":["-y","deepthonk"],"env":{"DEEPSEEK_API_KEY":"<YOUR_DEEPSEEK_API_KEY>","DEEPTHONK_API_KEY":"<YOUR_DEEPTHONK_API_KEY>","OPENROUTER_API_KEY":"<YOUR_OPENROUTER_API_KEY>"}}'Install DeepThonk MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"deepthonk": {
"command": "npx",
"args": [
"-y",
"deepthonk"
],
"env": {
"DEEPSEEK_API_KEY": "<YOUR_DEEPSEEK_API_KEY>",
"DEEPTHONK_API_KEY": "<YOUR_DEEPTHONK_API_KEY>",
"OPENROUTER_API_KEY": "<YOUR_OPENROUTER_API_KEY>"
}
}
}
}Install DeepThonk MCP in Codex
$ codex mcp add deepthonk --env 'DEEPSEEK_API_KEY=<YOUR_DEEPSEEK_API_KEY>' --env 'DEEPTHONK_API_KEY=<YOUR_DEEPTHONK_API_KEY>' --env 'OPENROUTER_API_KEY=<YOUR_OPENROUTER_API_KEY>' -- npx -y deepthonkInstall DeepThonk MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.deepthonk] command = "npx" args = ["-y", "deepthonk"] [mcp_servers.deepthonk.env] DEEPSEEK_API_KEY = "<YOUR_DEEPSEEK_API_KEY>" DEEPTHONK_API_KEY = "<YOUR_DEEPTHONK_API_KEY>" OPENROUTER_API_KEY = "<YOUR_OPENROUTER_API_KEY>"
Install DeepThonk MCP in Gemini CLI
$ gemini mcp add -s user -e 'DEEPSEEK_API_KEY=<YOUR_DEEPSEEK_API_KEY>' -e 'DEEPTHONK_API_KEY=<YOUR_DEEPTHONK_API_KEY>' -e 'OPENROUTER_API_KEY=<YOUR_OPENROUTER_API_KEY>' deepthonk npx -- -y deepthonkInstall DeepThonk MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"deepthonk": {
"command": "npx",
"args": [
"-y",
"deepthonk"
],
"env": {
"DEEPSEEK_API_KEY": "<YOUR_DEEPSEEK_API_KEY>",
"DEEPTHONK_API_KEY": "<YOUR_DEEPTHONK_API_KEY>",
"OPENROUTER_API_KEY": "<YOUR_OPENROUTER_API_KEY>"
}
}
}
}Configuration
DEEPSEEK_API_KEYSecretAPI key for the DeepSeek provider. Optional: omit to use MCP sampling or another provider.
DEEPTHONK_API_KEYSecretAPI key for a custom openai-compatible provider endpoint. Optional.
OPENROUTER_API_KEYSecretAPI key for the OpenRouter provider. Optional: omit to use MCP sampling or another provider.
DEEPTHONK_CONFIGPath to config.yaml. Defaults to ~/.config/deepthonk/config.yaml.
DEEPTHONK_PROFILES_DIRDirectory of custom profile YAML files. Defaults to the config directory's profiles/.
| Name | Description | |
|---|---|---|
| DEEPSEEK_API_KEY | API key for the DeepSeek provider. Optional: omit to use MCP sampling or another provider. | Secret |
| DEEPTHONK_API_KEY | API key for a custom openai-compatible provider endpoint. Optional. | Secret |
| OPENROUTER_API_KEY | API key for the OpenRouter provider. Optional: omit to use MCP sampling or another provider. | Secret |
| DEEPTHONK_CONFIG | Path to config.yaml. Defaults to ~/.config/deepthonk/config.yaml. | |
| DEEPTHONK_PROFILES_DIR | Directory of custom profile YAML files. Defaults to the config directory's profiles/. |
Automated checks
Ran Nov 14, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablelinxule/deepthonk is public and reachablegithub.com/linxule/deepthonk ↗Pass
- Package names this repository as its sourcedeepthonk names linxule/deepthonk as sourcenpmjs.com/package/deepthonk ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for deepthonknpmjs.com/package/deepthonk/v/0.4.0#provenance ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-09github.com/linxule/deepthonk ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from deepthonkPass
- No critical advisory in the package or its dependencies12 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubDeepThonk
thonk harder, not richer.
DeepThonk implements the OpenDeepThink algorithm (Zhou et al., 2026, arXiv:2605.15177) as a budget-friendly, provider-neutral "deep think / pro mode" wrapper, with first-class DeepSeek support. See Acknowledgments.
DeepThonk runs a population of candidate answers through pairwise judging, Bradley-Terry ranking, critique-guided mutation, elite preservation, and a final dense ranking pass. The CLI and MCP server both call the same TypeScript core engine.
Designed for agents. Every algorithm dimension — population shape (n, k, t, m), regularization (lambda), per-phase temperatures, prompt style, and per-phase prompt templates — is reachable inline through MCP arguments and CLI flags. CLI can load prompt files with --prompts or inline JSON with --prompts-json; MCP accepts inline structured prompt args. Every intermediate artifact (config, candidates, populations, comparisons, scores, per-call usage, status) is exposed as an MCP resource so an agent can inspect any step. See Customization for the full agent-composable surface.
Use it for hard, verifiable reasoning, coding, planning, and synthesis where breadth plus judgment can beat one expensive single shot. Avoid it for highly subjective tasks where judge noise dominates.
Quickstart
Requires Node ≥ 22.13.
Run without installing:
npx -y deepthonk plan --profile paper
npx -y deepthonk run --provider fake --profile quick \
--task "Find the smallest positive integer divisible by 3, 4, and 5." \
--out runs/test-quick
npx -y deepthonk inspect runs/test-quick
Or install globally:
npm install -g deepthonk
deepthonk plan --profile paper
The paper profile plans 285 model calls and 8 sequential rounds. Confirm budget and provider pricing before pointing it at paid models. The short alias dt is installed alongside deepthonk. Develop from source: see Development.
DeepThonk is an independent TypeScript reimplementation and practical integration layer; the published algorithm is the load-bearing part. Cost guarantees rely on provider pricing being present in config. Trace-v2 resume can reuse validated per-item receipts after a crash, while older traces replay an incomplete phase wholesale. The MCP HTTP transport remains loopback-only. The included acceptance smoke uses the deterministic fake provider and a toy task — it is not a CF-73 / HLE reproduction; see
docs/and Acknowledgments for the canonical paper and Python reference.
Setup
Create a reusable local config:
deepthonk setup \
--provider deepseek \
--api-key-env DEEPSEEK_API_KEY \
--fast-model deepseek-v4-flash \
--judge-model deepseek-v4-pro
By default this writes ~/.config/deepthonk/config.yaml. deepthonk run loads that file automatically when --config is not supplied. If you pass --api-key, setup stores it in ~/.config/deepthonk/env; otherwise it uses the named environment variable from your shell.
DeepSeek
export DEEPSEEK_API_KEY=...
deepthonk run \
--task task.md \
--profile paper \
--provider deepseek \
--generator-model deepseek-v4-flash \
--mutator-model deepseek-v4-flash \
--judge-model deepseek-v4-pro \
--out runs/task-paper
DeepSeek is implemented as an OpenAI-compatible profile using https://api.deepseek.com/v1. DeepThonk ships default USD pricing for deepseek-v4-flash and deepseek-v4-pro from the official DeepSeek pricing page, including cache-hit/cache-miss input rates. Model names and prices are still editable config because both can change.
Before paid runs, inspect cost shape and resolved config:
deepthonk plan --config ~/.config/deepthonk/config.yaml
deepthonk run --task task.md --config ~/.config/deepthonk/config.yaml --profile quick --dry-run
Start with --profile quick and consider --max-concurrency, --max-calls, --max-input-tokens, --max-output-tokens, --max-usd, and --request-timeout-ms before larger paid profiles. max_calls is reserved before dispatch and counts logical model invocations, including failed calls and invalid-JSON retries; provider-internal HTTP retries are reported separately. Token/USD totals are known only after responses and can overshoot by at most the active concurrency window. Plans keep nominal calls separate from finalizer and retry headroom in worst_case_calls.
OpenAI-Compatible Providers
export DEEPTHONK_API_KEY=...
deepthonk run \
--task task.md \
--profile balanced \
--provider openai-compatible \
--base-url https://provider.example.com/v1 \
--api-key-env DEEPTHONK_API_KEY \
--generator-model cheap-model \
--judge-model strong-model
The driver calls POST {base_url}/chat/completions and requests JSON mode for comparisons when supported. If a provider returns 400 or 422 with a body that mentions response_format or json, the driver retries without JSON mode, coordinates that capability probe across concurrent calls, and remembers the result for the process. Set supports_json_mode: false in YAML to disable JSON mode up front.
Provider names are flexible. For a custom OpenAI-compatible endpoint, use any provider label with --base-url, --api-key-env, and role-specific model flags. For OpenRouter:
export OPENROUTER_API_KEY=...
deepthonk run \
--task task.md \
--profile balanced \
--provider openrouter \
--generator-model openrouter/auto \
--mutator-model openrouter/auto \
--judge-model openrouter/auto
For mixed-provider runs, use YAML config and override individual roles under providers, especially judge.
Optional finalizer_model / --finalizer-model can post-process the ranked winner. Leave it unset when you want the raw ranked answer as the final artifact.
MCP
The MCP server exposes the same engine the CLI runs. Once wired into an MCP host, the host can plan budgets, kick off background runs, poll status, fetch winners, and stream structured trace artifacts — all through MCP tools, resources, and prompts.
DeepThonk is listed on the MCP Registry as io.github.linxule/deepthonk (since v0.2.1). Hosts that install by registry name resolve it to npx deepthonk serve-mcp automatically. For hosts that don't, the explicit configs below do the same thing by hand.
Provider API keys come from the host process's environment, not from DeepThonk's config alone. Each host handles env passthrough slightly differently — see the concrete patterns below. No key is required to start the server: with a sampling-capable host you can run provider: "sampling", and the fake provider needs no network at all.
MCP Sampling is supported as provider: "sampling" when the connected host advertises the MCP sampling capability. Blocking run, rank, and mutate work over stdio and stateful Streamable HTTP. HTTP background start rejects Sampling because nested Sampling must remain attached to the initiating request; stdio background runs and direct-provider HTTP background runs remain available. Sampling is not available from standalone CLI runs.
Claude Code
claude mcp add deepthonk \
-e DEEPSEEK_API_KEY=$DEEPSEEK_API_KEY \
-- npx -y deepthonk serve-mcp --transport stdio
Use -s user for cross-project scope or -s project to commit registration into .claude/. Verify with claude mcp list. See claude mcp --help for the authoritative flag set.
Claude Desktop
Config path: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS), %APPDATA%\Claude\claude_desktop_config.json (Windows), ~/.config/Claude/claude_desktop_config.json (Linux). Add:
{
"mcpServers": {
"deepthonk": {
"command": "npx",
"args": ["-y", "deepthonk", "serve-mcp", "--transport", "stdio"],
"env": {
"DEEPSEEK_API_KEY": "sk-..."
}
}
}
}
Restart Claude Desktop after editing.
Cursor
Project-scoped: .cursor/mcp.json in the workspace. User-global: ~/.cursor/mcp.json. Same JSON shape as Claude Desktop:
{
"mcpServers": {
"deepthonk": {
"command": "npx",
"args": ["-y", "deepthonk", "serve-mcp", "--transport", "stdio"],
"env": { "DEEPSEEK_API_KEY": "sk-..." }
}
}
}
Other MCP hosts (stdio)
Any host that speaks MCP stdio launches:
npx -y deepthonk serve-mcp --transport stdio
with the relevant provider env vars set on the process. If you'd rather install globally, npm install -g deepthonk then use command: "deepthonk" directly. Refer to the host's MCP registration docs for the configuration shape.
Streamable HTTP
For local web hosts, or when stdio isn't available:
deepthonk serve-mcp --transport http --port 3333 \
--max-active-jobs 2 --max-queued-jobs 32
The server binds 127.0.0.1:3333 only and exposes stateful POST, GET, and DELETE at http://127.0.0.1:3333/mcp. Sessions use cryptographic IDs, expire after 30 idle minutes when no request is active, and are capped at 64. DNS rebinding protection is on (CVE-2025-66414): requests with Host headers outside 127.0.0.1:3333 / localhost:3333 are rejected. The wrapper also rejects non-JSON POSTs, non-loopback Origin headers, and Sec-Fetch-Site: cross-site before reading the body. It has no bearer auth. Do not expose this port through a reverse proxy without re-evaluating that trust boundary.
Tools
| Tool | Purpose |
|---|---|
deepthonk.plan |
Estimate calls and sequential rounds for a profile (no model calls). Use before paid runs. |
deepthonk.start |
Start a run in the background; returns run_dir, job_id, and job-scoped artifact resources. |
deepthonk.status |
Poll job status from a run_dir. |
deepthonk.result |
Return final summary + winner once a job is complete. |
deepthonk.cancel |
Request cancellation by writing cancel.json into the run directory. |
deepthonk.lock_inspect / deepthonk.lock_reclaim |
Inspect lock ownership and explicitly reclaim only an exact fingerprint. |
deepthonk.repair_budget |
Replace legacy [redacted] numeric budget fields with explicit original values. |
deepthonk.run |
Blocking convenience: start + await completion in one call. Prefer start + polling for long-running jobs. |
deepthonk.rank |
Rank a user-supplied candidate set with pairwise judging + Bradley-Terry (skip generation). |
deepthonk.mutate |
Mutate one supplied candidate with critique (one-shot). |
deepthonk.resume |
Detect whether a run can be resumed; with continue: true, replay from the last validated phase boundary. |
deepthonk.export |
Export run summary or full trace in JSON or markdown. |
deepthonk.profile_list |
List saved named profile bundles. |
deepthonk.profile_show |
Show one saved profile; manually edited secret-shaped values are rejected on load. |
deepthonk.profile_save |
Save a reusable named profile bundle. |
deepthonk.profile_delete |
Delete a saved named profile bundle. |
All tools accept inline provider/model fields, or config_path pointing at a DeepThonk YAML config.
Resources
deepthonk://runs— JSON index of all runs inruns/.deepthonk://runs/{run_id}/summary— run summary (JSON).deepthonk://runs/{run_id}/config— redacted run config (JSON).deepthonk://runs/{run_id}/{candidates|comparisons|scores|usage|trace}— per-phase and per-call NDJSON.deepthonk://runs/{run_id}/population/{generation}— population snapshot for a generation (JSON).deepthonk://runs/{run_id}/{winner|final}— text artifacts.deepthonk://runs/{run_id}/status— run state (JSON).deepthonk://runs/{run_id}/prompts/{sha256}— verified content-addressed rendered prompt (JSON).deepthonk://runs/{run_id}/trace-v2— bounded phase index; follow its manifest, commit, checkpoint-index, and checkpoint URIs to inspect every receipt.deepthonk://jobs/{job_id}/{status|result|config|candidates|comparisons|scores|usage|trace|final|winner}?run_dir=...— job-scoped lookup; therun_dirquery param is required.deepthonk://jobs/{job_id}/population/{generation}?run_dir=...— job-scoped population snapshots before or after completion.- Job results also include
prompt_templateandtrace_v2_templatefor the job-scoped equivalents. deepthonk://runs/{run_id}/{resource}/page/{cursor}and job equivalents — opaque bounded pages. Whole reads are limited to 1 MiB; pages contain at most 1,000 records and 1 MiB.
Prompts
Four templates mirror the core loop: deepthonk/generate, deepthonk/compare, deepthonk/mutate, deepthonk/finalize. Hosts can render them directly to drive the algorithm by hand without invoking the tool surface.
Limits
deepthonk.resume reports trace state by default. With continue: true, it validates phase order, artifacts, run/provider/model identity, scores, usage, deterministic pair schedules, trace-v2 receipts, and phase commits. Valid incomplete-phase receipts are reused without another provider call. MCP Sampling model hints are preferences and token usage may be unavailable. Its shared adaptive limiter starts at 4; direct providers start at 8.
Customization
Every algorithm dimension is reachable through MCP arguments and CLI flags:
- Population shape:
n,k,t,m— override profile defaults inline. - Algorithm constants:
lambda,sample_temperature,mutate_temperature,judge_temperature. - Prompt style:
generalorpaper-programming. - Per-phase prompt templates: override
generate,compare,mutate, orfinalizewith custom system/user templates and variable substitution ({task},{rubric},{candidate},{candidateA},{candidateB},{critique}). CLI supports--prompts <yaml>and--prompts-json <json>; MCP supports inlineprompts. Unknown variables throw a fail-fast error at run-start. - Concurrency: per-phase caps for
generate,judge,mutate. - Provider backpressure:
provider_max_concurrencysets the recovery ceiling for the shared adaptive provider-route limiter. - Per-call output bounds: independent generation, mutation, judge, and finalizer token caps.
- Final ranking schedule: seeded
all-pairsork-regular, with an explicit logical call cap. - Critique bound: deterministic deduplication and a configurable aggregate-character cap before mutation.
Example agent call (MCP), no YAML file required:
{
"task": "Draft a concise non-solicitation clause for a senior sales employee.",
"profile": "balanced",
"n": 6, "t": 1,
"provider": "deepseek",
"judge_model": "deepseek-v4-pro",
"prompts": {
"generate": { "system": "You are an experienced employment-law attorney." },
"compare": { "system": "Prefer enforceable clauses under California law. Return strict JSON only." }
}
}
CLI accepts the same surface. Use --prompts <yaml> for reusable prompt files or --prompts-json <json> for one-off inline overrides. MCP and CLI both merge over any --config/config_path YAML defaults.
Save reusable bundles as named profiles at ~/.config/deepthonk/profiles/<name>.yaml and load them with --profile-name <name> (CLI) or profile_name: "<name>" (MCP). A named profile is a standalone bundle that replaces the main config file for that run; CLI flags and MCP inline arguments still override fields inside it. See examples/profiles/legal-drafting.yaml for the shape. The Customization guide covers listing, showing, saving, and deleting named profiles from both CLI and MCP.
See the Customization guide for the complete variable contract, the compare-phase JSON safety rule, the named-profile schema, and three worked examples. Per-role provider routing (providers.judge.provider = openrouter) and per-model pricing remain YAML-only — they're nested structured config, not inline ergonomics.
Trace Files
A successful run writes:
runs/{run_id}/
config.json
events.jsonl
candidates.jsonl
comparisons.jsonl
scores.jsonl
usage.jsonl
population-0.json
population-{generation}.json
manifests/*.json
checkpoints/*/*.json
commits/*.json
summary.json
artifacts/winner.txt
artifacts/final.txt
artifacts/prompts/<sha256>.json # only when prompt capture is enabled
status.json is written when the run is launched through MCP deepthonk.start (so async clients can poll). cancel.json is written only when cancellation is requested. A run.lock file is held for the duration of the run.
Trace rows are batch-appended through a single writer and flushed before lifecycle boundaries. Per-item output and usage receipts are written atomically before a phase commit. If a run is killed mid-tournament, trace-v2 resume validates and reuses completed receipts, re-materializes their JSONL rows, and calls the provider only for missing or invalid work.
usage.jsonl carries one row per provider call (generator, judge, mutator, finalizer) with phase/role/provider/model/token/USD/latency/retry. It contains no prompt content. jq over usage.jsonl is the simplest way to break a run's cost down by role.
Prompts and raw model outputs are off by default. When prompt capture is enabled, candidate/comparison rows carry a promptRef and identical rendered prompts share one content-addressed blob under artifacts/prompts/; the full prompt is not repeated in every JSONL row or receipt. API keys are never written. Candidate answers, critiques, scores, and final artifacts are trace data and are stored/exported by design, so do not use a shared run directory for sensitive tasks unless that is acceptable.
Development
pnpm install
pnpm run build
pnpm test
pnpm run lint
This repository is source-only. Generated run traces, paper notes, build output, coverage, logs, and node_modules are intentionally ignored.
Release publishing is tag-triggered through npm Trusted Publishing. See docs/release.md before bumping versions or pushing a v* tag.
Known limits for this release:
- Trace-v1 resume replays an interrupted phase wholesale; per-item reuse requires a trace-v2 run created by DeepThonk v0.2.
- HTTP Sampling is blocking-only. Use stdio or a direct provider for background
deepthonk.startwork. maxUsdrequires known model pricing; add explicit prices in YAML for custom providers and model IDs. Optional fieldslongContextThresholdTokens,inputUsdPerMillionLong, andoutputUsdPerMillionLongenable tiered pricing for models with a long-context surcharge (e.g., Gemini at 200K input tokens). Cache hit/miss rates remain flat.
Acknowledgments
DeepThonk is an independent TypeScript reimplementation of the OpenDeepThink algorithm. It is not a fork; no source code from the reference implementation is vendored. Credit for the algorithm, the benchmark methodology, and the empirical results belongs to the paper authors.
- Paper: Shang Zhou, Wenhao Chai, Kaiyuan Liu, Huanzhi Mao, Qiuyang Mang, Jingbo Shang. OpenDeepThink: Parallel Reasoning via Bradley–Terry Aggregation. arXiv:2605.15177, 2026. https://arxiv.org/abs/2605.15177
- Reference Python implementation: https://github.com/ZhouShang0817/open-deep-think (MIT). This is the authors' code release and the canonical implementation for reproducing paper results (CF-73, HLE).
DeepThonk's contribution is an integration layer: a provider-neutral TypeScript core, an MCP server, a CLI, structured trace artifacts, and budget enforcement. The algorithm itself is theirs.
DeepThonk MCP questions
How do I add DeepThonk MCP to Claude Code?
Run claude mcp add --env 'DEEPSEEK_API_KEY=<YOUR_DEEPSEEK_API_KEY>' --env 'DEEPTHONK_API_KEY=<YOUR_DEEPTHONK_API_KEY>' --env 'OPENROUTER_API_KEY=<YOUR_OPENROUTER_API_KEY>' deepthonk -- npx -y deepthonk in your terminal. Add --scope user to make it available in every project.
How do I add DeepThonk MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What can I use DeepThonk for?
It is designed for hard, verifiable reasoning, coding, planning, and synthesis tasks where breadth and judgment improve results.
How do I manage API keys for different providers?
You can set up a local config using the setup command, or pass provider API keys through the host process's environment variables.
Can I estimate the cost of a reasoning run before executing it?
Yes, you can use the plan tool to estimate the number of model calls and sequential rounds required for a specific profile without making actual model calls.
Does it support OpenAI-compatible endpoints?
Yes, it supports any provider that uses an OpenAI-compatible interface by specifying a base URL and API key.