# How the ADHD Architecture Addresses Premature Convergence in AI Reasoning

> Discover how ADHD architecture prevents premature convergence in AI reasoning by isolating idea generation and evaluation into distinct phases, ensuring robust and diverse outcomes.

- Repository: [Udit Akhouri/adhd](https://github.com/UditAkhourii/adhd)
- Tags: architecture
- Published: 2026-08-20

---

**ADHD (Adaptive Divergence‑Heavy Design) prevents premature convergence by strictly separating idea generation and evaluation into two isolated phases: parallel divergent branches that never share state, followed by a single critic phase that scores and selects only after all ideas exist.**

The **premature convergence problem** plagues many AI reasoning pipelines—once a language model produces an initial plausible answer, subsequent reasoning tends to anchor on that first output, shutting down exploration of better alternatives. The open-source **ADHD architecture** (`UditAkhourii/adhd`) solves this through a hard architectural boundary between generation and evaluation implemented in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts). This article examines exactly how that two-phase design eliminates early-lock-in.

## The Core Two-Phase Split: Divergence Then Convergence

ADHD's prevention strategy rests on a simple but rigid rule: **convergence happens after divergence, never during**. The engine enforces this through completely separated computational phases.

### Phase 1: Divergence (ADHD-Mode)

In the first phase, the system selects **cognitive frames** and spawns an independent LLM query for each frame. Crucially, as noted in the engine source:

```ts
// src/engine.ts#L4-L6
// Each branch runs in complete isolation—no shared KV-cache,
// no cross-branch visibility, no ranking hints.

```

This **hard wall** between branches means:

- Each generator call uses a fresh, stateless Agent SDK session
- The `DIVERGE_SYSTEM` prompt forbids evaluation or hedging
- Branches output raw JSON ideas only, with no quality assessments

The isolation is mechanically enforced rather than merely suggested. In `src/engine.ts#L61-L70`, every branch receives the same system prompt instruction: generate, do not evaluate.

### Phase 2: Convergence (Critic Mode)

Only after all branches complete does **a single critic call** score, cluster, and deepen the top-K ideas. The engine explicitly states this sequencing in `src/engine.ts#L12-L13`:

```ts
// "Convergence happens after divergence, never during."

```

Because evaluation runs **after** generation, the critic's rankings cannot influence any branch's output. This eliminates the feedback loops that normally cause premature convergence in single-pass or interleaved reasoning systems.

## Mechanical Isolation: How the Engine Enforces Separation

### Stateless Parallel Queries with System Prompt Switching

The architecture uses **distinct system prompts** to mechanically reorient model behavior rather than relying on instruction-following alone.

**For generation** (`src/engine.ts#L61-L70`):

```ts
const raw = await callLLM({
  model,
  systemPrompt: DIVERGE_SYSTEM,  // "You are in DIVERGENT mode..."
  userPrompt,
});

```

The `DIVERGE_SYSTEM` prompt strictly requires JSON-only output and prohibits any evaluation language.

**For evaluation** (`src/engine.ts#L71-L89`):

```ts
const raw = await callLLM({
  model,
  systemPrompt: SCORE_SYSTEM,   // "You are in CONVERGENT mode..."
  userPrompt,
});

```

The `SCORE_SYSTEM` prompt explicitly requests structured scoring across dimensions including novelty, viability, and fit—dimensions the generator was forbidden from considering.

### Controlled Concurrency via Semaphore

To keep divergence tractable without sacrificing isolation, `src/engine.ts#L49-L52` implements a semaphore:

```ts
import pLimit from 'p-limit';
const limit = pLimit(concurrency);  // default: 4 simultaneous branches

```

This caps resource usage while preserving the **statelessness guarantee**—each concurrent branch still operates in complete isolation from others.

## The Three-Step Critic Pipeline: Structured Down-Selection

The convergence phase isn't a single evaluation call. It's a **deliberately sequential pipeline** that prevents premature commitment:

| Step | Function | Purpose |
|------|----------|---------|
| 1. Score | `scoreIdeas` | Quantitative assessment across multiple dimensions |
| 2. Cluster | `clusterIdeas` | Group by underlying angle to detect superficial variation |
| 3. Deepen | `deepenIdea` | Expand only top-K ideas that survived both filters |

