Finding signal on Twitter is more difficult than it used to be. We curate the best tweets on topics like AI, startups, and product development every weekday so you can focus on what matters.
for a few days, we had something that felt like AGI...
Fable 5 showed up, effectively unlimited inside the plans, and the ceiling on what you could build lifted overnight but then Anthropic killed it, maybe forever meanwhile, Opus 4.8, the model you're left with, feels lobotomized by comparison, like someone turned the intelligence down most people just accepted the downgrade and moved on they didn't have to you don't need Anthropic to switch Fable back on to get that level of intelligence again you can rebuild it yourself, out of cheaper models, and run it on demand the trick is a council: one frontier model coupled with a few cheaper or open ones, answering together it lands at Fable-level quality for a fraction of the price, and it beats any single model you're paying for right now, for a reason most people get backwards
the reframe: hire a team, don't rent a genius almost everyone uses ai like this right now:
a hard question comes up
you hand it to the single most expensive model you have access to
you read its one answer
you trust it, because what else would you check it against
one model gives you one opinion, with no second set of eyes on its blind spots the council is built to change that you send the same question to a panel of models at once, then a separate model reads every answer, notes where they agree, where they contradict each other, and what each one missed, and writes the single best version and that combined answer beats the best model in the room working alone
a two-model panel with a judge scored 69 out of 100 on openrouter's own published reasoning test, where Fable 5, the strongest single model in it, scored 65.3 a team of three cheap models, refereed, landed at 64.7, about a point under Fable 5 itself, at roughly half the cost per question the quality didn't come from buying a smarter model it came from one model carefully reviewing and combining the work of several cheaper ones checking the work matters more than adding workers, and that single fact is the whole reason a council costs less and answers better if you want to learn how to squeeze the most out of model councils, and how to turn them into real money, that's what the real time AI ops community is built for: weeklyaiops.com why a council is the right shape for orchestration, not just answers
it's easy to read the above as a nice trick for getting better answers it's bigger than that the bigger payoff is what a council does for orchestration, the act of running a long, multi-step job because orchestration is really a string of decisions what's the plan, what order, what's risky, what do we do when step four contradicts step two and good decisions have never come from one mind they come from several perspectives weighing pros and cons against each other until the strongest call survives that is exactly what a council is so when you put a council in charge of a big task, you get a better decision-maker steering everything downstream and that reframes how you spend your one frontier model don't waste it as just another voice on the panel... put it in the judge's seat let the cheap and open models do the parallel drafting, and spend your expensive model on the step that carries the quality: reading everything and making the call one frontier judge, a panel of cheaper models under it that's the build everyone should run one trap before the options: a router is not a council
the moment this gets popular, everything will get rebranded as “fusion,” so learn the line now the thing it gets confused with most is a router a router picks one model for you, usually the cheapest one that can handle the request, to save money an eval tool runs many models and grades them side by side neither one fuses anything you still walk away with one model's answer, or a scorecard a council is defined by the judge, the model that reads all the answers and writes a better one than any single member produced no synthesis step and no council, just a switchboard keep that test in your pocket, because some products marketed as fusion are routers with a fusion feature bolted on the side the options, and how you pay for them none of this has to be built from scratch the choice comes down to one question: use the subscriptions you already pay for, or pay per request ent it, per request: the fastest way to feel a council is openrouter fusion there's a browser page with three buttons, quality, budget, and custom, and the budget button is the half-price team
zero setup, paste a hard question, read the fused answer if you want to own the whole graph instead of a preset, orcarouter lets you define the panel and the judge yourself in a config file, with named strategies for how the judge decides
both bill you per call, which is clean if you don't want a stack of subscriptions use what you already pay for: if you live inside a coding agent and already pay for Claude, ChatGPT, and Gemini, gavel runs all three in parallel on the same task and has Claude fuse their answers, using your existing logins instead of new api keys only the main model touches your files, the others advise read-only, which keeps it safe to run on real code
run your own: the council as a tool you control end to end
openfusion, one command line tool that runs any backend (paid apis, local open models, your coding agent) under strategies like consensus (the panel has to agree), best-of-n (keep the single strongest answer), or first-to-finish (take whichever lands first), and can even expose the whole council as a single endpoint anything else can call
fusion-fable, the closest self-run cousin to openrouter's version, a blind panel of frontier models with a strong model judging and writing the final answer
llm-consortium, the most refined of the bunch, with a judge that keeps re-running the panel until the answers converge on a confidence threshold:
start with the browser page to feel it, then graduate to gavel or openfusion once you know you want it in your daily workflow when to convene the council
a council is slower and pricier per call than a single model, because you're waiting on a whole panel plus a synthesis pass a default fusion call can run several times the cost and the latency of one model answering once so this is not your everyday default, it's the tool you reach for when the decision is worth it the gut check: would i have paid for a premium model to answer this if yes, it's a council question, if no, use your cheap fast model and move on the places a council earns its cost:
codebase migration: this is the clearest case, and it also clears up a myth picture moving an old monolith over to microservices: dozens of judgment calls about order and risk land before a single line of code gets written a council that synthesizes prose is genuinely not the tool for writing that code, because there's no objective referee for what counts as the best code but migration is barely a coding problem in the first place, it's a decision problem: what's the order, what breaks, what's the risk, what's the rollback you convene the council to produce the migration plan and weigh the risks, then you hand the actual edits to a single cheaper agent to execute step by step the council decides, the lighter agent does deep research: say you're weighing a real decision, like which database to commit to or whether to move off a vendor, the panel each pull and read sources in parallel, the judge reconciles where they disagree, and disagreement is exactly where the real answer hides, so you get a checked answer instead of one model's confident guess orchestrating a long, complex job: something like reorganizing a sprawling project that grew without a plan, the council sets the plan and re-decides at each fork, a cheaper agent runs the steps in between setting goals for a lighter agent: use the council to turn a vague intention into a sharp, sequenced brief, then let a cheap fast model execute against it, you're spending the expensive thinking only where thinking happens building a knowledge base: say a tracker of every competitor in your market, the council decides the structure, what's an entity, what's a duplicate, how it all connects, and a lighter agent fills it in underneath, so the expensive judgment shapes the system and the cheap labor populates it the same shape runs under all five the council never does the grunt work, it makes the decisions, and a cheaper model carries them out the nuance that proves it's a pattern, not a product
the loud version of this online is that fusion is brilliant at research and useless at coding that's a competitor's launch line, not a measured result, so don't take it as fact the true and far more useful version is this: synthesizing prose is the wrong way to judge code, because writing a nice summary of three code answers doesn't tell you if the code runs so for code, you change the judge instead of fusing prose, the council keeps the candidate whose patch passes the tests same council, objective referee that's the real lesson, a council is a pattern you tune per task, which is why no single product gets to own it prose and research get a synthesizing judge code gets a judge that runs the tests you pick the referee that fits the job, and the same simple shape, panel plus judge, carries all of it the build, ready to run
stop renting one expensive model for every hard call, convene a council
the shape: a panel of models answers in parallel > one judge reads all of them > it writes the single best answer
the build most people should run: cheap and open models on the panel, your one frontier model in the judge's seat, because the judge is where the quality lives
the test: no synthesis step means it's just a router
rent it per request: openrouter fusion (browser, zero setup) or orcarouter (own the graph)
use your subscriptions: gavel (Claude + Codex + Gemini via your existing logins)
run your own: openfusion, fusion-fable, or llm-consortium
when to convene it: migrations, deep research, long multi-step jobs, briefing a lighter agent, building a knowledge base
the rule under all of it: the council decides, a cheaper agent executes
for code: the judge runs the tests instead of synthesizing prose
the close the choice in front of you isn't which model is smartest anymore it's whether you keep renting one genius for every question, limits draining, bill climbing or you hire a team for the decisions that carry real weight, and let a cheap fast model handle the rest one frontier judge, a panel of cheaper models, and a clear rule for when it's worth convening the people who win the next stretch of AI won't be the ones paying the most for the smartest single model, they'll be the ones who learned to convene the room the two build guides this runs on, the half-price council in your browser and the lightweight agent that executes underneath it, are both waiting in the community at weeklyaiops.com
How to build and scale a one-person business with AI:
