Deepthink: multi-agent solution search with a solution pool that injects wrong artifacts on purpose

The problem Deepthink targets: one LLM pass is not a search

A single prompt gets you a single trajectory. If that trajectory is wrong, the model tends to correct it inside the same frame of reference, which is why the README describes the ordinary execution, critique, correction loop as something that "never works with LLMs" and leaves them stuck in what it calls a cognitive loop. Deepthink is built for people who want to spend inference compute on exploring several solution paths at once rather than on making one path longer. The stated goal is to scale test-time compute for any problem or benchmark and push the frontier. That framing matters: this is not a coding assistant or a chat wrapper. It is infrastructure for running a search over candidate solutions, and it assumes you can define a challenge precisely enough that independent agents can attack it from different angles. The audience is engineers and researchers who already run multi-agent experiments and are willing to configure agent roles, iteration counts and routing rules.

Strategies, hypotheses and information packets: the three parallel tracks

The Deepthink flow starts from a user-supplied challenge or from files placed in the virtual environment. From there the system generates high-level, distinct strategies, which the README compares to parallel branches that each attempt the same core challenge through a different approach. In parallel, it generates hypotheses about the challenge and tests each one independently. The README gives concrete examples of what a hypothesis can be: testing an uncertainty, or solving a smaller case and checking whether the result transfers to a larger one. The point of testing hypotheses up front is token economy. Once an agent has tested something with full attention, the branch agents do not have to spend tokens reasoning about it again. The output of that testing is packaged as an information packet, and if a packet is resolved to a specific strategy it is called a sub-packet. The routing is deliberate: hypotheses are usually generated with awareness of which strategies will run, so the packets can be aimed at the branches that will actually use them. This is the part of the design I find most defensible. Precomputing shared facts and handing them to parallel workers is a normal way to avoid duplicated reasoning, and describing the unit of transfer as a packet with a routing rule is clearer than most multi-agent READMEs manage.

The structured solution pool is the design bet worth arguing about

Each branch runs execution, then critique, then correction. Before correction, Deepthink inserts a separate agent whose only job is to assemble a structured solution pool for that branch. The pool contains artifacts, independent blocks, correction approaches, logic fragments, alternative improvements and complete alternative solutions. The README is explicit that these are not necessarily correct, rigorous or complete, and that the pool can contain wrong artifacts. That is the intended mechanism, described as random structured noise inside a sanity boundary. The claim is that showing a model explicitly executed wrong approaches removes a cognitive restraint and makes it consider implementation paths it would otherwise only entertain in a chain of thought without ever committing to. Whether that holds for your workload is an empirical question this repository does not answer for you, and no benchmark number appears in the supplied material. Treat it as a hypothesis about model behaviour, not a settled result. The correction agent then receives the previous work, the critique, the available information packet, the branch solution pool and curated cross-strategy context.

The meta loop: refreshing hypotheses, memory banks and pruning

Above the per-branch loop sits a control layer. After every k iterations the system refreshes hypotheses and therefore information packets. At certain iterations it distills history into memory banks recording what worked, what improved and which critique patterns persisted. It can also update the main strategies themselves after a quality filter, using the degree to which critique and correction cycle without a large delta as the signal that a branch is stuck or that the strategy itself is flawed. The post quality filter decides whether a branch continues, is refined, or is replaced. When a replacement happens, the README states that the complete old branch is archived under Pruned_Strategies/Strategy-N_First_PQF, with ordinal successors for later prunes, before fresh active slot directories are created. That archival behaviour is a real operational detail: pruning is destructive to the active slot but not to the history, which means a long run accumulates pruned branch directories you have to manage. The final step collects corrections and sends them to a final judge, which selects the best execution.

Sandbox execution and the final_output contract

