Give your coding agent a second brain

The setup I run is a cheaper model doing the implementation. Give it a clear plan and it writes the code cleanly and fast, at a fraction of what a frontier model costs. I use Opus 4.8 for this and it's a genuinely good implementer. Where a model like that is weaker isn't the typing, it's the hard thinking: a subtle concurrency bug, a real fork between two designs, a "why is this actually happening" that wants a stronger reasoner than the one writing the code. The lazy fix is to run everything on a top tier model, but that's a bad trade. You'd pay frontier prices on every trivial edit just to have the deeper reasoning on hand for the few moments that need it. And telling a cheaper model to "think harder" in the prompt doesn't do anything, because it doesn't hand the model a better reasoner, just a longer leash. What I wanted was to keep the cheap, fast implementer and let it borrow a stronger brain for the hard question, then go straight back to writing code. That's all ask-fable (https://github.com/baggybin/ask-fable) is... How it works It's an MCP server. You point Claude Code (or any MCP client) at it, and your agent picks up an ask tool. When it hits something genuinely hard, it calls ask with the real code and the real error, and a strong model reasons about that. By default that's Anthropic's Fable, or Claude Opus 5 if you want cheaper and faster turns. The models never see your repo. You paste the relevant code into the call, or point at files with a context bus so you only send a big chunk once. The model on the other end is a pure reasoner with no tools and no filesystem. It thinks about what you handed it and answers. Nothing else. That much is already handy. It gets more interesting when one opinion isn't enough, which is where the other three modes come in. Four ways to ask ask is one model answering, with session memory so you can follow up. It's the one you'll reach for most. ask_council sends the same question to several models at once and has a synthesizer reconcile their answers into one, while still handing you each raw answer and a consensus signal. I use it for the calls I don't want to get wrong: a data model, a migration, anything hard to undo. One model sounding confident is not the same as several models agreeing. ask_chain runs an ordered pipeline instead. A cheap model drafts, the middle stages criticize and extend that draft, and a strong model makes the final call. The cheap model does the legwork and the expensive one only shows up to finish, which keeps the bill down. ask_debate is the adversarial one. Two models argue a claim through a structured ledger (propose, refute, revise) and a third rules on what's left standing. It's the heaviest mode, so I save it for real "approach X or approach Y" forks. Behind all of them is a mix of backends: Fable, Opus 5, MiniMax, Gemini, GPT, GLM, DeepSeek, Grok, Kimi, and gateways like Ollama, Atlas and OpenRouter, which alone reaches a few hundred models on one key. If a backend isn't configured or isn't reachable, it gets reported and skipped rather than failing the whole call. There's also a guard sitting in front that refuses off-scope requests (offensive-security work, non-software domains) so the thing stays a software-reasoning tool. The moment it earned its keep I'd just added a feature I called the twin flames. It's one token, twin, that expands to both Anthropic reasoners at once, Fable and Opus 5, so asking for ["twin"] runs both with no extra setup. Tests passed, I pushed it to a PR. Then I did the obvious thing and asked the twin flames to review the feature I'd built with them. They agreed with each other and pointed at a hole I'd walked right past. The group expands into its members before anything validates it, so a bad group definition never throws. It just quietly changes what gets asked. An empty group would fall through to the default panel. An unknown member would get reported under a name the user never typed. A nested group would never expand at all. Three different config mistakes, all of them failing silently, which is the worst way for anything to fail. I reproduced all three in about a minute, added a check that runs when the module loads, and pushed that too. The feature found its own bug. If you've ever wanted a second reader who's actually adversarial about your work instead of agreeable, that's the pitch. (For what it's worth, the underlying trap has a name: expansion that happens before validation can't fail loudly, it can only produce the wrong thing quietly. The fix is always to check the definition where it's written, not the expansion where it's used.) The rest of it The reasoning is the headline but the boring parts are what make it usable. Refusals are deterministic, so a rejected question rejects the same way every time instead of flaking. There's a context bus so you paste a big codebase snippet once and refer back to it by key. There's an answer cache and a circuit breaker that backs off a struggling backend. And every call lands in a redacted audit trail with full tracing, so you can go back and see which model said what, and what it cost you. Trying it pip install git+https://github.com/baggybin/ask-fable.git Then register it as an MCP server in Claude Code and hand ask your hardest question. Fair warning on where this is: it's an early public snapshot of something I built for my own daily use. Fresh repo, MIT licensed, no pretense of a big user base. It works, I use it. Repo, the full tool list, and a setup guide are here: github.com/baggybin/ask-fable. If your habit is already "let the cheap model grind and only escalate the hard question," this is that, turned into a tool your agent can reach for on its own.