Skip to content

Self-Discover Reasoning: LLM-Composed Reasoning Structures

The model composes a task-specific reasoning structure from atomic modules before solving, rather than applying one fixed strategy to every problem.

The technique

Fixed reasoning strategies — CoT, ReAct, Chain-of-Thought Self-Consistency — apply the same cognitive approach to every problem. SELF-DISCOVER (Wang et al., 2024) inverts this: the model first identifies which reasoning primitives fit the task, composes them into an explicit JSON plan, then executes that plan.

Stage 1 (structure composition) runs once per task type, not per instance. The model then reuses the composed plan across every instance of that task. This makes the approach 10–40x more compute-efficient than CoT-Self-Consistency, while still exceeding its accuracy.

The three-stage process

Stage 1, self-discovery, runs once per task type and produces a reusable reasoning structure.

  1. Select — identify 3–5 relevant reasoning modules from a library of 39 atomic primitives (critical thinking, step-by-step analysis, analogical reasoning, backward reasoning, constraint identification, risk analysis, and others)
  2. Adapt — rephrase the selected modules from generic descriptions into concrete, task-specific instructions
  3. Implement — convert the adapted descriptions into a structured JSON reasoning plan

Stage 2, structured execution, runs per instance using the cached plan.

The model fills in the JSON plan, reasoning specifically about the task. Each key maps to an adapted reasoning module and produces an explicit, inspectable trace.

graph LR
    A[Task Type] --> B[Select Modules]
    B --> C[Adapt to Task]
    C --> D[Implement as JSON Plan]
    D -->|Cached per task type| E[Execute on Instance 1]
    D --> F[Execute on Instance 2]
    D --> G[Execute on Instance N]

Benchmark results

On PaLM 2-L (Wang et al., 2024):

Benchmark SELF-DISCOVER Chain-of-Thought Direct
BigBench-Hard (23 tasks) 67% 60% 56%
Grounded Agent Reasoning (T4D) 69% 40% 30%
MATH (200 samples) 50.5% 42% 45%

The grounded agent reasoning gain (+29pp over CoT) is the strongest signal: tasks requiring multi-step planning over structured state benefit most from explicit reasoning scaffolds.

On MATH, 74.7% of remaining failures are computational errors, not reasoning errors — a ceiling this approach cannot address. For numerical computation, the bottleneck shifts from reasoning quality to arithmetic accuracy.

Structures transfer across model families: a plan discovered with PaLM 2-L applies to GPT-4, and vice versa — the JSON format is model-agnostic.

When to apply

Use SELF-DISCOVER when reasoning quality is the bottleneck:

  • Complex analytical tasks with multiple interdependent sub-problems
  • Mathematical problem-solving where the reasoning path is non-obvious
  • Strategic planning over structured state (game-playing, agent task graphs)
  • Multi-step code generation where architecture decisions chain forward

Skip it when:

  • CoT already performs well — the overhead is not justified
  • Tasks are straightforward lookups or single-step transformations
  • Failures are computational (arithmetic errors) rather than reasoning failures — structure won't help
  • Per-query latency is the primary constraint and caching is not applicable

Why it works

SELF-DISCOVER outperforms fixed reasoning strategies through three mechanisms identified in the original paper (Wang et al., 2024):

  1. Multi-perspective integration — a single CoT pass applies one reasoning lens. Composing multiple modules (for example, root-cause analysis + constraint identification + verification) draws on the complementary strengths of each. Tasks that need world knowledge and structured state benefit most — the T4D grounded-agent-reasoning gain of +29pp over CoT is the clearest case.
  2. Task-specific composition — generic prompting applies the same approach no matter the problem category. Selecting modules that match the task's actual structure (algorithmic decomposition for code, backward reasoning for constraint problems) from the 39-primitive library removes mismatched reasoning overhead.
  3. Explicit structure — the JSON plan makes the model state its reasoning approach before executing it. This stops the model from silently switching strategies mid-response, and makes errors inspectable and correctable.

The gains are not uniform: algorithmic tasks see only moderate improvement, while world-knowledge and multi-step planning tasks (T4D: +29pp over CoT) benefit most. Computational errors remain outside the framework's reach.

The "explicit structure helps" claim is also contested. An instance-level reproduction, iSelf-Discover (Gunasekara & Ratnayake, 2025), found that unstructured reasoning plans consistently beat structured ones — by up to 18.90% relative on MATH, with zero-shot unstructured variants exceeding five-shot structured ones. The takeaway is that the per-task-type composition step, not the JSON rigidity, likely carries the benefit. Forcing reasoning into a fixed structure can cost accuracy when the task does not need it.

Compute trade-offs

Stage 1 costs 3 additional LLM calls (Select, Adapt, Implement) per task type. After that, each instance costs one inference call — the same as plain CoT, with no extra overhead per instance.

The meaningful comparison is against CoT-Self-Consistency (multiple CoT passes per instance): SELF-DISCOVER needs 10–40x fewer inference calls while exceeding CoT-SC accuracy (Wang et al., 2024). Stage 1 overhead is pure cost for a one-off task type, but amortizes quickly across any recurring one.

Key Takeaways

  • SELF-DISCOVER composes a task-specific JSON reasoning plan once per task type, then reuses it across instances — amortizing discovery cost
  • Stage 1 has three actions: Select modules from a 39-primitive library, Adapt them to the task, Implement as a JSON plan
  • Gains are largest on multi-step reasoning tasks: +29pp over CoT on grounded agent reasoning benchmarks
  • MATH failures (74.7% computational errors) mark a hard ceiling — structure cannot substitute for arithmetic accuracy
  • Composed structures transfer across model families without modification
  • 10–40x fewer inference calls than CoT-Self-Consistency with higher accuracy — the relevant compute comparison

Example

A SELF-DISCOVER workflow for analyzing a failing CI pipeline:

Stage 1, compose the plan (once, reused for all pipeline failures):

{
  "decompose_failure": "Break the pipeline into stages. Identify which stage failed and what its inputs and outputs are.",
  "root_cause_analysis": "For the failing stage, trace backward from the symptom to the likely root cause using available logs and configuration.",
  "constraint_check": "Verify that the fix satisfies all constraints: does not break other stages, does not introduce new dependencies, passes existing tests.",
  "verify_reasoning": "Check that the proposed fix is logically consistent with the root cause identified."
}

Stage 2, execute on each instance:

The model fills in each key with instance-specific reasoning, producing a structured trace that maps directly to the plan. When the diagnosis is wrong, the trace shows exactly which step introduced the error.

Adopted — practitioner-sourced, corroborated Last reviewed: 2026-06-12
Feedback