This structure ensures **only ideas that pass quantitative scrutiny receive additional computation**. The generator never sees partial scores or intermediate rankings that could bias exploration.

### Trap Detection and Exclusion

The scoring system in `src/engine.ts#L80-L86` specifically flags **traps**—common failure patterns like hidden costs or premature abstractions:

```ts
// From SCORE_SYSTEM prompt excerpt:
// "Flag trap indicators: hidden operational costs, 
//  over-engineering, solution-problem mismatch"

```

Trapped ideas are excluded from the shortlist before the deepening step, preventing the final focused pass from reinforcing problematic directions.

## Practical Implementation

To invoke the complete diverge-then-converge cycle:

```ts
import { run } from "./src/engine.js";

await run({
  problem: "Design a low‑latency server‑less data pipeline",
  framesPerRun: 5,      // 5 diverse cognitive frames
  ideasPerFrame: 6,     // 6 raw ideas per frame
  topK: 3,              // Deepen only top 3 after scoring
  concurrency: 4,       // Parallel isolation ceiling
  stripAnchors: true,   // Remove incidental tech-stack anchors first
});

```

This single call executes the full pipeline: parallel branch spawning with `DIVERGE_SYSTEM`, then sequential `scoreIdeas` → `clusterIdeas` → `deepenIdea` using `SCORE_SYSTEM`.

## Key Architectural Files

| File | Role |
|------|------|
| [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) | Core orchestrator: defines the two-phase loop, isolates branches with `DIVERGE_SYSTEM`/`SCORE_SYSTEM`, implements the three-step critic pipeline |
| [`src/llm.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/llm.ts) | Wrapper around the Claude Agent SDK; provides `callLLM` used by both phases |
| [`src/frames.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/frames.ts) | Supplies cognitive frames that re-pose the problem for each divergent branch |
| [`documentation/how-it-works.md`](https://github.com/UditAkhourii/adhd/blob/main/documentation/how-it-works.md) | Documents the architectural rationale for phase separation (`L5-L18`) |

## Summary

- **Hard phase boundary**: Generation and evaluation never interleave, enforced by [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) architecture
- **Mechanical isolation**: Stateless sessions, no shared KV-cache, distinct system prompts prevent cross-branch influence
- **Structured convergence**: Score → cluster → deepen pipeline ensures quantitative filtering before resource commitment
- **Trap awareness**: Explicit detection of hidden costs and premature abstractions excludes flawed directions early

## Frequently Asked Questions

### How does ADHD differ from simple temperature sampling or majority voting?

Temperature sampling and majority voting operate within a single inference pass or aggregate identical prompts. ADHD's divergence phase uses **cognitive frames** ([`src/frames.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/frames.ts)) to re-pose the problem from fundamentally different angles, and the isolation guarantee means each frame explores without knowledge of others. The critic phase then performs **model-driven selection** rather than statistical aggregation, enabling deeper analysis of why ideas differ.

### Can the critic phase itself introduce premature convergence?

The design specifically constrains the critic: it operates **only on fully generated ideas**, cannot request regeneration, and the deepening step is capped at `topK` ideas. The three-step pipeline (score, then cluster, then deepen) prevents the critic from over-investing in early high scorers before seeing the full distribution. As implemented in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts), the critic selects but does not generate.

### Why use separate system prompts instead of instruction tuning?

System prompt switching provides **runtime behavioral reorientation** without model retraining. The `DIVERGE_SYSTEM` and `SCORE_SYSTEM` prompts in `src/engine.ts#L61-L89` mechanically enforce different output constraints—JSON-only generation versus structured scoring—making the phase boundary inspectable and version-controllable.

### What happens if all divergent branches produce poor ideas?

The scoring system (`src/engine.ts#L80-L86`) includes **trap detection** that flags common failure modes. If no ideas pass the viability threshold, the pipeline returns the scored set without deepening, signaling that the frame selection or problem formulation needs revision. The architecture fails explicitly rather than converging on mediocrity.