🧠 Thinking Toolkit

English · Русский · 中文

30 battle-tested thinking models, packaged as one portable skill for any AI agent.

Thinking Toolkit teaches an agent how to think about thinking: given a messy
real-world request — a decision to make, a problem to diagnose, a system to
understand, a message to deliver — it selects the smallest useful set of
structured thinking models, applies them faithfully step by step, and returns a
concrete artifact: a weighted matrix, a causal map, a premortem table, a
backward plan, a draft message.

It is plain Markdown with zero runtime dependencies. If your agent can read
files, it can use this skill.

Why

Left to itself, an LLM agent reasons in prose that sounds convincing and skips
steps. Meanwhile engineering, strategy, intelligence analysis, and
organizational learning have spent decades turning the situations agents face
daily — comparing options, finding root causes, estimating without data,
stress-testing plans — into named, tested procedures. This skill turns those
procedures into instructions an agent can execute, with the pitfalls
practitioners documented along the way.

Three commitments shape the design:

1. Selection. Knowing what a decision matrix is costs nothing; the
   expensive mistake is reaching for one at the wrong moment. The catalog
   encodes selection cues, contrast rules ("Five Whys for one causal chain,
   Ishikawa for breadth, Connection Circles for feedback"), and anti-patterns
   for every model.
2. Procedure. Each model ships as a full operational card: inputs,
   numbered steps, guiding questions, output format, a worked example, and
   documented pitfalls. The agent follows the card instead of improvising
   around a label.
3. Honesty. The core contract separates observed facts from assumptions,
   marks unknowns instead of inventing evidence, runs sensitivity checks on
   consequential results, and ends every artifact with an action and a review
   trigger.

How It Works

When a model is named explicitly, the agent loads that card and follows it.
When the request is open, it identifies the job (decide, diagnose, estimate,
map, resolve, communicate), routes through the catalog's selection cues and
contrast rules, and picks one primary model with at most two complements. It
then frames the situation — stakes, reversibility, evidence — applies the
card's procedure at quick, standard, or deep depth, tests the result for
hidden assumptions and sensitivity, and closes with an artifact, an action,
and a review trigger.

The skill uses progressive disclosure to stay context-efficient: the agent
first reads only SKILL.md (~180 lines), consults the routing catalog when
selection is unclear, and loads only the model cards it actually needs.
Thirty models cost nothing until one is used.

The Catalog

Decision making — 12 models

Problem solving — 11 models

Systems thinking — 5 models

Communication — 2 models

Beyond single models, the catalog ships combination recipes — proven
sequences such as Consequential choice (Hard Choice Model → Decision Matrix →
Red Teaming) or Root-cause investigation (Pareto → Iceberg → Ishikawa → Five
Whys → OODA) — plus guardrails against the classic failure of stacking models
to appear thorough.

Installation

The skill follows the Agent Skills
convention (SKILL.md + resource files), supported by Claude Code, OpenAI
Codex CLI, OpenClaw, and other SKILL.md runtimes. Installation is copying a
folder.

Quick install

git clone --depth 1 https://github.com/ponomr/thinking-toolkit.git && thinking-toolkit/install.sh

That installs into every agent detected on the machine, printing each path and
refusing to overwrite an existing install unless you confirm.

Options:

• Pick a host: ./install.sh claude, codex, openclaw, or a custom path.
• --symlink links the skill instead of copying it, so a later git pull in
  this repo updates every install at once.
• --force overwrites an existing install without asking.

Manual install

Copy SKILL.md, references/, and (optionally) agents/ into the directory.
Nothing else is required at runtime — no API keys, no network access, no code
execution.

For self-hosted gateways and custom harnesses: inject SKILL.md into the
system context and make references/ readable; the skill assumes nothing
beyond file reading.

Usage

Ask for a model by name:

"Run a premortem on this launch plan."
"Compare these three vendors with a weighted matrix."
"Backcast from where we want the newsletter to be in three years."

Or just describe the situation and let the routing work:

"Support tickets keep growing and I don't know where to start."
→ Pareto Analysis to find the vital few, then Five Whys on the top category.

"We keep arguing about whether to rewrite the billing service."
→ Six Thinking Hats to structure the debate, Decision Matrix if options
stabilize, Red Teaming before committing.

The agent states which model it chose and why, applies the card's procedure,
and returns the artifact with its assumptions and a review trigger.

Repository Layout

thinking-toolkit/
├── SKILL.md                  # entry point: contract, routing, workflow
├── references/
│   ├── catalog.md            # index, aliases, selection cues, recipes
│   └── <model>.md            # 30 operational cards, one per model
├── agents/openai.yaml        # optional host discovery metadata
├── scripts/validate_skill.py # deterministic structure validation
├── tests/                    # validator regression tests
└── install.sh                # copy payload into agent skill dirs

Development

python3 scripts/validate_skill.py .        # structure + content invariants
python3 -m unittest discover -s tests -v   # validator regression tests

The validator enforces the invariants that make the skill reliable: every card
carries all ten operational sections, every link resolves internally, the skill
payload contains no external URLs (it must work fully offline), and the catalog
matches the card set exactly.

Design Principles

• Provider-neutral by construction. No tool calls, no browsing, no code
  execution, no memory assumptions. Any capable LLM with file access qualifies.
• The smallest useful model set. One model by default, three at most, and
  explicit permission to use none: a communication model is chosen only after
  the underlying analysis is adequate.
• User agency preserved. Model outputs support a decision that stays with
  the user. The skill never manufactures certainty the evidence does not
  contain.
• Depth matched to stakes. Quick pass for reversible low-stakes calls; deep
  pass — with sensitivity checks and disconfirming evidence — for consequential
  or irreversible ones.
• Deterministic quality gates. A stdlib-only validator keeps all 30 cards
  structurally complete and the routing tables in sync with the card set.

Acknowledgments

The models collected here were created by their original authors, including
Edward de Bono (Six Thinking Hats), Chris Argyris (Ladder of Inference), John
Boyd (OODA Loop), Dave Snowden (Cynefin), Kaoru Ishikawa (fishbone diagram),
Taiichi Ohno and Sakichi Toyoda (Five Whys), Eliyahu Goldratt (Evaporating
Cloud), Fritz Zwicky (morphological analysis), Tim Hurson (Productive
Thinking), Barbara Minto (Pyramid Principle), Joseph Novak (concept mapping),
Enrico Fermi (order-of-magnitude estimation), Vilfredo Pareto and Joseph Juran
(80/20 analysis), John B. Robinson (backcasting), Ruth Chang (hard choices),
the Center for Creative Leadership (SBI), and the systems-thinking tradition of
Jay Forrester and Donella Meadows. All card text is original prose written for
this project.

License

MIT — see LICENSE.