Using Claude Fable and GPT Sol Together for AI

The AI model wars produce a predictable side effect: everyone ends up picking a team. Anthropic partisans insist Claude is the only serious coding tool. OpenAI loyalists point to Codex and call it settled. What gets lost in the tribal noise is the more interesting question — what happens when you stop choosing and start combining?

That's the premise Chase, the YouTube creator behind the Chase AI channel, is working from in a recent video. With GPT Sol 5.6 arriving on the heels of Claude Fable, Chase argues that the "which model wins" framing is the wrong frame entirely. His proposed alternative is a structured, four-stage workflow that puts each model to work at the thing it's presumably best at, rather than asking either one to carry the full load.

The core idea is not new. Orchestrated multi-model pipelines have been discussed in AI development circles for a while, and the general logic — use a strong planning model to structure the work, then hand execution to whatever completes it fastest and cheapest — tracks with how serious engineering shops already think about cost optimization. What Chase is doing is packaging that logic into a reusable skill set that solo developers and small agencies can actually deploy without building the orchestration layer from scratch.

The Four Stages

The workflow Chase describes runs like this.

First comes what he calls the interview stage, driven entirely by Fable. This is built on Matt Pocock's "Grill Me" prompt framework — a structured interrogation process that extracts far more project detail than Claude Code's standard plan mode. Pocock, who creates developer-focused content at @mattpocockuk, designed it to surface decisions a developer might otherwise defer until they become problems mid-build. Chase describes it as "plan mode on steroids" — eight to ten layered questions about architecture, tooling, user context, and edge cases before a single line of code gets written.

Second is adversarial planning. Once Fable has produced an initial plan, that plan gets passed to Codex — which, as of Sol 5.6's release, routes through OpenAI's latest model. The two models exchange critiques and revisions until they reach consensus, with the exchange logged to a markdown file the developer can audit. In Chase's demo, the back-and-forth resolved in two rounds, surfacing refinements around identity persistence and what he describes as "hardening the data core."

Third, execution shifts entirely to Codex. This is where Chase's argument about token efficiency matters most. Fable — Claude's most capable model — is expensive to run at scale. Using it for everything, including the parts where a cheaper model would perform comparably, is wasteful. Chase's position is that GPT Sol, priced more aggressively than Anthropic's top-tier models, handles execution without giving up meaningful output quality. The GPT-5.5 pricing picture has already been complicated enough; Sol 5.6 is Chase's bet that the efficiency curve continues in the same direction.

Fourth, Fable returns for a review pass. After Codex completes the build, Fable audits the output, flags deviations, and requests corrections. If Codex can't resolve the issues after a couple of passes, Fable writes the corrections itself. This closing loop is the quality control mechanism — the assumption being that Fable's judgment about what constitutes correct output is more reliable than its ability to produce that output cheaply.

What the Demo Shows

Chase builds a trip planning web app called Trip Atlas to demonstrate the workflow. The result — a cinematic, map-based itinerary builder with animated route replay, passport stamp graphics generated via GPT's image tools, and dynamic distance calculations as stops are added — works. Not perfectly, and Chase acknowledges there's room to refine the look, but the functional requirements he specified at the start are met.

"In general, it built what we said we wanted to, right? Like everything actually works here," Chase says. That's a lower bar than it sounds — plenty of AI-generated builds fall apart under basic interaction — but it's a real one.

More telling than the output is what he reports about the cost. Chase notes that Fable's portion of the work consumed a relatively modest token count for a project of that scope. He's attributing this directly to the division of labor: Fable handled the thinking, Codex handled the doing.

The Honest Caveats

Chase is careful to flag that Sol 5.6's benchmark numbers come from OpenAI — "grain of salt," he says explicitly — and that the real-world coding performance may not match what the evaluations suggest. This is worth taking seriously. OpenAI's own benchmark presentations have a history of selecting metrics favorably, and independent evaluations of the same models have produced different conclusions depending on the task distribution. The broader pattern of model releases making strong benchmark claims that don't fully survive contact with real workloads has been consistent enough to treat as a prior.

None of which necessarily undercuts Chase's workflow. If Sol 5.6 underperforms its benchmarks but still executes code more cheaply than Anthropic's mid-tier models for equivalent tasks, the token efficiency argument holds regardless of where exactly it lands on any particular leaderboard. The workflow's value isn't predicated on Sol 5.6 being the best model — it's predicated on it being good enough at execution while being priced lower than Fable. Those are separable claims.

The adversarial planning stage raises its own questions. The idea of having two models debate a specification until they converge sounds rigorous. In practice, it depends heavily on what "consensus" means when you're prompting two large language models to negotiate. Whether they're genuinely stress-testing each other's assumptions or pattern-matching toward agreement is something a markdown log of the exchange can't fully answer. Chase's demo shows the process producing substantive-looking findings. Whether those findings would have materialized from a single thorough Fable planning session is harder to say without a controlled comparison.

The Broader Pattern

What Chase is really describing is a staffing model applied to language models: one senior strategist who's expensive and good at ambiguous problems, one capable executor who's cheaper and reliable on well-defined tasks. This is how engineering teams actually work, and it's not a coincidence that the AI tooling space is converging on the same structure.

The emergence of tools like this also signals something about where the practical ceiling of single-model workflows sits. If Claude Fable could handle everything at a cost that didn't compound painfully over a long project, there would be no market for this kind of orchestration. The fact that there clearly is suggests that the cost structure of frontier models remains a real constraint, not just a footnote.

"Unless you just are super anti-GPT and anti-Codex, it's hard to argue otherwise," Chase says of the combined approach. That's a fair summary of the logic, with one caveat the video doesn't fully address: the complexity cost of maintaining a multi-model workflow is real. Two APIs, two failure modes, two billing surfaces, and an orchestration layer that needs to be kept current as both models evolve. For a solo developer or a small shop, that overhead may be worth it. For others, the cleaner single-model path has value that doesn't show up in token counts.

The Grill Me Codex skill is available on Chase's GitHub repository. How much of its value comes from the multi-model architecture versus simply the more disciplined planning process that Pocock's framework imposes — that question is worth sitting with before attributing the results to either model in particular.

Bob Reynolds is Senior Technology Correspondent at Buzzrag.