Premature Convergence Is an Architecture Problem, Not a Prompting One

The Provocation

The repository is called ADHD. In clinical usage, the acronym describes a neurodevelopmental disorder marked by inattention, impulsivity, and executive dysfunction [1][4][7]. In this repository, it denotes something closer to the opposite: a disciplined refusal to lock onto a single reasoning track. ADHD—Parallel Divergent Ideation for Coding Agents—treats premature convergence as a structural defect in autoregressive models, not a failure of prompt engineering. The name is a wink that doubles as a thesis statement. While a standard language model risks hyperfocusing on its own first guess, this architecture forces the agent to scatter its attention across multiple, mutually ignorant cognitive frames before it is allowed to judge anything.

The attention spike is real. The New Stack ran a feature story on the skill. Repowire, a mesh-orchestrator project, merged a port that maps ADHD’s frames onto temporary peers. A multi-agent community tester, after installing it on two separate agents, confessed they had braced for another useless post and were surprised to find it genuinely useful. When an independent researcher subjects your framework to an eleven-source evidence review with eight validation rounds, the conversation has moved beyond novelty.

Why Chains and Trees Still Anchor

To understand the architectural bet, start with the baseline. Chain-of-thought prompting asks a model to emit intermediate reasoning steps before its final answer. Research demonstrates that this simple change can lift accuracy on grade-school math from under eighteen percent to over fifty-seven, because it aligns the model’s sequential token generation with the sequential structure of the problem [11]. Self-consistency pushes further by sampling multiple reasoning traces and voting on the final answer, though this multiplies both latency and cost [11].

Tree-of-thought generalizes the idea into a branching search. The model explores partial solutions, evaluates them as “sure,” “maybe,” or “impossible,” and backtracks from contradictions using breadth-first or depth-first algorithms [2][5]. It is a genuine advance over linear reasoning, particularly for puzzles where lookahead matters [5].

Yet both frameworks share a subtle vulnerability: they operate within a single shared context. In chain-of-thought, every token conditions on the ones before it, so the model’s first approximation colors everything that follows. In tree-of-thought, branches may be logically distinct, but they typically inhabit the same conversation state. The initial framing, vocabulary, and hidden assumptions remain visible across the tree. As the Prompting Guide notes, even the evaluation of thought candidates happens within that shared conversational memory [5]. The anchoring persists.

The Hard Wall

ADHD treats this as an architecture problem. Its fix is a two-phase loop with a hard wall between generation and judgment.

During divergence, the system selects a set of cognitive frames—deliberately distorted vantage points—and spawns parallel, isolated agent calls. Each call receives the problem description plus exactly one frame’s prompt, along with a system instruction that forbids evaluation. The branches are mutually ignorant. There is no shared context during this phase, which means the first branch’s vocabulary, its seductive wrong turns, and its implicit assumptions cannot leak into the second. The isolation is the point. The documentation distinguishes these frames from personas: a persona asks the same model to role-play, while a frame restructures what the model notices about the problem.

During focus, a separate critic call scores every idea on novelty, viability, and fit. It clusters proposals by underlying angle, flags traps with explicit reasoning, and deepens the top survivors into sketches that include risks and first steps. The generator and critic are not polite roles inside a single prompt; they are separate LLM invocations with opposite system prompts. This mechanical split prevents the model from grading its own homework while still warm from writing it.

The project documents fifteen cognitive frames, though it leaves the full taxonomy to its frames documentation. The concept is what matters: instead of asking one model to wear many hats serially or in a shared chat history, ADHD gives each hat its own isolated process, then brings in a distinct process to audit the results. The skill itself ships with a single-line description kept under six hundred characters specifically because some Codex builds truncate or reject multi-line YAML block descriptions—a small detail that reveals how much the project is optimizing for real-world agent plumbing rather than academic purity.

The Measurements

The project publishes self-run evaluations across six open-ended engineering problems, pitting ADHD against a single-shot baseline using the same underlying model. An independent LLM, prompted to behave as a skeptical staff engineer, judged the outputs with A/B order randomized to reduce positional bias.

