outsourcerer

Your frontier model is doing grep.

Outsourcerer routes each job to the best-value capable lane available, brings in a stronger model (or a whole panel of them) when it matters, and shows you the receipt.

---

You already pay for a fleet of AIs: Claude, Codex, Gemini, maybe Devin, a stack of OpenRouter credits. Each is brilliant at something the others aren't, and they sit in separate rooms. Outsourcerer makes them work as one team. It sends the boring work to the best-value capable lane available — plan-backed, keyless, free, local, or paid, pulls a top-tier model in when the job actually needs a big brain, keeps a running receipt of what that saved you, and, uniquely, clones your setup onto whichever engine runs the job.

It doesn't just call another model. It brings your whole workshop.

When Outsourcerer hands a job to a different engine or harness, that engine doesn't show up empty-handed. Grant a skill and the delegate gets the skill's whole bundle - SKILL.md plus its references, scripts, and assets - staged on disk next to the job on tool-capable harnesses, and synced into the harness's skills home on Devin. Text-only lanes can't run scripts, so they get the skill's complete documentation serialized into the prompt, with every script and asset explicitly listed as NOT TRANSFERRED - and a grant that can't fit or resolve refuses the dispatch instead of arriving half-loaded. MCP servers come along when you ask for them (--with mcp=), on the Claude lanes today; anywhere a grant can't make the trip, Outsourcerer says so up front instead of letting the delegate pretend. It's the difference between borrowing a stranger's bare laptop and having your own, fully set up, wherever the work happens to run.

---

The opportunity hiding in your subscriptions

You're already smart about this. Even inside Claude Code you hand the small stuff to Sonnet instead of Opus. Good instinct, Outsourcerer just takes it further than any single harness can:

• What if that same errand could run on an even cheaper engine, sometimes near-free on a subscription you already pay for, at quality that rivals your frontier model?
• What if a couple of stronger models could sanity-check your plan before you build, in parallel, without you leaving your session or wiring up a thing?

The models and the subscriptions are already on your machine. You could stand up a full multi-agent system to connect them, and sometimes that's exactly the right call. Outsourcerer is the lighter path for when you just want the work moved to the right engine and the savings counted.

---

You talk. The sorcerer handles it.

No flags to memorize, no routing tables. You say what you want; it checks what you actually have installed, picks the right engine, and offers you the cheap path before spending a cent it didn't have to.

If something isn't installed, it tells you the one command to fix it. You just say yes.

---

You decide how much you drive

The first time it wakes up in a session, Outsourcerer shows you what's ready, how much of your token budget is left, and asks one question: how do you want to drive?

• Auto-pilot. It takes the wheel. Picks the engine, offloads the grind, conserves your limits, and just tells you what it did. For when you want the work done, not the decisions.
• You-drive. Nothing moves without your say-so. It proposes, shows you the cost, and waits. For when the call is yours to own.
• Hybrid. You agree once on what it can handle alone (tests, repo-mapping, the mechanical stuff), and it asks about everything else. The sweet spot most people settle into.

Pick once and it remembers. Change your mind in plain language any time ("take the wheel", "ask me first"). And no mode is a trap: safety, cloud consent, and your sign-off on anything risky hold in all three. Beginners aren't dropped at a command line, they're handed a steering wheel and told what each pedal does.

---

It watches your fuel gauge, so you never hit empty

You know the feeling: 2pm, deep in a build, and your 5-hour limit taps out. Work stops.

Outsourcerer reads your live usage and, the moment you cross into the danger zone, quietly shifts the heavy lifting off your main model onto a cheaper lane that's still full, and tells you why it did. Your best model stays sharp for the judgment calls instead of getting spent on grep. The wall stops being a surprise you slam into and becomes a corner the sorcerer already saw coming. Different setup, same care: no Devin? It leans on Codex. Only local models? It keeps everything on your machine. It conserves with whatever you actually have.

---

It knows which model is actually worth it

