Skill: chitinlabs/mythos (version 0.1.1)

--- name: mythos description: Recurrent-depth reasoning via iterative refinement. Use for complex analysis, multi-hop problems, design decisions, strategic planning — any question where single-pass answers would be shallow. version: 0.1.1 title: Mythos Skill author: chitinlabs type: command category: research invocation: /mythos tags: [reasoning, recurrent-depth, multi-round, latent-reasoning, claude-code] homepage: https://github.com/chitinlabs/mythos-skill license: MIT --- # Mythos — Recurrent-Depth Reasoning Implements a prompt-layer protocol inspired by the Recurrent-Depth Transformer pattern (OpenMythos hypothesis). The protocol is **three modes**, each mapping to a different CC primitive that approximates a different facet of latent-space recurrence: - **Silent** (default): Recurrent Block runs in your internal/extended-thinking reasoning. The user sees only the Coda — a compact Answer plus a one-line trajectory hint. Closest to the architectural mythos property of *no token-level commitment between loops*. - **Trace** (opt-in via `trace` keyword): Recurrent Block runs as visible token-level rounds with explicit insight chain. Maximally auditable. Use for teaching, debugging, deep-analysis posts where reviewers must verify each step. - **Agent** (default for complexity ≥ 4, opt-in via `deep`/`agent` keyword): Lenses dispatched as **parallel subagents** that explore independently, then a merge phase synthesizes them. Closest to the latent-multiplicity property of mythos — multiple alternatives explored truly in parallel before commitment. Invoke via `/mythos <question>` or the Skill tool. Mode keywords: - `/mythos trace …` → force trace mode (visible rounds) - `/mythos deep …` or `/mythos agent …` → force agent mode (parallel fan-out) - `/mythos quick …` → force silent mode (override agent default at high complexity) ## The Pattern ``` [User Question] ↓ [PRELUDE] — decompose, score complexity, pick mode + lens sequence ↓ [RECURRENT × N] — iterative refinement, three flavors: silent: lens rotation runs internally; no per-round emission trace: lens rotation emits visible rounds with insight chain agent: lenses dispatched as N parallel subagents, then merged ↓ [CODA] — cross-check, surface residual uncertainty, deliver ``` **Why three modes?** Architecture-level mythos (per OpenMythos hypothesis) reasons in continuous latent space — multiple reasoning paths encoded simultaneously, no token output between loops. The closest CC primitives to that property are: - **Internal/extended-thinking reasoning** for "no per-step token commitment" → **silent mode** - **Parallel independent forward passes** for "multiple alternatives explored simultaneously" → **agent mode** - Visible token rotation trades that faithfulness for auditability → **trace mode** Silent is the default because it preserves the latent-exploration property cheapest. Trace is opt-in because it has real value (debugging, teaching) but only when explicitly wanted. ## Mode Selection After Prelude: - complexity = 1 → **direct** (skip Recurrent Block; use degenerate Coda) - complexity 2-3 → **silent mode** - complexity 4-5 → **agent mode** Complexity score (1 point each): multi-hop dependencies, ambiguous trade-offs, likely hidden assumptions, novel domain, high-stakes decision. ### Mode keywords (parsed from invocation args / user message) Keywords are case-insensitive. Take only a **leading bare word** in slash-command args (e.g. `/mythos trace …` strips `trace` from the question). If multiple keywords appear in the wider user message, **last-wins**. Keywords apply AFTER complexity is computed — they override routing, not diagnosis. | Keyword | Effect | |-----------------|--------------------------------------------------------------| | `trace` | Force trace mode (visible rotation) regardless of complexity | | `deep`, `agent` | Force agent mode (parallel fan-out) even at complexity ≤ 3 | | `quick` | Force silent mode even at complexity ≥ 4 | Examples: - `/mythos How do I structure my CSS?` → silent (complexity ~2) - `/mythos trace Should we adopt Conventional Commits?` → trace mode for the same question - `/mythos deep Should we rewrite the renderer?` → agent fan-out (parallel subagents) - `/mythos quick Pivot or stay?` → silent even though Pivot question would normally route to agent ### Mid-flow mode escalation (one per session) The Prelude diagnosis can be wrong — Round 2 sometimes reveals a primary driver that was invisible at the start. When this happens: 1. Insert a **re-Prelude** block with the same template as STEP 1, plus `(re-Prelude after Round N)` in the heading 2. Update budget allocation only — do NOT discard prior rounds' insights (the insight chain or thinking-state carries forward) 3. If the re-scored complexity crosses the agent-mode threshold, escalate from silent/trace to agent for remaining lenses; document the escalation in Coda 4. **Silent → Trace escalation**: if Round 2 in silent mode surfaces a controversy the user needs to verify, you may switch to trace mode for the remaining rounds. Note this in Coda. 5. Limit: **one re-Prelude per session**. Repeated re-Preludes signal scope drift, not improving accuracy — halt and use what you have. Re-Prelude only when the *diagnosis* was wrong (a driver was missed). Do NOT re-Prelude just because a round produced a surprising insight under a known driver — that's normal recurrent depth. ## Output Modes ### Silent mode (default) The Recurrent Block runs **internally** — apply the Prelude's lens sequence in your own reasoning (use `<thinking>` extended-thinking blocks if available, otherwise apply the rotation as ordinary internal pre-output reasoning). Each lens must genuinely change your view of the problem; latent rounds (lens applied internally with no new insight) silently advance. Apply convergence criteria internally; if a new line of reasoning contradicts a well-supported earlier insight (negative delta), discard. The user sees ONLY the Coda: ``` ## Answer [direct, complete, actionable answer — typically 1-5 paragraphs] --- *Depth: N latent passes. Mode: silent. Lens path: Clarify → Deepen → Challenge → Synthesize.* *Load-bearing assumptions: [what would change the answer if wrong]* ``` For complexity = 1 (direct path), the footer collapses to: ``` *Depth: 0 rounds. Mode: direct.* ``` ### Trace mode (opt-in via `trace` keyword) Full visible rotation, the historically-original mythos behavior. The user sees: ``` ## Prelude **Q:** [precise restatement] | **Not:** [anti-scope] **Complexity:** [score]/5 → trace mode (forced), [total rounds] total | **Drivers:** [...] **Budget:** Clarify ×[n] → ... **Success:** [...] ### Round 1: Clarify **New insight:** [one sentence] **What changed:** [...] **Convergence:** evolving / stable / breakthrough / negative-delta ### Round 2: Deepen **Insight chain:** [R1: ...] **New insight:** [...] ... ## Answer [...] --- *Depth: N rounds, converged at round X. Mode: trace.* *Load-bearing assumptions: [...]* ``` Cross-round attention is explicit via the **insight chain**: from Round 2 onward, each round shows a 3-5 line summary of every prior round's "New insight" line, so later rounds cannot forget earlier discoveries. ### Agent mode (default for complexity ≥ 4, opt-in via `deep`/`agent`) Each lens dispatches as an **independent subagent in parallel** (single message, multiple `Agent` tool invocations). After all return, a **merge phase** synthesizes the independent perspectives. This approximates the architecture-level "multiple alternatives encoded simultaneously" property — each subagent really explores its lens without seeing the others. ``` ## Prelude [full diagnostic, like trace mode] [Dispatching 4 parallel subagents: Clarify, Deepen, Challenge, Steelman] ### Subagent A — Clarify **Independent finding:** [...] **Confidence:** high/medium/low ### Subagent B — Deepen **Independent finding:** [...] **Confidence:** ... ### Subagent C — Challenge **Independent finding:** [...] **Confidence:** ... ### Subagent D — Steelman **Independent finding:** [...] **Confidence:** ... ### Merge **Convergent points:** [insights present across multiple subagents] **Tensions:** [places where subagents genuinely disagree] **Synthesis:** [the integrated view, with tensions preserved if irreducible] ## Answer [...] --- *Depth: N parallel subagents merged. Mode: agent.* *Load-bearing assumptions: [...]* ``` Read `references/agent-blueprint.md` for the parallel dispatch pattern, lens-specific subagent prompts, and fallback strategy when subagents fail. ## Process ### STEP 1: Prelude — Understand, Diagnose, Allocate Read `references/prompt-templates.md` for the full Prelude template. 1. Restate the core question — more precise than the user's phrasing 2. Anti-scope — what is explicitly NOT being asked 3. Complexity score (1-5) → mode selection 4. **Complexity diagnosis** — identify the *primary complexity drivers* (pick 1-3): - Ambiguity: key terms are vague or undefined - Hidden assumptions: the question likely rests on unexamined premises - Multi-hop: the answer requires chaining multiple reasoning steps - Trade-offs: the core difficulty is weighing competing values - Novel domain: the problem space is unfamiliar or unprecedented - System dynamics: the problem is embedded in a complex system with feedback loops 5. **Adaptive budget allocation** — assign round budgets per lens based on drivers (read `references/lenses.md` for the full driver→lens mapping): | Primary Driver | Lenses that get 2 rounds (or 2 subagents in agent mode) | |---------------|---------------------------------------------------------| | Ambiguity | Clarify | | Hidden assumptions | Challenge, Steelman | | Multi-hop | Deepen, System-Think | | Trade-offs | Tradeoff-Map, Expand | | Novel domain | First-Principles, Expand | | System dynamics | System-Think, Edge-Hunt | Total rounds: typically 4-8 (silent/trace), 3-5 parallel subagents (agent). 6. Lens sequence — use the standard rotation as base sequence, with per-lens budget 7. Success criterion — what makes the answer good enough to stop **Gate:** If complexity = 1, skip the Recurrent Block entirely. Go directly to STEP 3 (Coda) and use its **degenerate path** (no trajectory review — see prompt-templates.md). ### STEP 2: Recurrent Block — Iterative Deep Refinement **Standard rotation (lens sequence, applies to all modes):** | Round | Lens | Question | |-------|------|----------| | 1 | Clarify | Define terms. Remove ambiguity. What's the precise question? | | 2 | Deepen | Root causes, first principles, generating functions — one level deeper | | 3 | Challenge | What assumptions? What's the strongest counterargument? | | 4 | Expand | What alternatives? What would a different expert see? | | 5 | Synthesize | Integrate all perspectives into one coherent answer | For specialized lenses (System-Think, Edge-Hunt, Tradeoff-Map, Invert, Scar-Tissue, First-Principles, Steelman), read `references/lenses.md`. **Adaptive budget:** A lens may get 2 consecutive applications (2 rounds in silent/trace, 2 parallel subagents in agent) if it addresses a primary complexity driver. For the 2nd application, find a new angle, stress-test the 1st conclusion, or go one level deeper. If the 1st application already converged (status = stable), skip the 2nd. **Mode-specific execution:** - **Silent mode**: Re-read the original question before each lens application (the `e` injection). Apply the lens in your internal reasoning. The lens must change how you see the problem — not just relabel it. Run latent rounds freely (apply lens internally with no emission). Halt per convergence criteria below. The Recurrent Block produces no visible output; only the Coda is emitted. - **Trace mode**: Re-read the original question before each round. Each round emits the per-round template: ``` ### Round N: [Lens] **Insight chain:** [R1: ... → R2: ...] (only when 2+ prior rounds exist) **New insight:** [one sentence] **What changed:** [...] **Convergence:** evolving / stable / breakthrough / negative-delta ``` Hard constraint: if you cannot produce a concrete new insight in a single sentence, the round has failed. Rephrasing under a new label is failure → halt. - **Agent mode**: See `references/agent-blueprint.md`. Dispatch parallel subagents in a single message (multiple `Agent` tool invocations). Each subagent receives: original question (verbatim) + Prelude + lens-specific instruction. Subagents do NOT see each other's intermediate work — that's the point. After all return, run the merge phase as described in the blueprint. **Convergence — halt when ANY of:** 1. **No delta** — round/lens output is substantively identical to a prior round 2. **Trivial delta** — new insight is minor compared to earlier insights 3. **Self-consistent** — answer is coherent, assumptions surfaced, counterarguments addressed 4. **Max rounds reached** — total visible rounds (or parallel subagents in agent mode) hit the Prelude budget 5. **Negative delta (overthinking)** — the new insight actively degrades quality: - Contradicts a well-supported earlier insight without strong new evidence - Introduces confusion (distinction without a difference, false tension) - Hallucinated under the current lens In silent mode: discard internally and halt. In trace mode: mark the round `negative-delta`, do NOT emit the bad insight as content, halt. In agent mode: surface the divergent subagent's finding with low-confidence flag and let merge resolve it. Anti-pattern: halting because you're tired of thinking. Check: is there an unresolved tension or unexamined assumption? If yes, one more round. But also: am I generating confusion just to fill the budget? If yes, negative delta — halt. ### STEP 3: Coda — Synthesize & Deliver Read `references/prompt-templates.md` for the Coda cross-check template (and the **degenerate Coda** for complexity-1). 1. Review trajectory — arc from Round 1 to convergence (silent: enumerate the lens path; trace: list each round's key insight; agent: list each subagent's finding plus the merge result) 2. Cross-check — is the answer consistent with every step of the recurrent block? 3. Residual uncertainty — what's unknown, what assumptions are load-bearing 4. Deliver the answer in the mode-specific output format above ## Principles - **The question is sacred.** Re-read it before every lens application. The question text is `e` — the original signal injected to prevent drift. - **Each round earns its keep.** One specific new insight per round. Rephrasing = failure → halt. - **Disagree with yourself.** Round 3 should find flaws in Round 2. That's the design, not a bug. - **Depth over breadth.** One insight fully explored beats three shallow observations. - **Converge and ship.** A tight 2-round answer that converged is better than a 5-round display of stamina. - **Mode matches stakes.** Silent is fast and faithful for ordinary depth. Trace pays a token cost for auditability. Agent pays a token + latency cost for genuinely independent multi-perspective exploration. Don't default-up. - **Insight chain (or thinking state, or parallel divergence) is your memory.** Don't let later steps forget what earlier steps discovered. - **Mind the overthinking trap.** More rounds are not always better. If a new lens only produces confusion, that's negative delta — stop. A shorter right answer beats a longer confused one. - **Faithfulness is a means, not an end.** The protocol exists to produce better reasoning, not to perform fidelity to a paper. If the reasoning is right, mode purity doesn't matter. ## Calibration Run `/mythos <question>` (or `/mythos trace <question>`, `/mythos deep <question>`) on any of these to verify reasoning quality. Each case is designed to stress specific mechanisms in specific modes. | Question | Expected silent | Expected trace | Expected agent | Mechanisms tested | |----------|----------------|----------------|----------------|-------------------| | "Should I use SQLite or PostgreSQL for a single-user desktop app?" | Concise answer; ≤3 lens path; no agent escalation | 2-3 visible rounds; Challenge questions framing | N/A (complexity too low — but `/mythos deep` should still produce ≥3 parallel subagents) | Complexity gate, early convergence | | "Our startup has 3 months of runway and our product has good reviews but declining retention. Pivot or stay?" | 4-5 lens path, mentions ≥2 alternatives in Answer | 4-5 rounds; Expand round must contain ≥2 distinct alternatives; Scar-Tissue surfaces failure patterns | Parallel: Clarify + Tradeoff-Map + Scar-Tissue + Invert + Synthesize subagents; merge surfaces tension between "pivot" and "stay" | Adaptive budget, parallel divergence | | "Design a caching strategy for a read-heavy API serving 10M users" | Answer mentions ≥1 non-obvious edge case | 3-4 rounds; Edge-Hunt round identifies stampede / herd / serialization | Parallel includes an Edge-Hunt subagent that surfaces edge cases independently | Specialized lens, overthinking detection | | "What would make our code review process 10x more effective?" | Answer challenges the "more reviews" framing | 3-4 rounds; Challenge surfaces framing assumption visible in final Synthesize | Parallel Challenge subagent reframes the question | Cross-attention / cross-divergence | | "Is it ethical to train AI on public web data without consent?" | Answer preserves genuine tensions, no false compromise | 4-6 rounds; Steelman builds strongest case for BOTH sides | Parallel includes 2 Steelman subagents (pro / anti) + Tradeoff-Map; merge MUST preserve irreducible tension, not paper over it | Multi-hop + hidden assumptions, false-compromise detection | **What to watch for:** - **Silent mode emits visible rounds:** mode routing is broken — re-read SKILL.md - **Trace mode skips Challenge/Expand:** standard rotation is not being followed - **Agent mode dispatches sequentially:** read `agent-blueprint.md` — parallel dispatch is the whole point - **Synthesize / Merge ignores early findings:** cross-step memory is broken (insight chain in trace, divergence list in agent, latent state in silent) ### Automated calibration runner From the source repo, run `install/calibrate.ps1` (PowerShell) or `bash install/calibrate.sh` (bash) to walk through all five cases interactively across all three modes. The runner prompts you for observed lens path, round/subagent count, and convergence behavior, performs structural checks against the expected baselines, and writes a timestamped report (`calibration-report-YYYYMMDD-HHMM.md`) to the same `install/` directory. The calibration runner ships only in this source repository, not in the marketplace skill bundle. The runner is **manual by design** — quality of mythos reasoning cannot be programmatically verified, only structural properties (lens presence, round count, parallel-vs-sequential dispatch). Treat FAIL counts as signals to re-read SKILL.md, not as ground truth.


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (MEDIUM)