The headline numbers are stark. Breadth: 9.00 versus 4.83. Novelty: 7.83 versus 2.67. Trap detection—identifying seductive-but-broken ideas—shows the widest gap: 9.50 against 1.83, a ratio of roughly five to one. Actionability also scores 9.50 against 6.50. On builder usefulness, the most subjective metric, ADHD still edges ahead at 7.67 to 6.83, winning five of the six problems outright.

These figures arrive with appropriate caveats. The judge is an LLM, not a human panel. The problem set is small. The methodology, however, is disclosed: the skeptical-staff-engineer prompt, the randomized ordering, and the per-dimension scoring are all tracked in the repository’s evaluation documentation. The project does not pretend the numbers are final; it treats them as an opening argument.

Adoption and Porting

ADHD ships as a skill installable across roughly fifty agent platforms, from Claude Code and Codex to Cursor, Cline, and Gemini CLI. But the more telling signal is how other open-source projects have remixed the architecture.

Repowire merged a port that translates ADHD’s frames into frame-shifted temporary peers within its mesh orchestrator, mapping the generator-critic split onto separate peers versus the orchestrator’s own turn. Mstack vendored it as a think plugin for architecture, naming, and fuzzy debugging. Zk-flow-oss adapted the frame list into a pre-review critique workflow to reduce anchoring bias before human code review. TestDouble’s Han framework published an eleven-source research application against its own plugin model, tracking findings as open issues. The Nix-skills ecosystem has pinned a package. Even an awesome-prompts repository packaged the loop as a standalone text file for users who cannot install the skill.

This pattern—absorption into orchestrators, critique pipelines, and package managers—suggests the community is treating ADHD as a structural primitive rather than a clever prompt.

The Cost of Parallel Thinking

The architecture is not cheap. Divergence spawns multiple isolated calls. The critic pass adds another. Deepening the survivors adds more. The README explicitly flags cost and speed as tradeoffs in its when-to-use guidance. This overhead mirrors the known cost of self-consistency in chain-of-thought research, where multiple samples and majority voting improve accuracy at the expense of tokens and latency [11].

The project is candid about where it belongs: design decisions, API surface design, fuzzy debugging, naming, strategy, and any prompt shaped like “give me a few ways to…” It does not claim to justify its overhead for boilerplate generation or deterministic refactoring. That honesty is itself a signal of maturity.

Position in the Agent Landscape

Developers currently report juggling Claude Code, Codex, Cursor, Windsurf, and Gemini CLI, often burning through usage limits and credits while searching for reliable workflows [12]. Against this noise, ADHD is not another IDE or chat interface. It is a reasoning micro-architecture that slots into existing agents as a skill, library, or orchestrator primitive.

Its conceptual neighbors are split across two scales. At the macro scale, frameworks like Universal Agent OS extract governance—living plans, task ledgers, validation gates—from large agent projects so that sessions can resume from instructions as small as “continue” [9]. ADHD operates at the micro scale: it governs a single ideation burst, ensuring the agent does not prematurely commit before the governance layer has a plan worth persisting. The two approaches sketch a future where agent reliability depends on both long-term memory and short-term reasoning hygiene.

This bifurcation matters because the agent ecosystem is currently obsessed with context length and session continuity. Projects compete on how much of a codebase can fit into a context window, or how many previous turns the model can remember. ADHD bets that what happens inside a single turn—specifically, how strictly generation is quarantined from evaluation—matters just as much.

Outlook

The project is early. Its frame library is manually authored and currently lists fifteen vantages. Its evaluation suite covers only six problems. The mechanical separation of generator and critic relies on the underlying platform’s context isolation behaving as advertised. The Han research integration has already surfaced open questions tracked as issues against the repository, suggesting the method is being stress-tested rather than merely starred.

Open questions include whether the frames generalize beyond software engineering, whether automated frame generation could replace hand-tuned vantages, and whether a recursive critic phase would reintroduce the very anchoring the architecture seeks to prevent. The author’s preprint frames the work as an invitation to research labs and applied-AI teams working on reasoning and planning.

What is already clear is that the idea has escaped its repository. When other projects port your logic onto their orchestrator primitives, when a Nix packager pins your commit, and when independent researchers run eight validation rounds against your method, the concept is traveling as architecture. The field is slowly accepting that how an agent reasons—specifically, how ruthlessly it separates the act of generation from the act of judgment—may matter as much as the base model’s parameter count.