# How to Configure Different Models for the Critic vs Generator in ADHD

> Learn how to configure separate models for critic and generator in ADHD using CLI flags or RunOptions. Optimize your ADHD model setup effectively.

- Repository: [Udit Akhouri/adhd](https://github.com/UditAkhourii/adhd)
- Tags: how-to-guide
- Published: 2026-07-30

---

**You can configure different models for the critic and generator in ADHD by using the `--critic-model` CLI flag or the `criticModel` property in the `RunOptions` object, while the generator uses the standard `--model` or `model` field.**

The ADHD framework separates creative ideation from critical evaluation through distinct pipeline phases. By default, both the *generator* (which handles the diverge and deepen passes) and the *critic* (which manages scoring and clustering) execute on the same language model. However, as implemented in `UditAkhourii/adhd`, you can override this behavior to use specialized models for each role, decorrelating errors between generation and evaluation.

## Understanding the Generator and Critic Architecture

The ADHD pipeline operates in distinct phases that map to different cognitive roles:

- **Generator**: Executes the *diverge* and *deepen* passes to produce raw ideas and expand them.
- **Critic**: Runs the *score* and *cluster* phases to evaluate idea quality and group similar concepts.

By default, the system passes the same model identifier to both components. To improve result quality or reduce costs, you can assign a high-performance model to the critic while using a faster, cheaper model for generation, or vice versa.

## Command-Line Configuration

The CLI interface in [`src/cli.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/cli.ts) exposes two distinct flags for model selection:

- `--model NAME` – Specifies the model for the generator phase (diverge and deepen). This also serves as the default for the critic if `--critic-model` is omitted.
- `--critic-model NAME` – Specifies a dedicated model for the critic phase (score and cluster).

```bash
adhd run \
  --model claude-sonnet-4-5 \
  --critic-model gpt-4o \
  --problem "Create a low-cost feature-flag system" \
  --ideas-per-frame 6 \
  --top-k 3

```

If `--critic-model` is not provided, the critic automatically falls back to the value specified in `--model`.

## Programmatic Configuration

When integrating ADHD into a Node.js application, the `run` function accepts a `RunOptions` object defined in [`src/types.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/types.ts). This interface includes both `model` and `criticModel` fields:

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

const result = await run({
  problem: "Design a privacy-first analytics dashboard",
  model: "anthropic/claude-3-sonnet-20240229",  // Generator model
  criticModel: "openai/gpt-4o-mini",            // Critic model
  framesPerRun: 5,
  ideasPerFrame: 6,
  topK: 3,
  concurrency: 4,
});

```

The `criticModel` property is optional. When undefined, the system uses the `model` value for both phases.

## Internal Implementation Details

The model selection logic resides in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) at lines 27–30. Here, the pipeline initializes the critic model by checking for an explicit override before falling back to the generator model:

```typescript
// The critic (score + cluster) can run on a different model from the generator.
// Defaults to the generator model.
const critic = criticModel ?? model;

```

According to the ADHD source code, the `critic` constant is then passed to the `scoreIdeas` and `clusterIdeas` functions, while the original `model` value is retained for the diverge and deepen passes. This separation ensures that generation and evaluation occur on potentially different architectures or providers.

## Practical Configuration Examples

### Using Claude for Generation and GPT-4o for Evaluation

This configuration leverages Claude Sonnet's creative capabilities for ideation while using GPT-4o for structured scoring:

```bash
adhd run \
  --problem "How can we reduce onboarding friction?" \
  --model claude-sonnet-4-5 \
  --critic-model gpt-4o \
  --ideas-per-frame 6 \
  --top-k 3

```

### Programmatic Setup with Mixed Providers

For applications requiring fine-grained control, instantiate the engine with explicit model assignments:

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

async function main() {
  const output = await run({
    problem: "Optimize database query performance",
    model: "claude-sonnet-4-5",        // Generator: Diverge + Deepen
    criticModel: "gpt-4o",             // Critic: Score + Cluster
    framesPerRun: 5,
    ideasPerFrame: 6,
    topK: 3,
    concurrency: 4,
  });

  console.log("Best non-obvious pick:", output.nonObviousPick?.text);
}

main();

```

## Summary

- **Separate model support**: ADHD allows distinct models for the generator (diverge/deepen) and critic (score/cluster) phases via the `criticModel` option.
- **CLI usage**: Pass `--model` for the generator and `--critic-model` for the critic in the command line.
- **Programmatic usage**: Set the `criticModel` property in the `RunOptions` object passed to the `run()` function from [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts).
- **Fallback behavior**: If `criticModel` is omitted, the system defaults to using the generator model for all phases, as implemented in lines 27–30 of [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts).
- **File references**: Configuration is handled in [`src/cli.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/cli.ts) for command-line parsing and [`src/types.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/types.ts) for TypeScript interface definitions.

## Frequently Asked Questions

### What happens if I don't specify a critic model?

If you omit the `--critic-model` flag or the `criticModel` property, the critic phase automatically uses the same model as the generator. The fallback logic `const critic = criticModel ?? model` in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts) ensures backward compatibility while allowing optional specialization.

### Can I use models from different providers for each phase?

Yes, you can mix providers. The `model` and `criticModel` fields accept any valid model identifier string that your underlying LLM client supports, such as `"anthropic/claude-3-sonnet-20240229"` for the generator and `"openai/gpt-4o"` for the critic.

### Which pipeline phases use which model?

The **generator model** handles the *diverge* and *deepen* passes (creative expansion), while the **critic model** handles the *score* and *cluster* functions (evaluation and categorization). This separation is maintained throughout the execution flow in [`src/engine.ts`](https://github.com/UditAkhourii/adhd/blob/main/src/engine.ts).

### Does using different models affect concurrency settings?

No, concurrency is controlled independently via the `concurrency` option in `RunOptions` or the corresponding CLI flag. The model selection does not impact how many requests are run in parallel, though different models may have varying rate limits or latency characteristics that you should consider when setting concurrency values.