Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    quantum reasoning

    1

    A multi-path reasoning protocol that maintains, tests, and revives competing hypotheses for complex problem-solving.

    $5

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    quantum reasoning

    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:

    BranchHypothesisStateEvidence so far
    QR-01Connection-pool exhaustionActive504s 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-02Upstream gateway timeoutActiveA 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-03Auth-service latencyActiveThe auth middleware has a 29-second timeout against a roughly 30-second failure window; p99 latency during failures has not been measured.
    QR-04Worker memory growth / leakDormantIntermittent 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:

    1. Capture pool active/max and auth p99 at one-minute resolution through the next peak.
    2. Reproduce in staging with injected auth latency.
    3. Add a timeout budget and circuit breaker at the auth boundary; verify the 504 rate.
    4. 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:

    BranchHypothesisStateEvidence so far
    QR-01Connection-pool exhaustionActive504s 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-02Upstream gateway timeoutActiveA 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-03Auth-service latencyActiveThe auth middleware has a 29-second timeout against a roughly 30-second failure window; p99 latency during failures has not been measured.
    QR-04Worker memory growth / leakDormantIntermittent 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:

    1. Capture pool active/max and auth p99 at one-minute resolution through the next peak.
    2. Reproduce in staging with injected auth latency.
    3. Add a timeout budget and circuit breaker at the auth boundary; verify the 504 rate.
    4. 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

    Works with Claude Code, Cursor, Codex CLI, and any SKILL.md

    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

    1. Frame the state by separating verified facts from assumptions and unknowns.
    2. Open the possibility set using diverse strategies like direct derivation, decomposition, or numerical tests.
    3. Evaluate and route claims through verifiers like unit tests or formal solvers to calculate contradiction counts.
    4. 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. 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. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 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

    Python

    Permissions

    Terminal / Shell

    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.

    Listed25 days ago

    What's inside

    Frequently Asked Questions

    Unlike linear Chain-of-Thought prompting, this skill prevents 'hallucination drift' by maintaining multiple competing hypotheses at once and allowing the agent to backtrack if a lead proves false.

    The skill is model-agnostic and compatible with any high-reasoning LLM (such as GPT Claude or Google Grok ) that supports system instructions and tool calling.

    You will receive the core logic protocol instructions, the `branch_controller.py` Python reference script for managing state, and implementation guides for integrating it into your agent's workflow.

    Because this protocol explores multiple solution paths and uses adversarial testing, it consumes more tokens than a single-path prompt; it is best reserved for high-stakes, complex technical tasks.

    Setup involves importing the branch controller into your environment and configuring your agent's system prompt to follow the multi-path state management rules outlined in the documentation.

    Yes, buyers receive lifetime access to any updates made to the protocol logic or the Python controller script as new reasoning benchmarks and model capabilities emerge.

    New in Agents & Orchestration