Your frontier model is doing grep.
Outsourcerer hands the grunt work to the cheapest engine you already pay for, brings in a stronger one (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 cheapest engine that can nail it, 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. It carries your setup with it: the same skills, the same plugins, the same MCP servers your main agent uses. A cheap model running on Devin can use your custom skill and reach your MCP tools exactly the way your Claude session would. 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, plugins, and MCP servers so the delegate works with your tools, not a bare model, even on another harness.
- 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, `