- Home
- Skills
- Agents & Orchestration
- quantum reasoning
Works with the AI Agents you already use
quantum reasoning
A multi-path reasoning protocol that maintains, tests, and revives competing hypotheses for complex problem-solving.
$5
quantum reasoning
Example session with this skill installed
quantum-reasoning — Keep competing explanations alive, commit only when verified
A reasoning protocol that maintains several genuinely different hypotheses, tests them against evidence and tools, moves weak paths to dormant instead of deleting them, revives them when new evidence appears, and collapses to one answer only when verification justifies it.
What it does
- Separates verified facts, assumptions, unknowns, and available tools before reasoning.
- Opens materially different branches — not paraphrases or variants sharing the same hidden assumption.
- Tracks every branch as active, dormant, or rejected; rejection requires decisive contradiction.
- Verifies with executable checks, source inspection, formal solvers, or independent passes; it looks for disconfirming evidence, not just confirmation.
- Compares branches without double-counting correlated assumptions or averaging incompatible claims.
- Collapses only when a verified leader has a clear margin; otherwise reports the surviving alternatives and the evidence that would distinguish them.
- Adapts effort: 2–3 branches for light tasks, 4–8 for standard work, 8+ only when the problem and budget justify it.
Example session — incident diagnosis (illustrative values)
User: We see intermittent 504s around a 30-second window under peak load. Find the cause.
Abridged output:
| Branch | Hypothesis | State | Evidence so far |
|---|---|---|---|
| QR-01 | Connection-pool exhaustion | Active | 504s cluster at peak. DB CPU at ~40% makes database saturation unlikely, but pool wait time is client-side and still possible; active/max pool metrics are missing. |
| QR-02 | Upstream gateway timeout | Active | A 504 is a gateway timeout by definition. The absence of 502s does not rule it out; proxy timeout and upstream latency histograms are needed. This explains the status code, not necessarily the origin. |
| QR-03 | Auth-service latency | Active | The auth middleware has a 29-second timeout against a roughly 30-second failure window; p99 latency during failures has not been measured. |
| QR-04 | Worker memory growth / leak | Dormant | Intermittent recovery does not falsify a leak. Revive if RSS trends upward or workers are OOM-killed. |
Synthesis: the best-supported explanation is a chain, not a single fault: auth latency spikes at peak → requests wait in the connection pool → the gateway hits its timeout and returns 504. QR-02 is the delivery mechanism; QR-01 and QR-03 are candidate origins. Confidence: medium — the chain is plausible but not yet verified.
What would change the ranking:
- Auth p99 stays normal during failures → QR-03 loses support.
- Pool active connections never approach max → QR-01 loses support.
- Gateway timeout is longer than the observed failure latency → QR-02 weakens.
- RSS climbs and OOM kills appear → QR-04 is revived.
Next steps:
- Capture pool active/max and auth p99 at one-minute resolution through the next peak.
- Reproduce in staging with injected auth latency.
- Add a timeout budget and circuit breaker at the auth boundary; verify the 504 rate.
- Record branch state changes and evidence so the conclusion stays auditable and revivable.
Requirements
No runtime dependencies. Works with Claude Code, Cursor, Codex CLI, and any SKILL.md-compatible agent. An optional stdlib-only Python reference controller is included.
Honesty rules
This is a classical reasoning protocol, not quantum computation. Reference thresholds are defaults, not validated constants. Branch telemetry is never invented, and a conclusion is not collapsed until a verified leader has a clear margin.
- Read your context and instructions
- Compiled the quantum reasoning
quantum-reasoning — Keep competing explanations alive, commit only when verified
A reasoning protocol that maintains several genuinely different hypotheses, tests them against evidence and tools, moves weak paths to dormant instead of deleting them, revives them when new evidence appears, and collapses to one answer only when verification justifies it.
What it does
- Separates verified facts, assumptions, unknowns, and available tools before reasoning.
- Opens materially different branches — not paraphrases or variants sharing the same hidden assumption.
- Tracks every branch as active, dormant, or rejected; rejection requires decisive contradiction.
- Verifies with executable checks, source inspection, formal solvers, or independent passes; it looks for disconfirming evidence, not just confirmation.
- Compares branches without double-counting correlated assumptions or averaging incompatible claims.
- Collapses only when a verified leader has a clear margin; otherwise reports the surviving alternatives and the evidence that would distinguish them.
- Adapts effort: 2–3 branches for light tasks, 4–8 for standard work, 8+ only when the problem and budget justify it.
Example session — incident diagnosis (illustrative values)
User: We see intermittent 504s around a 30-second window under peak load. Find the cause.
Abridged output:
| Branch | Hypothesis | State | Evidence so far |
|---|---|---|---|
| QR-01 | Connection-pool exhaustion | Active | 504s cluster at peak. DB CPU at ~40% makes database saturation unlikely, but pool wait time is client-side and still possible; active/max pool metrics are missing. |
| QR-02 | Upstream gateway timeout | Active | A 504 is a gateway timeout by definition. The absence of 502s does not rule it out; proxy timeout and upstream latency histograms are needed. This explains the status code, not necessarily the origin. |
| QR-03 | Auth-service latency | Active | The auth middleware has a 29-second timeout against a roughly 30-second failure window; p99 latency during failures has not been measured. |
| QR-04 | Worker memory growth / leak | Dormant | Intermittent recovery does not falsify a leak. Revive if RSS trends upward or workers are OOM-killed. |
Synthesis: the best-supported explanation is a chain, not a single fault: auth latency spikes at peak → requests wait in the connection pool → the gateway hits its timeout and returns 504. QR-02 is the delivery mechanism; QR-01 and QR-03 are candidate origins. Confidence: medium — the chain is plausible but not yet verified.
What would change the ranking:
- Auth p99 stays normal during failures → QR-03 loses support.
- Pool active connections never approach max → QR-01 loses support.
- Gateway timeout is longer than the observed failure latency → QR-02 weakens.
- RSS climbs and OOM kills appear → QR-04 is revived.
Next steps:
- Capture pool active/max and auth p99 at one-minute resolution through the next peak.
- Reproduce in staging with injected auth latency.
- Add a timeout budget and circuit breaker at the auth boundary; verify the 504 rate.
- Record branch state changes and evidence so the conclusion stays auditable and revivable.
Requirements
No runtime dependencies. Works with Claude Code, Cursor, Codex CLI, and any SKILL.md-compatible agent. An optional stdlib-only Python reference controller is included.
Honesty rules
This is a classical reasoning protocol, not quantum computation. Reference thresholds are defaults, not validated constants. Branch telemetry is never invented, and a conclusion is not collapsed until a verified leader has a clear margin.D
Connects securely to your tools. The creator never sees your data.
About this skill
Hard reasoning problems often fail because models commit to a single solution path too early. When an initial assumption is wrong, the entire output drifts into hallucination. This skill implements a non-linear reasoning protocol that maintains multiple, diverse hypothesis branches simultaneously, preventing premature convergence on flawed answers.
What it does
- Multi-path branching creates distinct, orthogonal strategies for solving complex problems.
- Evidence-based pruning categorizes solution paths as active, dormant, or rejected based on logical support.
- Dynamic branch revival restores previously discounted paths if new evidence invalidates the current leader.
- Adversarial falsification uses tools and executable code to actively disprove leading hypotheses rather than just confirming them.
- Interference analysis compares independent paths to identify shared assumptions and reinforce consensus without double-counting correlated logic.
How it works
- Frame the state by separating verified facts from assumptions and unknowns.
- Open the possibility set using diverse strategies like direct derivation, decomposition, or numerical tests.
- Evaluate and route claims through verifiers like unit tests or formal solvers to calculate contradiction counts.
- Collapse the set only when a single result is verified or remaining alternatives are decisively falsified.
Frameworks & tools
The protocol is model-agnostic and runs on standard LLMs. It includes a Python-based reference controller, branch_controller.py, to track branch metadata, contradiction severity, and independence scores.
Why this beats prompting it yourself
Standard "chain of thought" prompting is linear and prone to the "sunk cost" fallacy where the model defends an early mistake. This skill enforces structural diversity and allows for the recovery of rejected ideas, leading to higher accuracy in high-stakes technical tasks.
Use cases
- Technical diagnosis where multiple root causes could explain a single set of logs.
- Architecture design requiring the comparison of materially different scaling strategies.
- Scientific reasoning to test competing hypotheses against empirical data.
- Complex debugging involving race conditions or non-deterministic failures.
Known limitations
This skill adds token and compute overhead and should not be used for trivial questions. It requires a model capable of following multi-step logical protocols.
Adds compute and token overhead. Not suitable for simple, unambiguous queries. Requires models with high instruction-following capabilities to manage branch states.
How to use
- 1
Connect your agent to the Agensi MCP
Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup
- 2
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 25 days ago
Requires
Permissions
Quantum-reasoning is a pure reasoning protocol and needs no network, browser, or environment variables. Read access is used only to load the bundled SKILL.md and references. Terminal/Shell is optional: the included stdlib-only Python reference controller (scripts/branch_controller.py) can be run to score branches, and it installs nothing. The skill writes files only when the user explicitly asks for a report or run record.