ECC
The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
- 309k
- JavaScript
- MIT
- 3 d ago
Your Claude session does the thinking; cheaper model subscriptions do the typing. A Claude Code skill and panel that run GLM-5.3, gemini-3.8-flash (agy), grok-4.6, Muse Code and any OpenRouter id as headless sub-agents — spec linting, quota gates, model-identity assertions, git-safety hooks, and the measured rounds every rule came from.
Repo midagedev/outsource, read from GitHub 1 min ago. midagedev has not joined Take My Repo.
midagedev/outsource is a public repo on GitHub by midagedev. Your Claude session does the thinking; cheaper model subscriptions do the typing. A Claude Code skill and panel that run GLM-5.3, gemini-3.8-flash (agy), grok-4.6, Muse Code and any OpenRouter id as headless sub-agents — spec linting, quota gates, model-identity assertions, git-safety hooks, and the measured rounds every rule came from. It declares the MIT license on GitHub. It is written mainly in Go, has 1 stars and last changed on 2026-11-20. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Your Claude session does the thinking. Cheaper model subscriptions do the typing.
A Claude Code skill that runs third-party model CLIs as headless implementation sub-agents. The lead Claude session keeps the work where judgment matters — specs, diff review, gates, commits — and outsources implementation, mechanical edits, investigation, and screenshot verdicts to models whose tokens are effectively free on a subscription.
It is not a wrapper. It is an operating manual with receipts: every rule in it came from a measured round, and the comparison below is how the rules were found.
A round is three choices, and they are separate. The model does the work. The provider is the account it runs on: it decides quota, login, and what happens to your prompts. The harness is the CLI that drives the model headlessly: it decides how the git ban is enforced and what you can watch. outsource-run --list-wiring prints what is wired today, models included.
Models — what you pick for a round
| Model | Provider · harness | Use it for | Watch out |
|---|---|---|---|
| GLM-5.3 — the default | zai · headless Claude Code (claude -p, default) or the crush CLI, on the z.ai coding plan |
every spec-able round: implementation, gate authoring, code investigation | blind — it cannot read images; does not flag a contract it cannot satisfy |
| glm-5.3-flash — same plan, 3× the quota | zai · the same two | mechanical edits and large fan-out when 5.3 quota is the constraint, plus capture self-verification — it sees pixels (read a solid #1E50DC back as #2244DD, ~5% per channel) |
measured slower than 5.3 on every benched task — its value is quota and eyes, not speed |
| gemini-3.8-flash-high — Google plan | agy · the agy CLI (Antigravity) |
spec-able rounds on a separate quota pool. Its predecessor 3.7 was the fastest arm benched (2–3× on two of three tasks) and the best measured vision (named a solid #1E50DC PNG's hex exactly); 3.8 is not re-measured yet |
exit 0 ≠ success — the launcher reads the result event's status |
| step-5-preview-free — OpenCode Zen, free for a limited time | zen · the opencode CLI |
a process family at no cost and no login, with a 1M context. Reads shape and colour family (7 and L right; #1E50DC read as #3A5BF0) |
borrowed: the free window ends when OpenCode ends it (announced as one week on 2026-10-09). Once answered a glyph probe without opening the image — a verdict counts only if the log shows the read call |
| grok-4.7 (CLI; the xai API row stays grok-4.6) | the grok CLI; also xai · Claude Code or crush |
vision verdicts, image/video generation, web research | notices a hazard and implements it anyway unless the spec forbids it (measured on 4.6) |
| muse-spark-1.3-contributor — Muse Code | muse · the muse CLI |
a fourth process family on its own account, with a 262k context and a reasoning-effort knob (--effort → --reasoning-effort); reads shape and colour family (a drawn H read back as H, a #1E50DC fill as "blue") |
the CLI has no hook and no definable permission profile, so an unguarded round commits — measured. The git guard here is a git shim first on the round's PATH (refuses with exit 97), which an absolute-path call still gets past |
any OpenRouter id — you name it, set a default, or let --model free pick |
openrouter · headless Claude Code (claude -p, default; the bare id, vendor/id), or the opencode CLI (--model openrouter/<vendor>/<id>) |
a process family for when the plans are out of headroom. --model free picks a free, tool-capable id from the live catalogue (Free models) |
no default id: name one, set one (Your own defaults), or use free. Free ids come and go week to week, and most of them train on your prompts. OpenRouter limits :free ids to 20 requests a minute and 50 a day, or 1,000 a day once the account has bought 10 credits (its limits page). Vision on this arm is measured only on opencode: a stealth id read shape but not colour (a blue fill called "dark maroon") |
Providers — whose account, whose terms
| Provider | Login | Plan quota readable | Your prompts |
|---|---|---|---|
| zai | z.ai coding-plan key (bin/credential.sh) |
yes (bin/quota.sh) |
a named account with stated terms |
| xai | x.ai key (bin/credential.sh) |
no | a named account |
| agy | the Antigravity CLI's Google login | no | a named account; shared ~/.gemini config, no per-track isolation |
| muse | Muse Code's OAuth session — its Anthropic-compatible endpoint answers an API key with billing_error |
no | a named account |
| zen | none for a free id | no | per id: step-5-preview-free is "zero-retention" and not used for training; other free Zen ids are not (one trains on your data during its free period) |
| openrouter | an OpenRouter key: OPENROUTER_API_KEY, bin/setup-key.sh openrouter, or the one opencode auth login already stored (read, never copied) |
no — pay per token; free ids cost nothing | per id: outsource models shows each id's data policy, read from the policies of the providers OpenRouter routes it to. --model free takes only ids that neither train on nor retain your prompts unless you allow it |
Harnesses — the CLI that drives it
| Harness | Git ban | Live trail | --effort |
Inbox · resume after a 429 | Identity check |
|---|---|---|---|---|---|
| claude-code | PreToolUse hook (bin/git-guard.sh) |
session transcript | yes | yes · yes | the transcript's model field |
| crush | the same hook | data/logs/crush.log |
no | no · no | none — crush logs no model |
| opencode | permission deny in its isolated config | --log (JSONL) |
no | no · no | opencode export |
| agy | deny rules in the shared ~/.gemini settings |
--log (stream JSON) |
no | no · no | the conversation trajectory db |
| muse | git shim first on PATH |
--log (JSONL) |
yes | no · no | muse export |
Codex on Cheaper Inference is a sidecar, not a launcher arm: the codex CLI itself, redirected by bin/codex-ci at Cheaper Inference, for ad-hoc, hand-supervised rounds in Codex's own harness, paid per token instead of per subscription. CI_MODEL (default gpt-5.6-sol; gpt-6-astra costs 7×, gpt-5.6-luna ~1/12) and CI_EFFORT (default medium) pick the arm. It is outside the launcher: no run registry, no git guard, no done-marker, no identity assertion, no quota gate.
Adding or withdrawing an arm is a row in one of three tables, not a refactor (How an arm is wired).
A status line and a panel make delegation legible while it happens — what stops this session, what stops the next round, and what is running right now:
opus │ you@example.com │ CTX 12% │ 5H 8%/3h20m │ 1W 38%/4d2h
z.ai 29%/6d4h │ grok 98%/2h19m │ 🛠2 ▶api zai·crush 12m ▶tests zai·cc 4m │ repo (main)
Claude Code, plus at least one backend:
agy CLI (Antigravity, Google plan);grok CLI;muse CLI (Muse Code);OPENROUTER_API_KEY, in its own store (bin/setup-key.sh openrouter), or where opencode auth login put it;opencode CLI, for OpenCode Zen's free ids (no login needed) or to run OpenRouter on the opencode harness.The codex-ci sidecar is separate: it needs the codex CLI and a Cheaper Inference key in CHEAPER_INFERENCE_API_KEY.
Go is optional. No binary is committed to this repository: each machine builds one with Go, or downloads a release binary and runs it only if its sha256 matches the committed manifest (Verifying the binaries).
| Marketplace | Install script | |
|---|---|---|
| The skill lives in | ~/.claude/plugins/cache/outsource/outsource/<version>/skills/outsource/ |
~/.claude/skills/outsource/ (--project: ./.claude/skills/outsource/) |
| The panel | loaded with the skill | claude --plugin-dir <clone>/mods/outsource-panel |
| A local overlay | inside the version folder, so an update replaces it | kept across upgrades |
Pick the install script if you keep a local overlay.
Marketplace — inside Claude Code:
/plugin marketplace add midagedev/outsource
/plugin install outsource@outsource
The root plugin loads mods/outsource-panel through its hooks/hooks.json, so the skill and the panel arrive together. Every path in this README that starts ~/.claude/skills/outsource/ starts in the plugin cache folder above instead. To keep an overlay with this install, set OUTSOURCE_SKILL_DIR to a folder you keep whose references/ holds local-overlay.md and overlays/.
Install script:
git clone https://github.com/midagedev/outsource cd outsource ./install.sh # user scope: ~/.claude/skills/outsource/ ./install.sh --project # project scope: ./.claude/skills/outsource/
With Go, install.sh builds the binary. Without Go, it downloads and verifies one at install time, so a missing network fails the install rather than the first round (--no-fetch skips the download). From a clone, claude --plugin-dir <clone> also loads the skill and the panel together for one session.
If you already set up z.ai — with npx @z_ai/coding-helper, or the crush CLI — there is nothing to do. Your key is found where those tools put it.
Otherwise, set it once. This prompts, verifies the key against z.ai before storing it, and writes ~/.config/outsource/credentials at mode 0600:
~/.claude/skills/outsource/bin/setup-key.sh zaiexport ZAI_API_KEY=… beats both. bin/credential.sh is the single owner of that resolution — and of which host your account lives on, so a mainland-China plan reaches open.bigmodel.cn instead of 401ing against the global one. The launcher never prompts: it runs headless in the background, where a prompt would hang a round instead of failing it. The crush CLI itself is only needed for --harness crush.
Referral link: https://z.ai/subscribe?ic=P7NR6BGEGL — 10% off for you, credit for this project. Optional; every other z.ai link here is the plain https://z.ai/subscribe.
The repository carries the skill, not your setup. On a new machine:
local-overlay-<name>.md before ./install.sh (the script seeds references/local-overlay.md from it when the install has none), or copy it straight to references/local-overlay.md in the installed skill. Copy references/overlays/ too if you declared project overlays. The repository never ships them.~/.claude/settings.json, and copy any shell alias you use, such as one for bin/glm.sh.--plugin-dir, as in the table above.~/.claude/skills/outsource/bin/quota.sh prints your z.ai plan. The first call also builds or fetches the binary if this machine has none.claude plugin marketplace update outsource, then claude plugin update outsource@outsource, then restart Claude Code.git pull && ./install.sh. A checksum manifest lets an unmodified install upgrade without flags; a hand-edited install needs --force. references/local-overlay.md always survives.Say "run this via glm" — or grok, or agy — in any Claude Code session, or invoke /outsource. Claude then:
The core principle: the delegate is an executor of tight specs. It has zero conversation context, so every delegation stands alone — and it is never asked for taste judgments, only numeric contracts.
Your choices live in one file, not in the code: $OUTSOURCE_CONFIG, else $XDG_CONFIG_HOME/outsource/config.json, else ~/.config/outsource/config.json. Edit it with outsource config, or with /rounds setup in the panel:
B=~/.claude/skills/outsource/bin/outsource $B config set providers.openrouter.defaultModel z-ai/glm-5.3 # a bare id $B config set providers.muse.enabled false # never route there $B config set free.allowTraining true # see Free models $B config set context.autoCompactWindow 400000 $B config list # every key, set or not $B config path # which file, and why
| Key | Value | Effect |
|---|---|---|
providers.<p>.defaultModel |
a bare id | the model when --model is absent. Precedence: --model, then the provider's model env var (GLM_DELEGATE_MODEL for zai), then this, then the table |
providers.<p>.enabled |
true / false |
false refuses every launch on that provider (exit 64) |
free.allowTraining |
true / false |
lets --model free pick ids that train on or keep your prompts |
free.denyPaths |
a list of globs (~, **) |
a round whose --cwd is under one never runs a free id |
context.autoCompactWindow |
tokens, default 600000 | on the claude-code harness, the auto-compact window is the smaller of this and the model's context window |
set refuses a value the launcher would refuse — a qualified id (opencode/x for zen), an OpenRouter router id, a wrong type — and names the fix. A file that does not parse refuses every launch rather than route past a choice it could not read. Keys it does not know are kept.
outsource models lists what the catalogue providers (OpenRouter and OpenCode Zen) offer right now, with context, price, tool support, expiry, and a data policy per id: no-train-no-retain, retains, trains or unknown. --free keeps the ids that cost nothing.
--model free lets the launcher pick one for the round. A candidate must be free and not a router, tool-capable, current, at least 128k of context, and — unless you allow training — no-train-no-retain:
outsource-run --provider openrouter --model free … # picks on OpenRouter outsource-run --provider zen --model free … # picks on Zen outsource models --pick free --provider openrouter # what it would pick, and why
The pick is printed once and recorded in the sentinel (model_selector=free); a detached round runs exactly that id. Your configured default wins when it qualifies. When nothing qualifies, the refusal counts what each filter dropped. Free ids churn weekly and most of them train on your prompts, which is why the policy gate is on by default; --allow-free-training lifts it for one launch. A named id on these two providers is checked against the catalogue too: one it does not list, a router, an expired id or one without tool support refuses before the round starts. OUTSOURCE_CATALOG=off turns all catalogue traffic off (OpenRouter).
A delegated round runs in the background, and between "I launched it" and "it reported" it is invisible. Every launch therefore registers itself, and bin/runs.sh reads the registry back:
$ bin/runs.sh
STATE LABEL PROV HARNESS ELAPSED SPEC
running api-migration zai crush 12m /tmp/sp/spec-api.md
running test-backfill zai cc 4m /tmp/sp/spec-tests.md
orphan docs-sweep xai crush 1h07m /tmp/sp/spec-docs.md
started but never finished — pid 48120 is gone; log=/tmp/sp/docs.log
orphan is the reason this exists. A round that was killed, or died when the machine slept, leaves no process at all — so a ps grep reports the same nothing for "finished cleanly" and "died an hour ago holding your worktree". Started-but-never-finished is a state only a written record can hold. bin/runs.sh json is the same data for scripts.
A round its plan limit cut (HTTP 429) is not shown as a bare rc=1. runs.sh prints ⛔quota resets 20:32 (plan) — the plan quota API's reset when the launcher could read it at the death, else the 429 text's, marked (429 text). A round --resume-on-reset is holding is in state waiting and shows ⏸quota → 17:24, the latest it wakes. runs.sh json carries quotaExhausted, resetAt, resetSource and waitingUntil. All of it comes from the sentinel and the record; runs never reads a trail.
runs.sh says whether a round is alive. To see what it is doing, follow its live trail:
$ bin/tail.sh test-backfill -f
── test-backfill · zai·claude-code · running · …/projects/-Users-me-repo-app/2e156be9….jsonl
14:11:14 🔧 Bash go test ./internal/launch/
14:11:48 🔧 Read /Users/me/repo/app/internal/launch/wiring.go
14:11:50 ✗ Bash: FAIL github.com/me/app/internal/launch
14:11:51 💬 The pairing gate fails first, as expected. Fixing the harness row.
── round 1789449070-74619: done rc=0
One line per turn, newest last: 💬 what the round said, 🔧 what it ran, ✗ a tool call that came back an error. -f follows and returns when the round does — the registry's exit code ends it, never a timeout. --all adds thinking blocks and successful tool results, --raw hands back the trail's own lines for jq, -n bounds how much history is rendered.
The trail is the harness's own session transcript. On the claude-code harness --log is written once, at exit, so there is nothing to follow there. Which .jsonl under <config-dir>/claude/projects/<cwd-slug>/ belongs to this round cannot be worked out from outside: the newest file is right until two rounds share a cwd, and then it is silently the wrong round. So the round says it itself: a SessionStart hook records its transcript path into the registry on the first turn, runs.sh prints it as trail=, and the completion sentinel keeps it after prune drops the record. A label that several live rounds share is refused with the candidates listed rather than resolved by a guess.
Neither GLM harness can stop itself: crush run has no turn or time limit in its flag set, and the claude CLI has no --max-turns, only --max-budget-usd at Anthropic's prices, which says nothing about a z.ai plan. A time limit is the tempting fix. Measured across ten delivered rounds, it is the wrong one: they ran 13 minutes to 1h50m, with duration tracking message count almost linearly (66 messages / 13m … 848 messages / 1h50m). Long rounds were long because there was a lot of work. A time limit truncates those and still misses a round that wedged at minute three.
So the registry measures output, not duration. runs.sh reports an IDLE column and flags ⏳ only when a running round has written nothing for ten minutes (OUTSOURCE_RUN_STALL):
▶refshot zai·crush 1h41m # 101 minutes in, wrote a second ago — leave it alone
⏳frozen zai·crush 22m ⋯14m # silent for 14 of its 22 minutes — go read its trail
An elapsed-time rule would have flagged the healthy 101-minute round and said nothing about the wedged one. What counts as output depends on the harness: data/crush.db-wal and data/logs/crush.log for crush, the session transcript named by trail= for claude-code, and --log itself for opencode and agy, which flush stream-JSON there one event at a time.
Reading the trail is step one, not the verdict. Measured 2026-08-28: a round sat at ⏳ ⋯57m, and its transcript's last line read "Adding the Core-level quarantine gates" — indistinguishable from a delegate mid-edit. It was not. The round had shelled out to a test runner that deadlocked, and the harness was blocked on a child that would never return; the round had been dead for an hour while looking busy. What separated the two was the descendant process tree, which the log cannot show:
pgrep -P <round-pid> # what the round is actually blocked on
ps -o pid,%cpu,etime -p <child-pid> # 0.0% CPU for minutes = wedged, not working
sample <child-pid> 2 -file /tmp/s.txt # macOS: where it is parked
A working child burns CPU. A child at 0.0% for minutes, with the round's IDLE past the stall threshold, is a hang — and the frame it is parked in usually names the cause outright (here: XCTWaiter inside a test whose two awaits were ordered so it waited on work its own held lock blocked). Kill the child, not the round: the harness notices the runner died, reports, and the round's completed edits survive on disk.
A stall is a reason to read the trail, not to kill anything. bin/outsource-run.sh --max-seconds N does hard-kill at N seconds (SIGTERM then SIGKILL to the whole process group, exit 124 in both the sentinel and the registry, session id still recovered so a follow-up can resume). It has no default and should not get one, because the kill lands mid-edit. Use it only where losing the round is acceptable up front.
--label is what the track is for. Type it on every launch: the listing earns its keep in parallel, and that is exactly when the derived default fails. This skill writes every track's spec to <scratch>/spec.md, one dir per track, so a label taken from the file name would read spec three times. The default therefore falls back to the directory holding the spec, and a label that still collides renders as name, name#2 — a warning that the round you are looking at cannot be identified, not a naming scheme.
A claude-code round records its inbox socket, and runs.sh prints it on a running round's detail line:
running api-migration zai cc 12m 4s …
trail=…/2e156be9….jsonl (follow: outsource tail 1789449070-74619) inbox=uds:/tmp/cc-socks/74702.sock
Send a correction there with Claude Code's SendMessage tool (to = that address). The round reads it between two tool calls, without a restart. Measured 2026-10-06: the message reached the round about 56 s later, and the round quoted it verbatim in its report. The address is needed because a round runs with its own CLAUDE_CONFIG_DIR, and cross-session discovery is split by config dir: the round never appears in ListAgents. Each round's settings carry crossSessionInbound: accept. Otherwise a -p round in bypass mode would hold a message from a lead outside bypass mode, then drop it after five minutes.
Each launch also tells the round who its lead is. The round's prompt opens with a "Launcher notice: your lead" section:
lead-token: <token>, is an amendment to the spec with the spec's authority. It cannot lift the preamble's bans (git writes, launching rounds, spawning agents).The token is minted per launch (16 random bytes) and stored in the run's registry record, which is owner-only (mode 0600). outsource runs json shows it as leadToken; the sentinel records only lead_socket=. The panel's round_send puts the token line in front of your text. To send by hand, read messagingSocket and leadToken from outsource runs json, then use SendMessage with to = uds:<messagingSocket> and a message whose first line is lead-token: <leadToken>. The token survives a lead restart; the socket does not.
A round from an older launcher may have no lead notice, or no inbox at all. The panel and mcp__outsource__rounds say which (inbox=no (<reason>)); stop it and resume with --session <id> to get both.
outsource runs stop <label|id> [--reason <text>] stops a running round:
--kill-after N), it sends KILL to the child's process group.rc= line. The sentinel carries stopped_by=lead and stop_reason=.Do not TERM the outsource-run wrapper yourself. While a harness child runs, the wrapper holds TERM on purpose, so the sentinel survives a caller's timeout. A round that --resume-on-reset is holding has no child, so runs stop sends TERM to its wrapper, which ends the wait and writes the sentinel. A label that several live rounds share is refused with the candidates; another session's round (⇄) needs --any-owner. A round with no recorded child — one launched by grok-run or by an older outsource-run — is refused. Exit codes: 0 stopped, 3 no such round, 64 usage, ambiguous, foreign or pid mismatch, 1 anything else.
When a signal ended the harness, the sentinel says which signal and where it came from: harness_signal=<NAME> and signal_source=lead-stop|watchdog|wrapper|external (watchdog is --max-seconds). runs shows such a finished round as ■<label> stopped or ✗<label> TERM ext. The claude CLI catches TERM and exits 143 itself (measured on 2.1.291), so rc=143 with harness_signal=TERM is a caught TERM, and rc=-1 is a child that died by the signal. The sender's pid cannot be known, so external means: no stop request, no watchdog, and no signal to the wrapper.
A report says what a round claims, and the diff says what it left behind. Neither says what it ran. bin/audit.sh <round> (the same selector as tail) reads a claude-code transcript, subagents included, or an agy log, and prints a review summary:
MODEL DRIFT on any other id;git-write, rm-rf, pgrep-wait, pipe-tail, nested-launch, network-install;written-and-changed, changed-without-file-tool and written-but-unchanged;--json prints the event list. Its kinds borrow Apache Maka's RuntimeEvent taxonomy: model_request, function_call/response, permission_decision, error, message_received, subagent_spawn, termination. Maka's log has no tamper evidence, so this adds a small piece. The launcher writes trail_sha256 / trail_bytes / subagents_sha256 into the sentinel after the harness exits, and audit returns one of four verdicts:
ok;extended: bytes appended with the sealed prefix intact, which is what a --session resume does;mismatch: exit 3;absent: an older round.mods/outsource-panel draws all of this inside the lead session, without spending a turn. The marketplace install includes it; with the install script, load it with claude --plugin-dir <clone>/mods/outsource-panel (Install). Load it one way, not both: if the marketplace install and that flag meet in one session, only the bundled copy runs — the standalone one registers nothing and says why in the debug log. The panel runs the outsource binary it finds first: OUTSOURCE_PANEL_BIN, then the plugin's own skills/outsource/bin/outsource, then the clone around a standalone copy, then ~/.claude/skills/outsource/bin/outsource; the debug log names the one it chose.
/rounds opens a pane with:
/rounds send <label> <text> sends without opening the pane./rounds wake [on|off] toggles the model wake (default on; a bare /rounds wake prints the state; off leaves the toasts)./rounds setup opens a second pane over your own defaults: one line per provider with on/off and its default model, a button that switches the selected provider on or off, an input that sets its default (empty clears it), and for OpenRouter and Zen a list of up to eight free, tool-capable ids from the live catalogue. It reads and writes only through outsource config, so a value the launcher would refuse is refused here with the same line. One outsource pane is open at a time; /rounds setup again closes it./rounds off turns the whole panel off — no polling, band, toasts, wake or pane, and the two tools answer an error — until /rounds on, which resumes without waking for anything that changed meanwhile; the setting persists, default on. /rounds wake off silences only the model wake and leaves the rest running.The panel also talks to the lead model, not only to you. When one of this session's rounds finishes, fails, is orphaned or stalls, the mod submits one [outsource-panel] prompt, so a lead with the panel loaded does not need to arm wait.sh for rounds it launched here.
UserPromptSubmit hooks like a typed prompt..rc sentinel, the diff, audit — and then a line to re-run the gates. The outsource commands are spelled with the installed binary's absolute path, because outsource is not on PATH.mcp__outsource__rounds and mcp__outsource__round_send (mcp__outsource-panel__rounds and mcp__outsource-panel__round_send when the panel is loaded on its own), and a system-prompt section that states all of this and names the tools as they are registered. With the wake off, the section says "arm wait.sh as usual".All data comes from outsource runs json and outsource tail, so the mod parses nothing itself. "Own" is the session id that launched the round. A brand-new session, or one after /clear, sees earlier rounds as foreign. Resume the launching session (claude --resume <id>, plus the same --plugin-dir if that is how you load the panel) to keep them yours. A terminal outside fullscreen seats the pane inline above the prompt, and the pane asks for the rows its whole tree needs. A round labelled send, wake, on, off or setup is reachable through the pane's round Select — those words are subcommands first.
A round that its plan limit cut, which --resume-on-reset is holding, shows as ⏸ with quota → <hh:mm>, the latest it wakes. It counts as live: it is listed with the running rounds, does not wake you when it starts waiting, and wakes you when it finally finishes, fails or is orphaned. A round that ended cut by the limit shows as ⛔ resets <hh:mm>, and its wake line reads "cut by the plan limit (429), resets hh:mm".
bin/statusline.sh puts the run registry, and the plan quotas from bin/quota.sh, into Claude Code's status line — the two lines at the top of this page. Add it to ~/.claude/settings.json:
"statusLine": { "type": "command", "command": "bash ~/.claude/skills/outsource/bin/statusline.sh" }
With a marketplace install the script lives in the versioned plugin cache folder (Install), so that path changes with each update.
Every budget is one token — NAME used%/until-it-resets. The percentage says how much is gone; the second half says how long until it comes back. Neither is actionable alone, which is why there is no bar here: a bar spends thirty columns on the first half and cannot render the second at all. Colour carries the alarm instead (green under 50, yellow under 80, red at 80+), and grok 98%/2h19m reads at a glance as nearly out, but not for long.
A render takes about 20 ms, because it never calls a quota API on the render path. Those calls take one to two seconds, so a lock-guarded background refresh writes a small cache every OUTSOURCE_STATUSLINE_TTL seconds (default 180), and a burst of renders makes one fetch.
Silence means exactly one thing: this backend is not set up here. Everything else has its own mark, so an absent segment is never ambiguous — a number not measured yet shows …, and a measurement that can no longer be refreshed is carried forward prefixed ~ rather than erased. Without that rule an expired grok sign-in once made the whole segment vanish, so a backend that had just stopped working looked exactly like one that was never configured. Nothing is ever silently rendered as 0%.
The rounds shown are this session's. The registry is machine-wide on purpose — an orphan has to be findable from wherever you are — but a status line reports on your window, and two Claude Code windows open on two repos would otherwise narrate each other's work as if it were yours. So the store stays global and the filter lives at the reading end: each launch records the session that owns it, and each status line asks only for its own. Ownership is matched on both the session id and the Claude Code process, so a round an in-process teammate launched still counts as yours. runs.sh unfiltered still shows the whole machine with an OWNER column, which is where you look when something is missing; OUTSOURCE_STATUSLINE_SCOPE=all puts that view back in the status line. Live rounds (running or orphaned) always show, prefixed ⇄ when another session owns them: a nested round once ran in the lead's own worktree, and a scoped line hid exactly the thing it exists to surface. Finished rounds stay scoped to yours, and an orphan ages off the one-line view after a day (OUTSOURCE_RUN_ORPHAN_LINE; one was measured squatting there for 9 days).
Set OUTSOURCE_STATUSLINE_PROVIDERS="" to drop the quota row entirely, or e.g. "zai" to keep one. No runtime dependencies: the tools are one static Go binary.
Before launch
bin/spec-lint.sh --root <repo> <scratch>/spec.md # 0 clean · 1 findings bin/outsource-run.sh --require-quota 15 … # 66 if the plan is too low bin/outsource-run.sh --resume-on-reset … # a 429 waits for the plan, then resumes the session (max 2)
Every zai launch also reads the plan quota (3 s budget) and prints one warning line when the tightest window has under 25 % left; it launches anyway. --require-quota is still the only refusal. With --resume-on-reset, --max-seconds bounds each attempt, not the launch: a launch runs up to three attempts, and the waits between them are not counted. The launcher says so in one line when both are given.
After the round — the model-identity assertion (exit 70), the done-marker check (exit 72 when a clean exit lacks the marker), the completion sentinel, and a cost line carrying the round's token counts from the log's usage. The total_cost_usd beside them is Anthropic-priced and wrong for every provider here. And bin/wait.sh <log> blocks until the sentinel lands — armed at launch and backgrounded, completion becomes a notification instead of a thing to poll.
Plan credits are deliberately not reported per round: a plan quota is a plan-wide counter that concurrent rounds and other sessions move too, so a before/after delta around one round measures the machine, not the round. Quota is a pre-flight signal — which provider this session should use, and whether to start at all.
$ bin/quota.sh
z.ai coding plan: level max — GLM Coding Max (status VALID, valid 2026-08-15~09-15)
5h window: 6692/28000 consumed, 21307 remaining, 23% used / 76.1% left, resets at 12:24 (in 3h 46m) <- tightest
1w window: 27758/140000 consumed, 112241 remaining, 19% used / 80.2% left, resets at 17:52 (in 153h 14m)
$ bin/quota.sh --provider grok
1w window: exact counts not exposed by this API, 98.0% used / 2.0% left, resets at 15:13 (in 6h 36m)
Several rounds on one machine each run their project's full build, tests and linters, and those steps compete for the same cores — measured 2026-10-06 on a 10-core Mac: about six rounds at once, load 23–28, every proof step crawling. outsource slot is a machine-wide counting semaphore those steps take turns on:
"$OUTSOURCE_SLOT" -- npm test # inside a round: the launcher exports the path bin/slot.sh --max 2 -- make check # by hand bin/slot.sh --status # every pool: holders (pid, label, age) and waiters
heavy unless --name <pool> says otherwise; its slots are lock files under ${XDG_CACHE_HOME:-~/.cache}/outsource/slots/<pool>/. A slot is held by flock, so a holder that dies — even by SIGKILL — frees it at once; there is no stale lock to clean up.--max N, else OUTSOURCE_SLOTS, else max(1, cores/4) — 2 on a 10-core machine. N belongs to the caller: a caller with N=1 only ever uses the pool's first slot, so callers that disagree about N never exceed their own budget.OUTSOURCE_SLOT (the skill's bin/slot.sh) and are named in the holder records by OUTSOURCE_RUN_LABEL (the round's --label); outsource-run exports both to every harness child.env, nice or command: it is never a heavy step, and the wrapper must not become a way around the git guard.A project's own runner. A project overlay may name a runner for heavy steps, and rounds on that project use it instead of $OUTSOURCE_SLOT. For example, a project whose test suite belongs on a build box rather than the laptop puts this in its overlay:
## Heavy steps Run every heavy proof step (full build, `just test`, `just lint`) as `tools/remote-run.sh -- <cmd>`: it syncs this worktree to the build box, runs the step there under that machine's own slot, and streams the output back with the step's exit code. Do not use `$OUTSOURCE_SLOT` in this repo; cheap steps (one test, `git diff`) still run locally.
The runner is the project's own script, so it can do what the slot cannot — move the work to another machine, or into that machine's queue — and the preamble's rule already defers to it.
Two layers, most specific last:
references/local-overlay.md next to the installed skill. Only what is true for you on every repo (default backend, model flags). Preserved by install.sh across upgrades, never shipped by this repo. When the install has none, install.sh seeds it from an untracked local-overlay*.md at the clone's root; an installed overlay always wins over that seed.In-repo — <repo>/.outsource/overlay.md, committed next to the code it describes. The default.
Declared — references/overlays/<name>.md in user scope, whose front matter lists the paths it applies to, the way .claude/rules/* declare theirs:
--- paths: - ~/repo/ds* # every clone - ~/repo/uf*/** # and the worktrees under them ---
Reach for declared when one repo has several checkouts on one machine — clones plus worktrees, each parked on a different branch. A committed overlay is then N copies drifting with N branches, and the lead who edits it in whichever checkout they are standing in silently forks the rules for everyone else. Measured on a repo with 16 checkouts: two overlays written months apart, neither aware of the other, with disagreeing gate tables.
outsource overlays --root <repo> prints what applies, in assembly order — user, then declared, then in-repo, so the committed file wins on conflict. --explain adds the kind and the pattern that matched, and a declaration whose paths could never match is named on stderr instead of quietly doing nothing.
Fourteen rounds, five real tickets from a Go + Svelte product, each ticket sent to every arm as the same task spec in its own git worktree.
All fourteen passed build / vet / the affected suite when the lead re-ran the gates itself. That is the finding that matters most: on ordinary work, the gates do not separate these models. Everything below lives outside the gates.
| Opus 5 | grok-4.6 | GLM-5.3 | |
|---|---|---|---|
| Wrong fact in the spec | catches it | catches it | catches it |
| Contract that cannot be satisfied | refuses, argues why, redesigns | notices, then implements it anyway | doesn't notice |
| Evidence it cannot obtain | names what's undecidable, flags a partial miss | — | produces a plausible-looking answer instead |
| Second-order effects | finds them unprompted | missed one the GLM arm caught | caught one grok missed |
| Reads images | yes | yes | no, at all (supports_attachments: false) |
| Self-verification / disclosure | unprompted | with the preamble | only with the preamble |
| Relative cost | highest | subscription | lowest |
Two of those cells decide the routing. The default GLM cannot see pixels, so anything that must look at an image goes to an arm with eyes — agy, glm-5.3-flash, or grok. No cheap arm reliably stops at an impossible contract, so that judgment stays with the lead — or with a Claude agent when the round is design-weight.
When glm-5.3-flash shipped and agy joined the pool, the same method ran again: three tasks × three models, nine rounds, byte-identical specs. A Go implementation against lead-authored tests seeded with adjacent-mutation traps; a mechanical %v→%w conversion seeded with six non-error %v traps; a codebase investigation answering five questions with file:line citations the lead then verified by hand.
All nine came back perfect on the objective gates. 3/3 test suites green, all 8 conversions with all 6 traps preserved and zero extra edits (three 16-line diffs, identical), 5/5 answers with citations that held. The gates, again, did not separate the models. What differed was speed:
| seconds per round | glm-5.3 | glm-5.3-flash | gemini-3.7-flash-high |
|---|---|---|---|
| Go implementation | 74 | 80 | 30 |
| mechanical conversion | 45 | 166 | 62 |
| investigation | 159 | 191 | 73 |
agy finished 2–3× fastest on two of three; flash was slower than 5.3 on every task — its value is the 3× plan quota and the eyes, not speed. The vision ladder came from separate probes: agy named a solid #1E50DC PNG's hex exactly; flash read it as #2244DD (~5% per channel); glm-5.3 failed a white-glyph shape probe outright. Precise-color and aesthetic verdicts stay with a frontier vision judge until the cheap arms are A/B-measured on verdict quality.
The first same-spec A/B with muse in the pool, and the first on a task where the objective gate does not saturate: write a Q3_K quantized gemv in Rust for NVIDIA's cuda-oxide (sm_86), with a C++ reference harness against ggml's mmvq on the same tensor, on the same RTX 3090. Byte-identical spec except path substitutions, isolated worktrees, both gates re-run by the lead. Full write-up in rig-log.
| glm-5.3 (effort high) | muse-spark-1.3 (effort high) | |
|---|---|---|
| wall time | 38 min | 20 min |
| accuracy gate (rel err ≤ 1e-4) | pass, 1e-6 | pass, 1e-7 |
| kernel bandwidth, stack M=1 (ggml 333 GB/s) | 62.7 GB/s (0.19×) | 134.4 GB/s (0.40×) |
| kernel bandwidth, stack M=8 (ggml 168 GB/s) | 8.6 (0.05×) | 32.7 (0.19×) |
| the one allowed optimisation pass | instruction-side only (51 → 66) | shared-memory x staging (60 → 140) |
| wrong premise in the spec (a ggml function name) | used the right one silently | reported the correction |
| toolchain defect met | none (#[unroll] on u32 loops worked) |
compiler ICE on #[unroll] with usize counters — reported, upstream candidate |
| diagnosis in the report | SASS read (ptxas -v), cause named |
pass-by-pass table, the step that mattered named |
| tokens spent (output incl. reasoning / model turns) | 357k / 224 | 79k + 45k reasoning / 76 |
Neither arm reached the 0.9× target in round 1 and both stopped after one pass as the spec said; in round 2 both cleared it, and the round-2 spec existed because the two round-1 diagnoses overlapped. The artifact went to muse, the diagnosis to GLM. Two rows change routing on their own: muse produced a 2.1–3.8× faster kernel in half the wall time, and it was the arm that said the spec was wrong.
Three more rounds followed on the same pair (below). Across four rounds and ten arms GLM spent 1.9–3.6× muse's tokens on every task (output + reasoning on both sides; output alone reads 3–6× because z.ai folds reasoning into it), and won three of the four adoption decisions where one arm was picked. Nothing in the series says which of those two facts should drive routing; the table exists so the next round does not have to guess.
max, and two new task classesRound 2, same two arms, same day — the spec was the lever both round-1 reports had pointed at (ggml's mmvq structure: q8_1 activations, dp4a, coalesced weight words), with the accuracy gate re-stated for that design. Both cleared it:
| round 2 | glm-5.3 | muse-spark-1.3 |
|---|---|---|
| wall time | 39 min | 34 min |
| stack M=1 vs ggml mmvq | 1.046× | 0.91× |
| stack M=8 | 0.83× | 0.78× |
| evidence tool | ptxas -v, incl. a reverted step (−35 %, regs 60→122) |
ncu instruction counts |
| structure | separate quantize kernel (runs once per token, reused by every expert) | quantize fused into each gemv block |
| adopted | yes (numbers and structure) | no |
| tokens spent (output incl. reasoning / model turns) | 443k / 172 | 137k + 93k reasoning / 94 |
Both arms ran at --effort high, but that label maps onto each vendor's own scale (z.ai folds reasoning into output tokens; muse reports it separately and its default is already high), so the label alone is not a controlled variable — the token and turn rows are, and GLM spent 3–4× the output tokens of muse in both rounds. Read the speed rows with that beside them.
Round 3, both arms at max, on the M=8 follow-up (gate: M=8 ≥ 0.9× and M=1 ≥ 1.0× in one run). The arms took orthogonal levers:
round 3 (max) |
glm-5.3 | muse-spark-1.3 |
|---|---|---|
| wall time | 20 min | 14 min |
| lever | 128-value q8_1 blocks: four dp4a share one scale, one FMA per column | bounds checks off on 73 device loads (get_unchecked + SAFETY), drow hoisted |
| stack M=1 | 1.14× | 1.57× |
| stack M=8 | 1.06× | 0.99× |
| tokens (output incl. reasoning / turns) | 257k / 125 | 57k + 33k reasoning / 70 |
| spec premise corrected | — | QR3_K is 4, not 2 |
| lead combined both | stack M=1 1.86×, M=8 1.20×, every shape above ggml |
Both arms used fewer tokens at max than at high in round 2, because the task was smaller and the gate closed early — so the label is not comparable across tasks either; only the token row is.
Round 4, two different task types, both arms at max — the series so far was one kernel refined three times, so the last round changed the task class twice: a CPU kernel (Rust AVX2 intrinsics, Q3_K×Q8_K gemv with pinned CCD-aware threads, against ik_llama.cpp's CPU backend on a 317 MB working set; gate ≥ 0.9× ggml at each engine's best thread count) and a compiler bug hunt (minimal reproducer for a cuda-oxide #[unroll] ICE, one-variable intervention table, locate the pass, duplicate search, English issue draft — no GitHub writes). Four arms, four worktrees, all gates re-run by the lead:
round 4 (max) |
glm-5.3 | muse-spark-1.3 |
|---|---|---|
| CPU gemv — wall time | 34 min | 18 min |
| big M=1 vs ggml, lead re-run | 1.11× | 1.11× |
| big M=8 | 0.87× | 0.57× |
| expert0 M=1 (small shape) | 0.91× | 0.12× (barrier noise at < 22 rows/thread) |
| 64 threads (SMT) on big M=1 | holds (−0.1 %) | −12 % |
| what the arm found | a scale-unpack bug in its own port, localized by diffing against ggml's dequant dump | a lever table: THP never engaged, 2× unroll −25 %, sw prefetch −10 % — all reverted with evidence |
| adopted | yes (kernel) | lever table folded into the notes |
| tokens (output incl. reasoning / turns) | 456k / 160 | 77k + 48k reasoning / 52 |
| ICE hunt — wall time | 16 min | 12 min |
| cause located | const_fold.rs:200 via unroll.rs:387 → SCCP |
same two frames, independently |
| reproducer | 1-trip loop, 14 variant files, partial unroll with a runtime trip count also ICEs | 8-trip loop with accumulator; i << 1u64 compiles, i << 1u32 ICEs — a bare 1 is i32 |
| spec premise corrected | for under #[unroll] is not E0658 (warns instead) |
same |
| lead re-verified | all 14 variants rebuilt, baseline re-ICEs after each | baseline + fix |
| adopted | yes (tree + draft), muse's 1u64/1u32 row added to the draft |
|
| tokens (output incl. reasoning / turns) | 129k / 150 | 34k + 13k reasoning / 88 |
Two arms on the same compiler bug converged on the same two source lines without seeing each other — that is what a root cause looks like when it is one. On the CPU kernel both cleared the gate at the same ratio, and the decision came from the rows the gate did not cover (M=8, SMT, small shapes): a gate that saturates on both arms is a gate, not a comparison.
The method is the point, because "which model is better" is not answerable without one.
git worktree, so nothing is confounded by phrasing or by arms colliding.A sync tick spent 19.4 s of 21.4 s re-reading 71 unchanged Confluence pages. The spec carried the reporter's hypothesis: "the watermark window never narrows on a quiet tick."
| Manipulation | Result | What it settles | |
|---|---|---|---|
| Opus 5 | removed the window slack (overlap 5min → 0) |
still 6/6 bodies re-read | the slack is not the cause — no constant can close this |
| grok-4.6 | pushed the watermark 1 h past every page, so the query matched nothing | 0 body fetches | an empty match is already free — "stalled floor → full backfill" is false |
Opposite manipulations, same refutation. The cause was neither: there was simply no decision between a search hit and the body fetch, and minute-granularity CQL re-matches the same cluster forever. Both arms then built the same shape of fix — one owner for "does this page need its body?" — instead of tuning a constant.
The asymmetry is why that line is in the spec at all: making a suspected cause false and watching the symptom stay refutes it. Watching a symptom disappear proves nothing, because it may only be masked.
(The 6/6 is the test fixture; the 71 pages is the production measurement.)
One ticket asked for two things at once: treat a file carrying name: gadak as ours and overwrite it, and keep protecting files the user authored. A user who customises our skill keeps that line — it is what makes the skill load — so the two clauses are jointly unsatisfiable.
name: gadak is treated as ours and overwritten" — and implemented it as specified anyway.Three of four arms shipped a data-loss bug with every gate green. That is the failure mode this skill now spends the most effort on: not a red gate, but a green one with a gap nobody named.
The same shape repeated on an auth ticket whose contract asked to distinguish three failure cases the available evidence cannot distinguish. All three arms reached that conclusion; only Opus said so, classifying the one case that is decidable and flagging the rest as a partial miss. The GLM arms concatenated every hint into every error — satisfying the letter of "show the user a string" while quietly failing its point.
| Ticket | output tokens, none ÷ full | input tokens, full → none |
|---|---|---|
| new CLI verb | 0.63× | 298k → 139k |
| sync perf | 0.78× | 146k → 112k |
| UI ordering | 0.84× | 107k → 95k |
| auth onboarding | 0.86× | 166k → 96k |
| CLI upgrade | 0.94× | 81k → 78k |
Cheaper in all five, fewer turns in four, never worse on a gate. On the sync bug the no-preamble arm even caught a second-order trap the grok arm missed (a page skipped by the new gate must still be reachable by the comments-only pass) and wrote the regression test for it.
But the cost was not where the preamble was earning its keep:
| full preamble | no preamble | |
|---|---|---|
| FAIL-first evidence | 5/5 | 5/5 |
| self-verification section | 5/5 | 0/5 |
| "what I could not do" | 5/5 | 1/5 |
FAIL-first survives without the preamble because the task spec demands it. What disappears is disclosure — which is exactly how the auth round came back looking complete when it wasn't.
Not established, and not claimed: which individual sections of the full preamble are dead weight. Only all-or-nothing was measured.
Every row is a mechanism with an exit code, not advice in a document.
| Weakness found | What now stops it |
|---|---|
| GLM cannot see images, but a spec might hand it a screenshot | Vision guard, exit 65 — driven by the model table's measured vision level, with the provider's answer for unmeasured ids as the fallback (the zai default is blind, glm-5.3-flash is not), never a provider-name test at the call site. --no-vision-check overrides. |
z.ai silently answers an unqualified claude-* request as its plan default |
Model-identity assertion, exit 70 — read from the per-turn message.model in the session transcript. Not from modelUsage, which was measured to echo the requested id and so can never prove a match. No transcript means "unverifiable", which also fails. |
| A cheap arm doesn't stop at an unsatisfiable contract | A lead checklist item, before launch. The delegate-side rule for this already existed in the preamble and did not fire, so it moved to the lead rather than becoming more prose. |
| Without the preamble, disclosure vanishes | references/spec-preamble-core.md — the short substitute carrying back exactly the half that vanished, and nothing else. |
| Specs carry wrong premises (five in one session — a nonexistent tool, a nonexistent column, an absent fixture, a wrong runner cwd, a wrong manifest path) | bin/spec-lint.sh, before launch: every path:line citation and path-shaped reference resolved, exit 1 on a miss. Bare filenames only when they carry a :line; anything resolving under any plausible base is not flagged, because a linter people ignore is worse than none. Brace sets expand; Create: and Absent-ok: (or a "do not touch:" list) declare paths that are not in the tree on purpose. |
| A negative premise ("this file does not exist") that a linter can't check | Lead checklist: verify absence one path at a time. A two-pattern ls in zsh printed nothing because the second glob matched nothing and aborted the command — so a file that exists went into a spec as absent. |
| grok blocked from producing its own required evidence | Per-subcommand git denies. A blanket git worktree* also blocked git worktree list, which every spec asks for as the first line of the report. |
| The plan runs dry mid-round | --require-quota N, exit 66 — keyed on the tightest window, not the shortest (measured: weekly at 81.7% remaining while the 5-hour sat at 83.8%). Fails closed. |
| A delegate reports "done" that isn't | Completion sentinel <log>.rc with rc, finished, harness, provider, model_requested, model_actual, session; on claude-code quota_exhausted (with reset_at, quota_reset_at, api_error when 1) and, under --resume-on-reset, resumed_after_reset. The harness's own lifecycle is not completion proof. |
| A clean exit without the spec's completion marker | --done-marker, exit 72 on both launchers: one code for one fact, distinct from model identity's 70. 72 names the missing marker; the tree is still the verdict. |
A confident report from a round that never made a tool call (measured 2026-09-29: "32 passed" over a 23-line transcript with zero tool_use blocks, no file written) |
Exit 73 on claude-code: after the harness exits, the launcher counts the transcript's tool_use blocks and records tool_calls=<N> in the sentinel. --allow-no-tools is for rounds that are answer-only on purpose; 72 keeps precedence. |
| Repository-state git from a delegate | bin/git-guard.sh, a PreToolUse hook parsing the real command string — git -C … commit, env … git push, sudo git …, chained mutations all blocked; read-only git deliberately open. One file, both harnesses' calling conventions. If no binary can be produced, the hook exits 2 (block), never a non-blocking error, so the git ban fails closed. |
| A delegate that runs the build its station owns (a machine where rounds write code and one station compiles and tests it) | OUTSOURCE_BUILD_GUARD: a command the claude-code launcher adds as a second Bash PreToolUse hook, after the git guard, in every round's shared settings. Unset (the default), a round has the git guard alone. |
z.ai silently answers a glm-5.2 request with glm-5.3 (measured twice — the response model field differs from the request, so it is not an echo) |
Refused at launch, exit 70. On crush there is no identity assertion, so the misassignment would otherwise stay silent forever; OUTSOURCE_ALLOW_MAPPED_MODEL=1 exists to re-measure, not to route. |
| A delegate reads the lead-side launch procedure that rode into its spec, decides it is the lead, and launches a nested round into the same worktree — clean exit, zero implementation | Nested launches refused, exit 64 — every harness child carries OUTSOURCE_ROUND=1 and both launchers refuse to start under it (OUTSOURCE_ALLOW_NESTED=1 for deliberate nesting). |
| agy exits 0 for a permission-denied round, and for a soft-denied write that produced no file | The launcher reads the final result event's status and fails anything that is not SUCCESS — agy's exit code is a lifecycle signal, never the verdict. |
A blind harness answers Read on a PNG with "uploaded to a CDN" plus a URL — which reads like success, so a delegate issued per-axis SHIP calls on captures it never saw |
The GLM preamble names the tell: a URL or an upload confirmation means the picture was not seen, and a confabulated verdict is worse than none — no verdict routes the question to a judge with eyes; a confident one ends the audit. |
A round cut by the plan's 5-hour limit (HTTP 429) read as a bare rc=1, and last-report printed the API error line as the report |
The sentinel says so: quota_exhausted=1, reset_at (the 429 text's reset, RFC3339 UTC or unknown), quota_reset_at (the plan quota API's, read at the death), api_error=429 […]. last-report exits 65 with no report: rate-limited (429) at 15:30, plan resets at 20:32 (plan); resume with --session <sid>. --resume-on-reset (claude-code) reads the plan every 5 minutes and resumes the same session as soon as the window reopens (1 % or more left in the tightest window), at most twice. The text's reset + 60 s is only the upper bound — measured: a 429 at 06:32:00Z said 08:23:45Z and the resumed session was answered at 06:33:39Z. |
grok-4.6, nine blind-judged rounds vs Opus 5 / Fable 5. Each round: implement a module and author its own verification gate in a Three.js/WebGPU project, judged blind with labels swapped.
| Exp | Task | Device added | Verdict | Measured |
|---|---|---|---|---|
| E1 | hit ripple + rim shader with a numeric gate | — (baseline) | lost 0:5 | assertions 14 vs 24 |
| E2 | debris burst + flash timing | — (replication) | lost | assertions 12 vs 32; 1.5× faster |
| E3 | 3-plane parallax cloud billboards | fairness + self visual verification | lost — didn't read as clouds | failure traced to the checklist |
| E5 | exposure flash + hitstop | contract↔assertion mapping table | won 2:0:1 | assertions 10 → 42 |
| E6 | near-miss graze sparks | reference-image injection (A/B) | injection rejected 4:0:1 | references help only same-effect |
| E7 | timeScale state machine + cel clock motif | quantified depth, self-review | split: visual won, logic lost | assertions 67 vs 95; 2.2× faster |
| E8 | camera FOV ladder | v2, vs Fable 5 | split | Fable caught a defect in our own spec |
| E9 | QTE hit windows + combo state machine | 4 logic design principles | lost; design credited | assertions 81; fastest run |
GLM-5.3, three shipped solo rounds and a same-spec A/B vs an Opus subagent. A CLI/MCP warning feature, a store-level schema-divergence repair with a FAIL-first test, and a docs-contract CI gate — each landed on main after lead review with no rework, and GLM corrected five wrong premises in the lead's own specs along the way. In the A/B (N=3) both arms independently chose the same shared utility and independently invented the same AST-based test workaround; the Opus arm won all three artifact picks, on second-order state interactions, evidence strength, and naming the failure modes a script's options handle. Each of those three became a spec rule here.
What closed the measured quality gap, each device with an effect behind it:
How the pieces fit, for readers who change or audit them.
internal/launch/wiring.go is the single owner of "what can run where", and it is three tables.
A provider is an account and an endpoint: base URL, default model, default harness, which environment variable may pin a model, the qualifier a CLI writes before the model id (empty means the provider's own name; zen's is opencode), what the vision guard answers for an id nobody measured, and the context-window fallback. A provider with a working Anthropic-compatible endpoint (zai, xai, openrouter) carries a URL, resolves its key through bin/credential.sh, and defaults to the claude-code harness — a test holds that rule, and a provider that defaults elsewhere must name its reason in the table. The others bring their own CLI and auth: zen's free tier answers only the opencode client (measured: FreeTierError from its /v1/messages), muse's endpoint answers an API key with billing_error, and agy is provider and harness in one.
A model row is what was measured about one id on one provider: its vision level (unmeasured, blind, shape, colour-family, exact-hex), whether the endpoint silently answers it with a different id (refused at launch), and a context window when it differs from the provider's. An id with no row falls back to the provider.
A harness is how a model is driven headlessly: the binary that must be on PATH, the providers it drives, where the round leaves a live trail, the dispatch, and the shape --model must take there.
Everything downstream derives from those three — the --harness validation, the --detach PATH lookup, the progress directory runs watches, the dispatch, the pairing refusal, the vision guard, the mapped-model refusal, and the --help line. Consistency tests refuse a half-wired row: a default harness that does not drive its own provider, a harness with no dispatch or no PATH binary, a --model form hint with no rule behind it, two providers on one harness sharing a qualifier, a model row for an unknown provider, a provider default with no model row.
outsource-run --list-wiring prints what the tables currently route:
PROVIDER HARNESS DEFAULT MODEL NOTES
zai claude-code glm-5.3 default harness; seeds from $GLM_DELEGATE_MODEL
zai crush glm-5.3 --model form zai/<id>; seeds from $GLM_DELEGATE_MODEL
xai claude-code grok-4.6 default harness
xai crush grok-4.6 --model form xai/<id>
openrouter claude-code (--model required) default harness
openrouter opencode (--model required) --model form openrouter/<id>
zen opencode step-5-preview-free default harness; --model form opencode/<id>
muse muse muse-spark-1.3-contributor default harness
agy agy gemini-3.8-flash-high default harness
MODELS (measured per id; ids not listed fall back to the provider)
PROVIDER MODEL VISION CONTEXT NOTES
zai glm-5.3 blind 1310720 default
zai glm-5.3-flash colour-family 1310720
zai glm-5.2 unmeasured 1310720 refused at launch: answered by glm-5.3
zai (other ids) guard refuses 1310720
xai grok-4.6 unmeasured - default
xai (other ids) guard passes -
openrouter (other ids) guard passes -
zen step-5-preview-free colour-family - default
zen (other ids) guard passes -
muse muse-spark-1.3-contributor colour-family - default
muse (other ids) guard passes -
agy gemini-3.8-flash-high unmeasured - default
agy (other ids) guard passes -
The refusal messages come from the same tables, so they say where the round should go rather than only where it cannot:
$ outsource-run --provider zen --harness claude-code …
harness claude-code does not drive provider zen — claude-code drives: zai xai openrouter;
provider zen runs on: opencode (OpenCode Zen's free tier refuses every client but opencode
(measured 2026-10-09: FreeTierError from /zen/v1/messages))
No binary is committed to git. bin/outsource is a small POSIX sh dispatcher, and bin/outsource.sha256 is a committed manifest: the release version plus the sha256 of each of the four release binaries (darwin-arm64, darwin-amd64, linux-amd64, linux-arm64). On first use the dispatcher gives this machine a binary. It tries these in order:
./build.sh in a clone, or install.sh with Go);~/.cache/outsource/<version>/);No switch skips that check. OUTSOURCE_RELEASE_URL only changes where the bytes come from (a mirror, an air-gapped server). Concurrent first calls share one fetch under a lock, and the cache keeps the current and the previous version. If no binary can be produced, bin/git-guard.sh exits 2 and so blocks git; a failed fetch never opens the guard. The bin/*.sh tool names need bash (on Alpine, apk add bash); bin/outsource <tool> needs only sh plus curl or wget.
You do not have to run bytes you did not build. With Go installed, ./build.sh builds the host binary beside the dispatcher, and that binary wins every lookup. install.sh with Go present also builds instead of fetching.
To check a release binary against the source:
CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -trimpath -buildvcs=false -ldflags="-s -w" \ -o /tmp/outsource-darwin-arm64 ./cmd/outsource shasum -a 256 /tmp/outsource-darwin-arm64 # must equal the outsource-darwin-arm64 line in bin/outsource.sha256
Set GOOS/GOARCH to the platform you want to check. Every flag there is load-bearing:
-trimpath keeps build paths out of the artifact.CGO_ENABLED=0 makes the binary static, so the host toolchain does not matter.-buildvcs=false stops Go stamping the commit hash and a +dirty marker into the module version. Without it the bytes would change on every commit.Three tools keep the manifest honest:
tests/reproducible-build.test.sh runs exactly this build for all four platforms and compares the results with the committed manifest. A source edit that skipped ./build.sh cannot ship.install.sh refuses when the manifest does not match a fresh build.scripts/release-assets.sh <X.Y.Z> builds the four binaries, checks them against the manifest and uploads them as release assets. It refuses unless the committed manifest already names those exact bytes.Go's linker ad-hoc signs darwin/arm64, and that signature is what lets a cross-compiled macOS build run at all.
Every tool call records one line: which tool, its exit code, how long it took, and which flag names were passed. Nothing leaves the machine — there is no endpoint, no upload and no identifier. OUTSOURCE_TELEMETRY=0 turns it off.
$ bin/outsource telemetry --since 7d
TOOL CALLS FAIL RATE p50 p95
outsource-run 31 4 13% 11m04s 1h22m
guard —(blocks only)
runs 210 0 0% 4ms 9ms
failures by kind
3 x guard exit 2 a delegate tried a git/gh command it is not allowed
2 x outsource-run exit 72 the round ran and its completion marker never appeared
1 x outsource-run exit 65 a spec that needs eyes was sent to a backend that has none
The point is the second table. Each of those exit codes names a way a launch was wrong rather than a way the provider failed, so a rate on one is a finding about how you are running rounds: 64s mean flags are being guessed, 65s mean vision work is going to a blind backend, 72s mean completion markers are not being written into specs, and the guard count says which delegates keep trying to do the lead's job.
What is never recorded: flag values, paths, spec text, stdin, environment, or any credential. Flag names are the signal; what they pointed at is not. The only values kept are three closed enums this repo defines — harness, provider, git profile. The guard records which kind of command was blocked, never the command. Two tests assert this, one of them by planting a codename in a path, a spec, a label and a marker and then failing if any of it appears in the file.
The file lives beside the run registry, is mode 0600, and rolls at 2MB keeping one generation.
| File | Purpose |
|---|---|
skills/outsource/SKILL.md |
The router: backend table, spec assembly, lead review checklist |
references/grok.md · glm.md · agy.md · muse.md · opencode.md · codex.md |
Per-backend operating manuals: flags, git-safety profiles, harness quirks, measured behavior |
references/spec-preamble.md |
Shared rules prepended to every spec — every clause from a real incident |
references/spec-preamble-core.md |
The short substitute: the disclosure half, measured to vanish without it |
references/glm-preamble.md |
GLM runtime delta (which model sees pixels and which does not, hooks not flags, evidence rules) |
references/spec-authoring.md · references/spec-template.md |
The quality bundle, and the per-task spec skeleton |
bin/outsource |
The dispatcher. One Go binary is every tool below; it is built or fetched on each machine and never committed (Verifying the binaries). The bin/*.sh names beside it are compatibility shims that exec into it, kept because docs, hooks, installed copies and tests call the tools by path. Hooks written by the launchers point at the resolved binary directly |
outsource-run |
The launcher: the provider/harness wiring tables, isolated config per track, session resume, vision/quota guards, model-identity assertion, completion sentinel, --resume-on-reset, --detach / non-TTY foreground refusal |
grok-run |
The grok launcher: same registry entry, sentinel and done-marker verdict, the git-profile flag strings it owns, a startup proof, --detach / --foreground |
guard · git-shim |
The git ban: the PreToolUse hook, one implementation for both harnesses (54 regression cases + a 670-verdict golden), and the git shim first on a muse round's PATH |
credential · setup-key.sh |
The single owner of key and host resolution, and its interactive half. setup-key.sh stays shell on purpose — its whole job is TTY interaction, and tests/shell-boundary.test.sh enforces that boundary |
verify-key |
Checks a key before it is stored; the key arrives on stdin, never in argv |
glm.sh |
The other direction: your own interactive Claude Code session on the z.ai plan, not a delegate round. Shell on purpose — it resolves the key, pins the model on all six variables an alias could route around, and execs the CLI. Worth an alias |
spec-lint · quota |
Pre-launch spec check; plan quota with --require-window as a gate |
overlays |
Which overlays apply to a repo, in assembly order; --explain says why |
runs |
The run registry: which rounds are alive, on what, for how long — and which started and never finished. runs stop ends one |
tail |
A round's live trail, one line per turn; -f follows it until the round ends |
audit |
What a round ran: the model behind each request, shell commands, files written, denials, and the trail's seal |
wait |
Blocks until a round's sentinel appears — armed at launch and backgrounded, a finished round becomes a notification instead of something you remember to poll |
slot |
A machine-wide counting semaphore rounds wrap their heavy proof steps in, so concurrent rounds take turns on the machine instead of all crawling at once; --status shows who holds and who waits |
last-report |
The round's final report out of either log shape, exit 65 when there is none |
statusline |
A Claude Code status line: session budgets, plan quotas, live rounds — about 20 ms per render |
telemetry |
A local record of tool calls, exit codes and reasons, and a summary of them. Local only, never uploaded, OUTSOURCE_TELEMETRY=0 to disable |
bin/codex-ci |
The Codex sidecar: runs the codex CLI against Cheaper Inference without writing to ~/.codex/config.toml |
mods/outsource-panel |
The panel: the /rounds pane, the band, the toasts, the lead wake and its two tools |
install.sh · build.sh |
Install or upgrade a copy of the skill; build the binaries and regenerate the manifest |
scripts/release-assets.sh |
Build the four release binaries, check them against the manifest, upload them |
scripts/grok-progress.py |
Compress a grok NDJSON stream into one-line progress events (lead-side; not installed) |
MIT
midagedev/outsource is a public repo on GitHub by midagedev. Your Claude session does the thinking; cheaper model subscriptions do the typing. A Claude Code skill and panel that run GLM-5.3, gemini-3.8-flash (agy), grok-4.6, Muse Code and any OpenRouter id as headless sub-agents — spec linting, quota gates, model-identity assertions, git-safety hooks, and the measured rounds every rule came from.
It declares the MIT license on GitHub.
Its maker tagged it for macOS, Windows and Linux, or as Docker or cross-platform. That is declared by the maker; Take My Repo has not tested it.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
Its last change on GitHub was on 2026-11-20. GitHub counts 1 open issue and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Reverse engineer anything with agents, from app behavior down to native binaries.

Manifold is a Java compiler plugin, its features include Metaprogramming, Properties, Extension Methods, Operator Overloading, Templates, a Preprocessor, and more.
f.k.a. Awesome ChatGPT Prompts. Share, discover, and collect prompts from the community. Free and open source — self-host for your organization with complete privacy.


Live, in-place screen translation for macOS — a lens that rewrites the text under it in your language, on-device.
Hybrid GPU + CPU inference for mixture-of-experts models, written in Rust down to the CUDA kernels. A drop-in llama-server.

Your Jira and Confluence, mirrored into one local SQLite file — macOS app, web UI, and agent SQL/MCP. Instant search, offline, one binary.

Claude Code mod: write and read in your own language while Claude works in English
당신의 캐시 히트율은? — CDN·캐싱·이미지/동영상 서빙 파이프라인 퀴즈. 모든 오답은 실제 오개념에서.

경복궁·여의도를 실제 지도 배치로 옮긴, 살아 움직이는 픽셀아트 미니어처. 뷰어·3D 장면(.blend/.glb)·프롬프트 공개 — A living pixel-art miniature of Seoul
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/midagedev/outsourceTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.