Ai

---
name: reasoning-patterns
description: Select and apply test-time reasoning techniques (chain-of-thought, self-consistency, tree-of-thoughts, least-to-most, step-back, ReAct, reflexion) by cost, latency, and problem shape.
triggers: [chain of thought, self-consistency, tree of thoughts, least to most, step-back prompting, test-time compute, when to use reasoning, process reward scoring]
tags: [ai, reasoning, cost]
core: false
context_cost: medium
---
# Reasoning Patterns Skill

## Goal
Choose the right amount and shape of reasoning for a task, then apply it without overspending. Reasoning
techniques trade extra tokens and latency for accuracy on hard problems — they are powerful on
multi-step logic and actively harmful on simple lookups, where they add cost and can talk the model out
of a correct first answer. The objective is to match the technique to the problem's structure (linear,
branching, decomposable, abstract, environment-grounded), spend the minimum compute that clears the
quality bar, and always pair self-evaluation with an external anchor.

## Steps

1. **Classify the problem before choosing a technique**
   - Simple/lookup/well-specified → answer directly; reasoning adds latency and risk. Stop here.
   - Linear multi-step (arithmetic, logic, analysis) → **chain-of-thought**.
   - Noisy single trace, aggregable answer → **self-consistency**.
   - Search/backtracking structure (puzzles, planning, proofs) → **tree-of-thoughts**.
   - Decomposable into ordered easy sub-problems → **least-to-most**.
   - Model rushes to a specific wrong answer → **step-back** to the governing principle first.
   - Needs external information or to act → **ReAct** (defer to `agentic-patterns.skill`).

2. **Chain-of-Thought (CoT)** — instruct the model to lay out intermediate steps before the final
   answer. The cheapest reasoning lever; usually a single call. Use as the default when a one-shot
   answer is unreliable; skip for trivial tasks.

3. **Self-Consistency** — sample several independent CoT traces at non-zero temperature and take the
   majority (or otherwise aggregated) answer. Use when one trace is noisy and a verifiable/aggregable
   answer exists. Cost is N× tokens — bound N and use it only where the accuracy gain is measured. For
   the aggregation/quorum mechanics defer to `swarm-consensus.skill`.

4. **Tree-of-Thoughts / Graph-of-Thoughts** — explore reasoning as a branching tree (ToT), score
   partial branches with a value heuristic, and prune dead ends; generalize to a DAG (GoT) when partial
   results should *merge*, not only branch. Use for genuine search problems. This is the most expensive
   pattern (many calls) — reserve it for problems a linear chain provably cannot solve.

5. **Least-to-Most** — first prompt the model to decompose the problem into an ordered list of easier
   sub-problems, then solve them in sequence, each consuming earlier answers. Use when the hard problem
   is really a chain of dependent easy ones; it improves generalization to harder instances than seen
   in examples.

6. **Step-Back Prompting** — before the specific answer, ask the model to state the higher-level
   principle, abstraction, or general question, then reason down from it. Use when the model
   over-anchors on surface details and a governing concept would steady it.

7. **Reflexion (anchored)** — after a failed attempt, have the model write a verbal self-critique,
   persist it to memory, and retry with that lesson in context. Use only when multiple attempts are
   allowed and a real success/failure signal exists; persist the lesson via `episodic-consolidation.skill`.
   The reflection itself must be grounded (Step 9).

8. **Scale test-time compute to difficulty, not uniformly**
   - Detect hard instances (low confidence, repeated failure, high stakes) and spend more there:
     longer reasoning, more samples, deeper search. Route easy cases to a cheap, short path.
   - Where this becomes a cheap-vs-capable model choice, defer to `cost-benefit-router.skill` rather
     than hard-coding model selection here.

9. **Prefer process-level over outcome-only scoring, with an external anchor**
   - Score the *trace as it unfolds* (process reward) and prune a path the moment it goes off the
     rails, rather than grading only the final answer (outcome reward). Process scoring catches the
     "right answer, wrong reasoning" case.
   - Any self-evaluation MUST be anchored to something the model cannot merely assert: a deterministic
     check (test/lint/run), a symbolic constraint (units, ranges, a solver), or per-step scoring. See
     `agentic-patterns.skill` (grounded self-critique) and `cognitive-testing.skill`.

10. **Bound every reasoning loop** — max iterations/branches, a token and wall-clock budget, and a
    quality-threshold exit so search or refinement cannot run away.

## Constraints
- NEVER apply heavy reasoning to simple, well-specified, single-fact, or latency-critical tasks.
- NEVER let a self-critique loop score only its own opinion — require an external anchor.
- Self-consistency, ToT, and debate-style methods cost N× tokens; bound N and justify it with a
  measured accuracy gain, not a hope.
- Do NOT re-implement consensus aggregation, model routing, judging, or memory persistence here —
  reference `swarm-consensus.skill`, `cost-benefit-router.skill`, `llm-as-judge.skill`, and
  `episodic-consolidation.skill`.
- Stop at good-enough: more reasoning past the quality threshold burns cost and can degrade a correct
  answer.

## Output Format
A reasoning plan containing:
- **Problem class**: which structure the task has (linear / branching / decomposable / abstract /
  grounded) and therefore which technique.
- **Technique**: the chosen pattern(s) and why, including the cheaper alternatives rejected.
- **Compute budget**: number of samples/branches/iterations and the token/wall-clock cap.
- **Anchoring**: the deterministic or symbolic check, and whether scoring is process-level or
  outcome-only.
- **Difficulty routing**: how hard instances are detected and escalated (and to which skill).
- **Exit rule**: the quality threshold that stops the loop.

## Security & Guardrails

### 1. Skill Security
- **Risk**: An ungrounded self-evaluation or reflexion loop reinforces a confidently-wrong answer,
  stamping it "reviewed" and raising false confidence. Mitigation: require an external anchor
  (deterministic/symbolic check or process-level scoring) on every self-critique, per
  `agentic-patterns.skill`; never treat the model's own approval as verification.
- **Risk**: Tree-of-thoughts or self-consistency fans out unbounded, exhausting tokens/cost on a
  problem that did not need it. Mitigation: cap branches/samples/iterations and total token budget up
  front, gate the expensive techniques behind a difficulty check, and halt on a circuit breaker.

### 2. System Integration Security
- **Risk**: Persisted reflexion lessons become an indirect-injection channel — a poisoned "lesson" is
  re-read as trusted guidance on the next attempt. Mitigation: tag persisted critiques with provenance,
  treat them as untrusted data on re-read per `prompt-injection-defense.skill`, and scope them per
  task/tenant via `episodic-consolidation.skill`.
- **Risk**: A ReAct-style reasoning step that triggers a tool/code action executes attacker-influenced
  reasoning with real privileges. Mitigation: run all actions in an isolated environment per
  `agent-sandboxing.skill` and keep the reasoning's action surface least-privilege; reasoning that
  acts is bound by the same sandbox as any tool call.

### 3. LLM & Agent Guardrails
- **Risk**: Exposed chain-of-thought leaks sensitive intermediate data, internal policy, or a usable
  attack path. Mitigation: keep raw reasoning traces internal, return only the vetted final answer to
  untrusted callers, and screen exposed reasoning for secret/PII leakage.
- **Risk**: Long or branching reasoning suffers context rot and silently ignores a constraint buried
  mid-trace, producing a confidently wrong result. Mitigation: keep active constraints near the prompt
  boundaries, compact intermediate reasoning via `context-engineering.skill`, and treat answers
  produced near the context ceiling as suspect pending re-grounding.