When the Sandbox Terminal Environment is enabled, every Deepthink role receives sandbox_exec and final_output. Agents use sandbox_exec for iterative exploration and testing, then submit completed work through final_output. The contract is role-specific: roles that produce JSON submit their existing role-specific JSON object directly through final_output, and the environment validates that contract inside the tool loop. If validation fails, it returns a correction error without discarding the agent's research. Downstream agents and the central system receive only the submitted artifact, so intermediate command transcripts and scratchpad data are filtered out. That filtering is the reason the contract exists at all. Without it, a branch's shell history would leak into every downstream prompt. The repository layout during a run uses Strategy-N/{Critique,SolutionPool} for active branches, with execution and correction writing direct branch files, critique owning Critique and the pool owning SolutionPool. Hypothesis tests are organized by Hypothesis-vN, and only the currently routed tests are mounted to branch workers. The README says this layout is largely scaffolding and that a cleaner solution is in progress, so expect the paths to move.

Running it, and the Adaptive mode that skips the final judge

The supplied README does not include install commands, environment variable names or a configuration file example. It points to Deepthink/DeepthinkDocs.md for agent contracts, repository schemas, mode behavior, iteration synchronization and failure policy, and notes that the previous diagram is archived at Deepthink/OldSystemArchitecture.png. The concrete keys that do appear are sandbox_exec and final_output, plus the directory names Strategy-N, Critique, SolutionPool, Hypothesis-vN and Pruned_Strategies. Provider support is stated as all major providers plus local models, without naming them. Adaptive Deepthink is the second mode and differs in a way that matters: it is orchestrator-directed and pass-based, and it has no separate final judge. Its worker topology pairs a Strategy Generator with Strategies Proximity and a Hypothesis Generator with Hypothesis Proximity, plus Test Hypothesis and the Execution to Critique to Correction chain for each selected strategy. Each generation and proximity pair runs a bounded three-round internal revision loop. If you want the judge to pick a winner, you need the first mode, not this one.

Where Deepthink is the wrong tool, and what to use instead

The clearest limitation is stated by the project itself: Deepthink mode is in huge refactoring, and the sandbox repository structure is described as largely scaffolding. Building on it now means tracking a moving target, and the README's own pointer to a cleaner solution in progress is a warning about interface stability. The second limitation is cost shape. Every iteration fans out into strategy branches, each branch runs execution, critique, solution pool generation and correction, and on top of that there are hypothesis tests and periodic refreshes. The README's token-economy argument is about avoiding duplicated reasoning, not about reducing total spend, and the system is explicitly aimed at scaling test-time compute upward. If your task has one obviously correct answer that a single careful pass handles, this pipeline adds coordination overhead and produces nothing you could not get more cheaply. If you want a simpler comparison point, take a single-agent loop that runs generate, critique, revise until a stopping condition: it has no strategy branching, no hypothesis packets and no cross-branch context, which means far less orchestration code and no pruning bookkeeping, but also no mechanism to escape a branch that is stuck on a bad approach. Deepthink's whole premise is that the escape mechanism is worth the extra agents.

Maintenance, licence and what to check before adopting

The repository is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are included. That is a permissive licence and it is the only licence fact the supplied material supports; it says nothing about the licences of the model providers you connect to, and those terms apply separately to your inference calls. Maintenance cost here is not dependency churn so much as prompt and contract churn. The agent contracts live in DeepthinkDocs.md, the JSON roles must satisfy a validation contract enforced inside the tool loop, and the active branch directories are recreated on pruning while old branches are archived. Any change to a role's output shape ripples through the validation step and through every downstream consumer, which is why the docs file is the first thing to read. The last push recorded is 2026-09-05 and no releases were retrieved, so there is no versioned artifact to pin against. Verify the contracts in DeepthinkDocs.md, confirm which mode you are running, and check whether the sandbox layout has already changed from the Strategy-N and Hypothesis-vN scheme described here before you write any integration code against those paths.

Editorial conclusion

Adopt Deepthink if you are comfortable reading DeepthinkDocs.md before running anything, and if the problem you have is one where several plausible solution paths can be generated and judged against each other. Do not adopt it if you need a stable interface today: the README labels Deepthink mode as a huge refactoring in progress and describes the sandbox repository layout as largely scaffolding. Before wiring it into anything, verify three things in the repository: the agent contracts in Deepthink/DeepthinkDocs.md, the exact final_output contract for each JSON-producing role, and which operational mode you are actually running, because Adaptive Deepthink has no separate final judge while Deepthink does.

Official sources

1. Issues
2. License: MIT
3. README
4. ryoiki-tokuiten/Deepthink on GitHub