Modes of Thinking

Stop asking AI to think harder. Make it think differently.

Most AI reasoning tools give the model one oversized instruction: analyze carefully, consider multiple perspectives, and produce a smart answer.

That sounds useful. It also leaves the most important decision to chance:

What kind of thinking does this problem actually require?

Debugging is not forecasting. Forecasting is not deciding. Deciding is not red-teaming. Red-teaming is not learning from a result. When every problem gets the same generic reasoning treatment, the model can produce a polished answer in the wrong frame.

Modes of Thinking is a portable Agent Skill and reasoning router for AI agents. It gives an agent ten distinct modes of thought, a practical atlas of reasoning lenses, and a disciplined way to move from uncertainty to action.

$modes-of-thinking <mode> [agents=N] <problem>

It works with Codex, Claude Code, and Gemini CLI. It has no runtime dependencies, MCP servers, hooks, telemetry, or hidden services.

It also protects the agent's finite context. Modes of Thinking spends tokens on competing explanations, evidence, uncertainty, and synthesis instead of repeatedly loading the same files, tool definitions, and council context.

One problem is rarely just one problem

Consider a simple question:

Should we launch this product now?

A generic assistant tends to produce one blended list of benefits, risks, and suggestions. Modes of Thinking lets you choose the cognitive operation you need:

$modes-of-thinking reframe Should we launch this product now?
$modes-of-thinking forecast Should we launch this product now?
$modes-of-thinking redteam Should we launch this product now?
$modes-of-thinking experiment Should we launch this product now?
$modes-of-thinking council agents=3 Should we launch this product now?

Those are not stylistic variations. They ask fundamentally different questions:

• Are we representing the decision correctly?
• What is likely to happen, and within what range?
• How does this fail, get abused, or backfire?
• What is the smallest test that could change the decision?
• Which independent perspectives disagree, and why?

The point is not to generate more analysis. The point is to run the right form of analysis before confidence hardens around the wrong answer.

Ten modes. Ten cognitive jobs.

Mode	Form of thinking	What it does
think	Selective thinking	Classifies the problem and chooses the smallest useful three-lens stack: primary, challenge, and action.
deepthink	Integrative thinking	Runs a ten-stage protocol across evidence, causality, uncertainty, incentives, failure, action, and learning.
council	Independent thinking	Assigns dynamically chosen, competing lenses to separate subagents and synthesizes their disagreement.
sweep	Cross-disciplinary thinking	Scans the problem through four to six relevant disciplines without the cost of spawning agents.
reframe	Representational thinking	Rewrites the problem as a system, game, queue, portfolio, timeline, experiment, or other useful representation.
decide	Comparative thinking	Defines criteria, compares real options including inaction, and makes a recommendation with switch conditions.
forecast	Probabilistic thinking	Produces ranges, base rates, scenarios, confidence, key drivers, and evidence that should trigger an update.
redteam	Adversarial thinking	Searches for failure paths, abuse, incentive problems, dependency risk, and proportionate mitigations.
experiment	Empirical thinking	Finds the assumption carrying the most decision risk and designs the smallest test that can resolve it.
debrief	Reflective thinking	Compares prediction with outcome, separates bad process from variance, and updates the working model.

You do not need all ten at once. The system is designed to resist the temptation to throw every mental model at every problem.

The difference is the architecture

1. It routes before it reasons

The default think mode first identifies the problem class, then builds a three-lens stack:

1. Primary lens: the best fit for the actual problem.
2. Challenge lens: a competing explanation, failure mode, or value conflict.
3. Action lens: the next observable decision, test, or diagnostic step.

This creates useful tension without turning every answer into a bloated debate.

2. It separates facts from confidence theater

The skill keeps five things distinct:

• Observed: directly verified evidence
• Inferred: conclusions drawn from that evidence
• Assumed: claims accepted without verification
• Valued: preferences and ethical commitments
• Unknown: missing information that could change the answer

The agent must expose concise evidence, assumptions, uncertainty, and decision rationale. It does not expose private chain-of-thought, and it is not allowed to replace missing evidence with confident role-play.

3. The modes form a learning loop

Most reasoning prompts end when the answer is generated. Modes of Thinking continues through the full decision cycle:

reframe -> forecast -> decide -> redteam -> experiment -> act -> debrief
    ^                                                        |
    +---------------------- update the model -----------------+

That matters because an answer is not the same thing as a good decision process. A useful system should make a prediction, define what would change its mind, test the riskiest assumption, and learn when reality disagrees.

4. Council creates disagreement on purpose

council is not four agents repeating the same answer with different job titles.

The chair classifies the problem, selects competing perspectives dynamically, gives every council member the same neutral brief, and keeps their work independent until synthesis. The result is resolved through evidence and assumptions, not majority voting.

The protocol is deliberately bounded:

• You choose 2, 3, or 4 council agents. There is no silent default.
• The main agent is the chair and does not count toward that number.
• Council members are advisory and read-only.
• Nested delegation is prohibited.
• Limited concurrency uses sequential independent waves rather than quietly shrinking the council.
• If the runtime cannot spawn real subagents, the skill says so. A simulated perspective is never presented as a spawned agent.