You shouldn't have to memorize which model is best at what, or keep up with a leaderboard that shuffles every week. Ask Outsourcerer to pick, and it does the homework for you: it reads what the task really is (code? reasoning? a quick errand?), pulls live benchmark scores for every model you can reach, weighs quality against what each one actually costs you, and recommends the best value for this job, not just the most famous name.

That means a frontier-grade answer on a budget lane when the cheap model genuinely clears the bar, and a premium model only when the task truly earns it. It shows you the score and the reason it chose what it chose, so the pick is never a black box, and you can always overrule it. When it can't reach the live boards, it falls back to a built-in capability map, so the recommendation is never worse than a good default.

This is the same brain your copilot uses to choose. In auto-pilot it scores the models, takes the best value, and just proceeds (telling you which and why). In you-drive or hybrid it scores them the same way, then shows you the pick and waits for your nod. The benchmarks drive the choice in every mode; the mode only decides whether it asks first.

---

Advisors: bring the big brains in, several at once

Delegation runs both directions. Push work down to a cheaper model to save money, or pull the strongest models up as advisors to make the work better, and not just one:

• Convene a panel. Spin up several strong models in parallel, one from each subscription if you like (say Sol on Codex, Fable on Claude, Hy3 on OpenRouter), to review a plan or a diff at the same time.
• Act only on consensus. Outsourcerer greenlights the work when the panel agrees; a split isn't a coin flip, it's a signal to bring the decision back to you.
• Improve, don't just grade. Ask the advisors to rewrite the weak parts and fold in each other's fixes, not merely flag them.

A second, differently-wired head at the right moment is where the real leverage is. Three of them, agreeing, is even better.

---

One spell, tailored to each model

The models don't think alike, so Outsourcerer doesn't prompt them alike. The right prompting techniques are baked in per capability tier: it frames a task for GPT-5.6 one way, for Fable another, for a genuinely small model a third, each to its strengths. And cheap does not mean dumb: GLM-5.2, Hy3 and DeepSeek are capable tier, frontier capability at a budget price (~Opus-4.8 class), so they get the same high-autonomy prompting as the flagships, not a hand-holding work order. You ask in plain language; the sorcerer translates it into the dialect each engine actually responds to. You get better output from the cheap lane than you'd get by sending it the prompt you'd send Claude. Dial thinking depth per task with --effort.

---

What you can ask it to do

• Offload the grind. Repo mapping, mechanical refactors, running the test suite, big searches. Cheap model does it; your main agent stays the boss.
• Bring your setup along. Hand the job your skills (--with skills=x, or all) and the delegate works with the whole skill - docs, references, scripts - on tool-capable harnesses; text-only lanes get the complete docs with executables honestly marked NOT TRANSFERRED. MCP servers on request (--with mcp=), on the Claude lanes, verified present before launch.
• Convene advisors. Have several stronger models review a plan or a diff in parallel, improve it, and only proceed on consensus.
• Run agents in parallel. Fan out a whole multi-agent gauntlet (a QA sweep, a per-module review, N reviewers) across any backend at once with fanout, watch them live, and collect every finding into one file. No 16-session bootstrap tax.
• Generate images. GPT-image first on your Codex plan (keyless, no API credits), then nano-banana or an OpenRouter image model. (Every illustration in this README was rendered exactly this way, by Outsourcerer, keyless, $0 cash.)
• Review anything visual. Screenshots, UI, design, handed to Gemini, keyless on your Antigravity login.
• Run it on your own machine. A local model on Ollama or LM Studio runs the job on your hardware: $0, no tokens burned, fully private. (Its own section below.)
• Find the cheap seats. Ask what's free or cheap right now across your platforms (suggest). It reads each catalog live, so it keeps up as new models drop (a fresh free model on Devin or OpenRouter shows up on its own).
• See what you're saving. The Tab shows real spend vs your frontier model, per lane.

All of it in plain language. The commands underneath are the sorcerer's, not yours.

---

Loops: send the laps somewhere cheaper

Loops are not new. Claude Code has them and they work. What is expensive is who runs the laps.