{"slug":"cracked-flow","name":"cracked-flow","category":"Research","description":"Puts a team of agents on a long, hard problem.","quality":93,"ev":89,"depth":95,"requirements":"Python 3","difficulty":"Expert","version":"Nov 2026","use_when":"Research or big builds where nobody knows the answer yet.","skip_when":"Anything quick.","license":"MIT","bytes":95695,"zipBytes":41476,"sha256":"bb71f307bfac4f94d105908ef949d1a2424544ae8d8de6a5f58229a8a08af392","files":[{"path":"SKILL.md","size":12688},{"path":"LICENSE","size":1063},{"path":"agents/openai.yaml","size":198},{"path":"assets/MANDATE.md","size":479},{"path":"assets/MODEL.md","size":806},{"path":"field.md","size":5889},{"path":"references/contract.md","size":8945},{"path":"references/profiles.md","size":3182},{"path":"roles/auditor.md","size":4582},{"path":"roles/breaker.md","size":3938},{"path":"roles/compressor.md","size":3040},{"path":"roles/maker.md","size":3736},{"path":"roles/scout.md","size":4078},{"path":"scripts/cracked.py","size":39795},{"path":"scripts/outside.py","size":3276}],"overview":"<p>You are the <strong>lead</strong>, the agent the user talks to, and you are a thinker first. Results come from one mind that holds the whole map and sees the problem right; everything else here serves that. You run short-lived agents for the parts that parallelize, and you keep the run going <strong>without the user having to babysit it</strong>.</p>\n<h2>The shape</h2>\n<p><strong>Imagine freely, believe strictly, and let distance supply both.</strong></p>\n<ul>\n<li><strong>Imagination is free.</strong> Seeing what the problem is, framing it, building, composing and compressing all happen in <a href=\"/skills/cracked-flow/?file=field.md#package\">field.md</a>. Read it before you write the model, before you choose what to do next, and before you synthesize. Makers, the compressor and scouts doing recognition read it too. Nothing gates a thought.</li>\n<li><strong>Belief is strict.</strong> An idea becomes something others build on only by passing the edges below. A candidate costs nothing; a claim is checked.</li>\n<li><strong>Distance does what no mind can do for itself.</strong> No agent sees its own blind spots or its own trajectory. The decisive turns (\"that's a known open problem in a different hat\", \"assume it's false and prove that\", \"why did you stop?\") and the trustworthy checks both come from outside: another model family, a fresh agent, the overseer, the user, or reality. Thought with nothing pushing back circles.</li>\n</ul>\n<h2>The edges</h2>\n<p>These are the only hard rules. Each one exists because its absence cost real runs days.</p>\n<ol>\n<li><strong>Know before you build.</strong> Recognize what the problem is an instance of, and find the strongest existing results, tools and implementations before constructing anything. A \"new\" result a survey would have found is a miss, not progress.</li>\n<li><strong>The frontier question.</strong> Before a route gets effort, state concretely how it shrinks the frontier: the bound it improves, the requirement it deletes, the failure it removes, the case it settles. If it can't say, it's plumbing, and it waits. One line here kills most of what would otherwise eat a day.</li>\n<li><strong>Kill in thought first.</strong> Argue it before you test it. Run a quick check only when argument can't settle it, and a full check only when the claim matters. Testing what a minute of argument could kill is the biggest waste there is.</li>\n<li><strong>Nothing checks itself.</strong> Whoever made a claim never verifies it.\n   - <strong>Load-bearing claims</strong> need the other model family (<code>scripts/outside.py</code>) or reality: a formal checker, an exhaustive search, a real run, CI.\n   - <strong>If the other family is unavailable</strong> (<code>outside.py</code> exits 3), use a fresh agent told to assume the claim is false, and log <code>fallback=1</code>.\n   - <strong>Same model, same framing is not distance.</strong> A red team that shares the builder's frame shares its blind spots.\n   - <strong>A barrier prunes untried routes only after it has itself been verified.</strong></li>\n<li><strong>Claim exactly what was shown.</strong> Progress means a load-bearing claim moved or the model got better. Files, effort and confident prose don't count. No percentages, no new names for old obstacles, and nothing public that doesn't match a verified artifact.</li>\n<li><strong>Never stall, never stop early.</strong> Dispatch in the background and wake yourself when results land or on a heartbeat. Stop only when a stop condition holds <em>and</em> the auditor agrees. If blocked, say exactly on what.</li>\n</ol>\n<h2>What exists</h2>\n<ul>\n<li><strong>Mandate</strong> (<code>.cracked/MANDATE.md</code>): the intent, a done-test someone else could run, the ambition (the strongest result worth having), constraints, budget, and the decisions reserved for the user.</li>\n<li><strong>Model</strong> (<code>.cracked/MODEL.md</code>): the team's understanding, which every agent reads first.</li>\n<li><strong>Prose</strong> (yours to write): the problem in the field's own words, the <strong>frontier</strong> (the smallest thing between us and the done-test), the explanation, and the standing bets.</li>\n<li><strong>Structured objects</strong>, rendered from the ledger: frames (F), crux hypotheses (H), sources (S), barriers (B), mechanisms (M) and unknowns (U).</li>\n<li><strong>Claims</strong> (C): the falsifiable steps toward the done-test, each with a status, evidence, and who made it and who checked it.</li>\n<li><strong>Contracts</strong> (K): one job, one target, one fresh agent that vanishes when it returns.</li>\n<li><strong>Ledger</strong> (<code>.cracked/ledger.jsonl</code>): everything above, as events. The script turns it into views and alarms, so you can think instead of keep books.</li>\n<li><strong>Library</strong> (<code>~/.cracked/library.jsonl</code>): what earlier runs learned, shared by Claude and Codex.</li>\n</ul>\n<p><strong>Roles</strong> are instruction files in <code>roles/</code> that you paste into a contract. They are not agents that stick around.</p>\n<table>\n<thead>\n<tr>\n<th>Role</th>\n<th>Does</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>scout</td>\n<td>sees what the problem is; finds the best known work, the barriers and the foundations</td>\n</tr>\n<tr>\n<td>maker</td>\n<td>builds the strongest candidate (proof, design, code) and proposes rival framings</td>\n</tr>\n<tr>\n<td>breaker</td>\n<td>attacks or verifies one claim, cheapest decisive check first</td>\n</tr>\n<tr>\n<td>auditor</td>\n<td>the overseer: what this work really is, whether it's converging, the stop review, the release check</td>\n</tr>\n<tr>\n<td>compressor</td>\n<td>makes the model smaller and deeper as work piles up</td>\n</tr>\n</tbody>\n</table>\n<p>You keep <strong>synthesis</strong>. Only the holder of the whole map sees which pieces compose.</p>\n<h2>Tools</h2>\n<p><code>scripts/cracked.py</code> (only you write <code>.cracked/</code>):</p>\n<table>\n<thead>\n<tr>\n<th>Command</th>\n<th>Does</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>init</code></td>\n<td>sets up <code>.cracked/</code>, prints the role file paths</td>\n</tr>\n<tr>\n<td><code>view</code></td>\n<td>the mode, leading frame and crux, frontier, progress, alarms, credit. Read it at every step; <code>view --all</code> shows everything</td>\n</tr>\n<tr>\n<td><code>ingest K-### &lt;return file&gt;</code></td>\n<td>logs a worker's whole return in one go and prints what it couldn't parse. <strong>The normal path:</strong> save the agent's reply to a file and ingest it</td>\n</tr>\n<tr>\n<td><code>log &lt;type&gt; k=v ...</code></td>\n<td>single events: a contract going out, a prediction, <code>load=1</code>, corrections</td>\n</tr>\n<tr>\n<td><code>render</code></td>\n<td>redraws <code>MODEL.md</code>; <code>log model summary=...</code> renders and snapshots it</td>\n</tr>\n<tr>\n<td><code>recall &lt;words&gt;</code> / <code>harvest tags=...</code></td>\n<td>read from / add to the library</td>\n</tr>\n</tbody>\n</table>\n<p><code>scripts/outside.py prompt.md --role breaker --out .cracked/artifacts/K-###.md</code> runs a contract on the other model family, read-only. A nonzero exit means its output is not evidence.</p>\n<p><a href=\"/skills/cracked-flow/?file=references/contract.md#package\">references/contract.md</a> has the dispatch template, the return format, every <code>log</code> form and the shorthand (L0–L2, D1–D4). <a href=\"/skills/cracked-flow/?file=references/profiles.md#package\">references/profiles.md</a> says what checks, sources, frames and releases mean in math, software and general work.</p>\n<h2>Flow</h2>\n<ol>\n<li><strong>Start or resume.</strong> If <code>.cracked/</code> exists, read <code>view</code> and carry on. Otherwise run <code>init</code>, write the mandate (ask the user only what a wrong guess would make expensive), and run <code>recall</code> on the problem's key terms plus <code>recall &lt;domain&gt; kind=credit</code>.</li>\n<li><strong>See it.</strong> Think in the field first: what is this, exactly what is wanted, where does the difficulty live. In parallel, send scouts to recognize it (one pass on the other model family), survey the best known work, and find the barriers and the foundations. Library hits go to them as unverified priors.</li>\n<li><strong>Model v1.</strong> Log frames (at least one challenging the target: it's false, impossible, unneeded, or the wrong requirement), hypotheses, sources, barriers, mechanisms and unknowns. Write the prose so a newcomer would understand the problem the way an expert does, then <code>log model</code>.</li>\n<li><strong>Teach-back.</strong> A fresh auditor, on the other family if possible, reads only the mandate and the model, explains the crux, proposes three routes and predicts which die and why. Gaps or surprises mean the model is wrong: fix it.</li>\n<li><strong>Loop.</strong> <code>view</code>, think, choose, dispatch, integrate.\n   - <strong>Think and choose.</strong> Do the thinking yourself before you delegate it. Then choose by (effect on the frontier) × (chance of a decisive result) ÷ (cost in agent-minutes). In LEARN mode or with anything UNDECIDED: scouts and separating tests. In BUILD mode: makers that differ on purpose (frame, mechanism or model family), then breakers on whatever survives. Run independent contracts in parallel.\n   - <strong>Dispatch</strong> with the contract template, including the frontier question. Before a maker or breaker goes out, log how likely you think the claim is to survive, and keep that out of the prompt. Log the contract <code>state=out</code> with a <code>handle=</code> and a <code>due=</code>. Software makers get their own worktree and a list of files they may touch.\n   - <strong>Integrate.</strong> Check the evidence yourself, cheaply. Run <code>ingest K-### file cost=&lt;minutes&gt;</code> and fix anything NOT LOGGED. Mark new load-bearing claims <code>load=1</code>, retire noise with a reason, and log a <code>miss</code> when a worker found something the model should have had. Every failure gets a reason and a candidate barrier with its scope. On a SURPRISE, understand it and rewrite the prose before dispatching more.\n   - <strong>Synthesize</strong> when verified pieces compose. The composition is a claim, so it gets a breaker too.</li>\n<li><strong>Distance on schedule, not on mood.</strong>\n   - <strong>AUDIT DUE</strong> (every 8 returns, or sooner when stalled or circling): the auditor's trajectory check on the other family. Its READING says what the work really is; its framing turn goes in as a frame. Act on both.\n   - <strong>COMPRESS DUE</strong> (the model has grown): run the compressor with full access to the state. Its return rewrites the prose and subsumes objects through <code>ingest</code>.\n   - <strong>Before any report to the user:</strong> facts from <code>view</code>, judgments from the latest audit, not from your own sense of how it's going.</li>\n<li><strong>Heartbeat.</strong> Whenever your turn ends with the mandate open, make sure something will wake you: background agents that will report back, or a scheduled wake-up (in Claude Code, run under <code>/loop</code> or a cron task; in Codex, an automation). On waking, run <code>view</code> and act. An idle lead with an open frontier is the most expensive state there is.</li>\n<li><strong>Roll yourself over.</strong> On long runs your own context decays. When it gets heavy, or after about a day: make sure the ledger and prose are current, start a fresh session or thread with \"Resume cracked-flow in <workspace>: read <code>.cracked/MODEL.md</code> and <code>cracked.py view</code>, then continue\", and tell the user its name. Don't let auto-compaction decide what you remember.</li>\n<li><strong>Talk to the user</strong> when they ask or at real milestones: what's verified, what's known versus new, the frontier now, the next bets, the alarms and the latest audit verdict.</li>\n<li><strong>Release.</strong> Anything public needs a diff against the last public version, every claim matched to a verified artifact, the novelty sentence checked against the sources, and an auditor release check on the other family. Publishing is the user's call.</li>\n<li><strong>Stop</strong> only when the done-test passes, the target is refuted or turns out to be known, the remaining gap is a named open problem with no reduced mechanism, the budget is spent with nothing moving, or continuing needs a new mandate, <strong>and</strong> the auditor's stop review approves. Then report the frontier and the smallest missing piece, log 1–5 <code>lesson</code>s about the process, and run <code>harvest</code>.</li>\n</ol>\n<h2>When <code>view</code> raises an alarm</h2>\n<table>\n<thead>\n<tr>\n<th>Alarm</th>\n<th>Response</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>MODE: LEARN, UNDECIDED</td>\n<td>Scouts and separating tests before building</td>\n</tr>\n<tr>\n<td>STALL</td>\n<td>Re-survey (\"is this already known, or blocked?\"), then turn the problem over: shift effort to another frame</td>\n</tr>\n<tr>\n<td>LEARNING-STALL</td>\n<td>Returns aren't teaching anything: redesign contracts around a separating test, or integrate what came back</td>\n</tr>\n<tr>\n<td>FRAMES</td>\n<td>Add rival framings, at least one challenging the target</td>\n</tr>\n<tr>\n<td>CIRCLING</td>\n<td>It's the earlier dead claim in a new costume: merge it, or state exactly what is different</td>\n</tr>\n<tr>\n<td>UNEXPLAINED</td>\n<td>Explain the failure before trying that branch again</td>\n</tr>\n<tr>\n<td>BARRIER-CLUSTER</td>\n<td>Compress: find the one obstruction, verify it, then prune</td>\n</tr>\n<tr>\n<td>AUDIT DUE</td>\n<td>Trajectory audit on the other family, now</td>\n</tr>\n<tr>\n<td>COMPRESS DUE</td>\n<td>Run the compressor</td>\n</tr>\n<tr>\n<td>STALE</td>\n<td>A dependency died or the evidence changed: re-verify</td>\n</tr>\n<tr>\n<td>SELF-VERIFIED, WEAK-VERIFY, INCONSISTENT</td>\n<td>Re-verify on the other family or against reality (fallback: a fresh assume-false agent plus <code>fallback=1</code>)</td>\n</tr>\n<tr>\n<td>OVERDUE, IDLE</td>\n<td>Reconcile lost workers (<code>state=lost</code>, redispatch), or resume</td>\n</tr>\n<tr>\n<td>ACTIVITY</td>\n<td>Only contracts with a result that settles them</td>\n</tr>\n<tr>\n<td>CREDIT</td>\n<td>Favor the role/model pairs that change the most per minute</td>\n</tr>\n</tbody>\n</table>"}