This makes council mode expensive enough to be valuable and constrained enough to remain usable.

5. The mental-model atlas is a library, not a checklist

The included atlas covers evidence, causality, systems, uncertainty, strategy, incentives, markets, engineering, human behavior, ethics, operations, and learning.

The agent loads relevant lenses progressively. It is explicitly told to stop when another lens is unlikely to change the decision. More frameworks do not automatically produce more insight; often they produce repetition, false balance, and analysis paralysis.

6. It saves tokens around the thinking, not from the thinking

Most “token optimization” advice amounts to asking for a shorter answer. That can make the output cheaper while making the decision worse.

Modes of Thinking targets the actual waste:

• Search before reading: inspect indexes, metadata, headings, filenames, and bounded ranges before loading full sources.
• Load tools on demand: use deferred tool discovery when the runtime supports it instead of carrying every tool definition in context.
• Batch predictable work: group independent reads and use compact structured results rather than streaming every intermediate response into the conversation.
• Reuse evidence: preserve source handles and a small decision-relevant evidence ledger so verified facts do not need to be fetched again.
• Compress between phases: carry forward facts, assumptions, disagreements, uncertainty, and provenance; drop duplicate excerpts and completed-step narration.
• Share council packets: every member gets the same compact neutral brief, while research questions are divided to prevent four agents from running the same search.

The system explicitly forbids saving tokens by hiding uncertainty, dropping contrary evidence, skipping validation, or erasing user constraints. It makes no universal percentage-savings claim: real savings depend on the runtime, tools, source size, and task.

What this replaces

Modes of Thinking replaces a familiar collection of weak habits:

• Repeatedly typing “think step by step” and hoping the frame improves
• Asking one giant prompt to diagnose, predict, decide, critique, and plan at once
• Spawning a crowd of agents without independent briefs or a synthesis protocol
• Treating every “expert persona” as a real independent perspective
• Producing precise forecasts without base rates or update triggers
• Running experiments with no threshold tied to an actual decision
• Reviewing outcomes without recording what the model got wrong

It does not guarantee the right answer. It gives the agent a better process for discovering when its answer may be wrong.

Start with the mode that matches the failure

If you are worried that...	Start with...
The agent is solving the wrong version of the problem	reframe
The answer is broad but not operational	think
A major decision crosses several domains	deepthink
One agent may be anchored to its first interpretation	council
You need broad coverage without spawning agents	sweep
You have options but no defensible choice	decide
A confident prediction has no range or base rate	forecast
A plan looks good because nobody has tried to break it	redteam
Debate is continuing because the critical fact is unknown	experiment
Reality contradicted the original prediction	debrief

If you do not know where to begin, use think. Routing is its job.

Install

Codex

codex plugin marketplace add volkthienpreecha/modesofthinking
codex plugin add modesofthinking@modesofthinking

Start a new task, then invoke:

$modes-of-thinking think Why did this release double API latency?
$modes-of-thinking council Should we enter this market?

If agents=N is missing from council mode, the skill asks whether to spawn 2, 3, or 4 agents before it does anything.

Claude Code

claude plugin marketplace add volkthienpreecha/modesofthinking
claude plugin install modesofthinking@modesofthinking

Plugin commands are namespaced:

/modesofthinking:think Why did this release double API latency?
/modesofthinking:council agents=3 Should we enter this market?

To expose personal aliases such as /think or /council, copy the desired Markdown adapters from commands/ into ~/.claude/commands/.

Gemini CLI

gemini extensions install https://github.com/volkthienpreecha/modesofthinking

The extension exposes /think, /council, and the other modes. If a local command uses the same name, Gemini applies its automatic extension prefix.

Try these

$modes-of-thinking think Diagnose why activation fell after onboarding was simplified.

$modes-of-thinking reframe We need to grow faster without increasing acquisition spend.

$modes-of-thinking forecast What is the probability this migration finishes within six weeks?

$modes-of-thinking redteam Attack this plan for an AI-generated security marketplace.

$modes-of-thinking experiment Test whether users will pay before we build the full product.

$modes-of-thinking debrief We predicted a 20% signup lift. We got 4%, and activation fell 8%.

$modes-of-thinking council agents=3 Should we open-source the core product?

What it is not

This is not a claim that a prompt can magically increase a model's intelligence.

Modes of Thinking cannot create evidence that does not exist, rescue a model that lacks the required knowledge, or spawn real subagents in a runtime that does not support them. Its value depends on the underlying model, the available evidence, and the quality of the problem you give it.

What it can do is make the reasoning process more deliberate, more inspectable, and harder to bluff. It gives the model distinct cognitive operations instead of one vague command to be smart.

Built for inspection

• One canonical Agent Skill in skills/modes-of-thinking/
• Generated Claude and Gemini command adapters from one registry
• Generated Codex marketplace package
• Progressive context and tool-efficiency protocol
• No external dependencies
• No MCP servers or network services
• No hooks
• No telemetry
• MIT licensed

Generate and validate the packages locally:

python scripts/generate_adapters.py
python scripts/validate.py

License

MIT