auto-reasoning

name	auto-reasoning
description	Use when the user wants automatic task-difficulty routing for reasoning effort only, asks to run or configure the auto-reasoning harness, wants Codex/OpenAI calls to keep the model fixed while varying reasoning depth, or asks for an auditable effort-selection workflow.

Auto Reasoning

Overview

Use the auto-reasoning harness to classify a task, select a reasoning effort, execute through an adapter, verify, and escalate effort if needed. The harness must keep the model fixed; routing may change only reasoning effort.

Invocation Contract

When this skill is invoked for a concrete task, run the task through the harness, not just a classifier dry run:

1. Run the harness with --adapter codex --json unless the user explicitly asks for dry-run, classify-only, or the OpenAI adapter.
2. Report the selected effort, confidence, adapter, verification status, and any escalation.
3. Treat the adapter-backed harness result as the task result. Do not redo the full task manually unless the harness fails or the user asks for a second pass.

Use classify-only dry-run only when the user asks to inspect classification, debug policy, or answer a meta question. Do not answer only with "I loaded the skill"; the useful action is an adapter-backed run for real tasks.

If the user asks "are you auto reasoning?", answer based on evidence:

• If an adapter-backed harness run was executed in the current turn, say yes and give the selected effort and adapter.
• If only classify-only dry-run was executed, say it only classified; it did not execute with routed effort.
• If no harness run was executed, say no and offer or perform a classify-only dry run for the current task.

Guardrails

• Do not claim the current Codex thread can change reasoning effort mid-response.
• Do not route between models. If a model is required, treat it as fixed adapter configuration supplied by the user or environment.
• Prefer the local repo CLI when working inside the auto-reasoning source tree; otherwise use the installed auto-reasoning command.
• Use --json when the audit trail matters, then summarize selected effort, confidence, verification status, and escalations.
• For coding tasks, pass verifier commands such as --verify "npm test" when available.

Workflow

1. Locate the harness.
   • In the source repo: run npm run build if dist/cli/main.js is missing or stale, then use node dist/cli/main.js.
   • Installed package: use auto-reasoning.
2. Run the harness.
   • Concrete task default: node dist/cli/main.js --adapter codex --json "<task>" or auto-reasoning --adapter codex --json "<task>".
   • Classifier inspection only: node dist/cli/main.js --json "<task>" or auto-reasoning --json "<task>".
   • If the user explicitly asks for OpenAI, include --adapter openai --fixed-model <model>.
3. Choose the adapter.
   • codex: default for concrete tasks; run codex exec with model_reasoning_effort only.
   • dry-run: classify and inspect effort without executing another agent/API call.
   • openai: call the Responses API with a fixed --fixed-model and selected reasoning.effort.
4. Add verifiers when the task has objective checks.
5. If the harness fails after escalation, report the final effort, failing verifier or adapter error, and the next concrete action.

Commands

Run a concrete task through Codex with routed effort:

auto-reasoning --adapter codex --json "review this patch for risky edge cases"

Run through Codex with a verifier:

auto-reasoning --adapter codex --verify "npm test" --json "fix the failing tests"

Classify only:

auto-reasoning --json "review this patch for risky edge cases"

Run through the Responses API with a fixed model:

OPENAI_API_KEY=... auto-reasoning --adapter openai --fixed-model gpt-5.5 --json "analyze this incident report"

Local source repo equivalent:

node dist/cli/main.js --adapter codex --json "review this patch for risky edge cases"

Response Pattern

When reporting results, keep it compact:

• difficulty: classifier label
• effort: final selected effort
• confidence: classifier confidence
• verification: pass/fail and important command output
• escalation: whether effort increased, and why