Put Claude Fable 5.1 and Gemini 3.8 Flash on the Same Coding Team

A developer at Google Cloud recently watched an autonomous coding agent burn $38 in frontier-model tokens to answer a question that a junior engineer could have resolved by reading one file. The task wasn't hard — it just wasn't worth the model doing the thinking. That anecdote, from Google Cloud engineer Alan Blount (@zeroasterisk) in a Google Cloud Tech post published September 14, 2026, frames a problem every team running coding agents in production eventually hits: one model, one price, every task is a bad default.

Blount's answer isn't a smarter model — it's two models with different shapes, configured behind one governance plane, and routed explicitly by task. This guide walks through his approach: getting Claude Fable 5.1 and Gemini 3.8 Flash both callable through Google Cloud's Gemini Enterprise Agent Platform (the rebrand of Vertex AI), benchmarking your own tasks instead of trusting a public leaderboard, and wiring an agent harness so a cheap model handles routine work while an expensive one only gets pulled in when the task actually calls for deep diligence.

TL;DR

The $38 question that should have cost a fraction of a cent

The anecdote that opens Blount's post is deliberately mundane: a research-style coding agent was asked something trivial — the kind of question a git log or a file read answers directly — and it routed the whole thing through a deep-planning frontier model. The agent didn't just answer the question; it planned, reflected, cross-checked, and burned tokens the way it would on an actual hard problem. The bill came to $38 for what should have been a near-zero-cost lookup.

That's not a story about the model being bad. It's a story about routing being absent. When every request — trivial or existential — goes through the same model at the same rate, you're either overpaying constantly (frontier tokens on parsing tasks) or underprotected occasionally (a fast, shallow model waved through an irreversible operation without enough scrutiny). Both failure modes come from the same root cause: treating "which model handles this" as a non-decision.

Google Cloud's Gemini Enterprise Agent Platform — the current name for what was Vertex AI's Model Garden — exists specifically to make that decision easy to act on. It gives one governance plane, one billing surface, and one API convention (aiplatform.googleapis.com) across Google's own models, Anthropic's Claude family, xAI's models, and any Hugging Face model you choose to self-deploy. The point of this guide is what to actually do with that: put a deep, expensive planner and a fast, cheap worker on the same team, and decide in advance which one answers which class of question.

Step 1: Configure both models behind one governance plane

Before any routing logic matters, both models need to be independently enabled and callable. Google's platform treats Anthropic models as a distinct publisher with its own data-sharing gate — this is the step most teams miss, and the one that produces a confusing 403 the first time they try Fable 5.1.

Authenticate once

gcloud auth application-default login

Enable Claude Fable 5.1 — accept the Advanced AI Safety Addendum first

Anthropic's publisher models on Google Cloud require accepting Google Cloud's Advanced AI Safety Addendum before a project can call them, and then explicitly enabling data sharing with the Anthropic provider via setPublisherModelConfig. Skip this and every call to aiplatform.googleapis.com's Anthropic publisher endpoint returns an HTTP 403.

export PROJECT_ID="your-gcp-project"
export LOCATION="global"
export MODEL="claude-fable-5-1"

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/anthropic/models/${MODEL}:setPublisherModelConfig" \
  -d '{
    "publisherModelConfig": {
      "dataSharingEnabledProvider": "ANTHROPIC"
    }
  }'

Two things worth knowing before you run this:

• A 409 "already exists" response is not an error. If the config was already set — by you, a teammate, or a prior run — the API returns 409, and the correct handling in any setup script is to treat that as success, not to retry or fail the run.
• A 403 after this call usually means the addendum wasn't accepted, or the config call targeted the wrong project/location pair. Data sharing is enabled per-project, so a script that provisions multiple projects needs to run this once per project, not once globally.

Once the config succeeds, verify access with a lightweight streaming call rather than a full request:

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/anthropic/models/${MODEL}:streamRawPredict" \
  -d '{
    "anthropic_version": "vertex-2023-10-16",
    "messages": [{"role": "user", "content": "ping"}],
    "max_tokens": 16
  }'

A clean streamed response confirms Fable 5.1 is live on the project. A 403 here after the config call succeeded almost always traces back to the addendum acceptance step, not the API call itself.

Enable Gemini 3.8 Flash — no data-sharing gate required

Gemini 3.8 Flash is a first-party Google model, so it skips the publisher data-sharing step entirely — just enable the model in the console or via API, then call it directly:

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "Content-Type: application/json" \
  "https://aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/gemini-3.8-flash:streamGenerateContent" \
  -d '{
    "contents": [{"role": "user", "parts": [{"text": "ping"}]}],
    "generationConfig": {
      "thinkingConfig": { "thinkingLevel": "low" }
    }
  }'

The thinkingConfig.thinkingLevel field is Gemini 3.8 Flash's tunable reasoning knob — a value like low keeps latency and cost minimal for routine tasks, while high lets the same model spend more compute reasoning through something less trivial without switching models at all. That tunability is part of why Flash is a credible frontline worker rather than just a discount option.

Step 2: Benchmark your own tasks, not a public leaderboard

Public leaderboards score isolated, single-prompt tasks under controlled conditions. Production agent tasks are multi-turn, tool-using, and shaped by your own codebase and conventions — none of which a leaderboard captures. The only benchmark worth trusting is one you run yourself, on the tasks you actually give your agents.

Blount's setup pairs opencode — an open agent harness — with promptfoo to run the same tasks against both models side by side and diff the results.

opencode.json — point the harness at both models

{
  "provider": {
    "vertex-anthropic": {
      "models": {
        "claude-fable-5-1": {
          "endpoint": "https://aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/global/publishers/anthropic/models/claude-fable-5-1"
        }
      }
    },
    "vertex-google": {
      "models": {
        "gemini-3.8-flash": {
          "endpoint": "https://aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/global/publishers/google/models/gemini-3.8-flash",
          "thinkingLevel": "medium"
        }
      }
    }
  }
}

promptfooconfig.yaml — the same two tasks, both models

providers:
  - id: vertex:claude-fable-5-1
  - id: vertex:gemini-3.8-flash

prompts:
  - "Summarize the current git branch status and outstanding changes."
  - "Design a zero-downtime migration plan moving a production table from Postgres to Spanner."

tests:
  - description: "Trivial parsing task"
    vars:
      task: git-status-summary
  - description: "Irreversible, high-complexity task"
    vars:
      task: db-migration-plan

outputPath: ./results/fable-vs-flash.json

What the side-by-side run showed

On the trivial git-status task, Fable 5.1 over-thought it — multiple redundant reflection turns before settling on an answer, taking roughly 6 seconds and costing about 23x more than Gemini 3.8 Flash, which answered in 1.1 seconds for under a tenth of a cent. There was no quality gap that justified the difference; the task simply didn't need a deep planner.

On the harder task — the zero-downtime Postgres-to-Spanner migration — the picture flipped. Gemini 3.8 Flash produced a clean linear plan in about 3 seconds. Fable 5.1 took roughly 12 seconds but returned a full formal DAG that identified clock-skew risk in dual writes, called out idempotency-key requirements for retried writes during the cutover window, and included a reversible rollback gate — a genuinely stronger answer for a task where getting it wrong means data loss or downtime, not just an extra editing pass.

That's the core finding: cost and speed differences that look damning on a trivial task can be exactly the right trade on a complex, irreversible one. The benchmark's job is to show you where that line sits for your workloads, not to declare one model universally better.

Step 3: Route explicitly — asymmetric coordination, not automatic smart routing

Once you know which task types favor which model, the harness pattern is straightforward: a fast, cheap model handles the frontline, and a deep, expensive model only gets invoked at specific checkpoints or escalations.

Pattern A — coding-agent-harness config

{
  "agents": {
    "worker": {
      "model": "vertex-google/gemini-3.8-flash",
      "thinkingLevel": "low",
      "tools": ["read_file", "grep", "run_tests", "git_status", "ask_for_help"]
    },
    "deep-thinker": {
      "model": "vertex-anthropic/claude-fable-5-1",
      "context": "1000000",
      "tools": ["read_file", "grep", "run_tests", "propose_migration_plan"],
      "restrictWrites": true
    }
  },
  "escalation": {
    "trigger": "worker.ask_for_help",
    "handoff": "deep-thinker"
  }
}

Pattern B — custom agent service, narrow toolsets by design

The same shape applies outside a harness, as plain service architecture:

• Give the fast worker (Gemini 3.8 Flash) a narrow toolset of 3-5 tools with strict schemas. It should be good at a small set of well-defined operations, not a generalist with broad file-system access.
• Give the deep model (Claude Fable 5.1) architecture docs and schemas, but restrict its direct file-write permissions. Its job is diligence and planning, not unsupervised execution — a human or a separate, permissioned agent should apply what it proposes.
• Add an explicit escalation tool — ask_for_help(reason, failed_attempts, context) — that the fast worker calls only on genuine ambiguity, an irreversible action, or repeated tool failures. In practice, this keeps the fast model handling roughly 85-90% of requests directly, with the deep model reserved for the minority of cases that actually need it.

Why not just build a smart router?

It's tempting to reach for a classifier that automatically decides which model gets each request — the way mature ad-tech and fraud-detection systems route in production. Blount's post pushes back on applying that pattern to multi-turn coding agents, for three reasons:

1. Single-turn context often lacks enough signal. A router deciding from one prompt doesn't see the multi-turn state an agent has already built up — the same request can be trivial or load-bearing depending on what came before it.
2. Success metrics don't map cleanly onto router-learnable features. Ad fraud has clean labels (fraud / not fraud) at scale. "Was this coding-agent response good enough" is fuzzier, slower to label, and harder to turn into training signal for a router.
3. A wrong routing choice gets re-run on the other path — eating into exactly the savings and latency the router was supposed to deliver. An automatic router that's wrong 15% of the time doesn't just produce 15% worse answers; it produces 15% of tasks that pay for both models.

The verdict: keep routing boring and explicit, composed by task boundary — worker handles routine work, deep-thinker handles checkpoints and escalations — rather than dynamically learned. This is the same instinct behind OpenRouter's model-routing cascades: explicit rules you can audit beat a black-box router you have to trust.

Step 4: Token ROI is not just $/1M tokens

A raw price comparison — Gemini 3.8 Flash's $0.75/M input and $3.75/M output against Fable 5.1's per-token rate — is not a complete cost model. It measures the input to the decision, not the output. The complete accounting weighs:

• Time saved and faster shipping against token spend
• Errors and outages avoided — the DB migration example above is the clearest case: Fable 5.1's extra 9 seconds and higher cost bought a plan that caught clock-skew and idempotency risks a shallower plan would have missed in production
• Team upskilling cost of running and maintaining two models instead of one, against the savings that pairing unlocks

A cheap model that ships a bug straight to production costs more than the tokens it saved. An expensive model that catches a migration risk before it happens can be a bargain even at more than 20x the per-token price on a routine task. The comparison only makes sense per task, not as a blanket "which model is cheaper" question — which is exactly why Step 2's own-task benchmarking matters more than any public leaderboard result.

The closing point is deliberately unglamorous: the simplest lever most teams are missing is not a fancier automated router. It's just configuring two or more models with genuinely different cost/capability profiles and routing tasks to them explicitly, by task boundary, based on your own numbers. Everything in this guide — the setPublisherModelConfig call, the promptfoo benchmark, the ask_for_help escalation tool — exists to make that one decision easy to act on, repeatedly, without re-litigating it on every request.

Related on explainx.ai

• What is an agent harness? The scaffolding layer that makes AI agents reliable
• From ReAct loop to production harness: DAG planning, tiered memory, budget pressure
• Claude Fable 5.1 and Mythos 5.1: benchmarks, pricing, and safeguards
• How enterprises use OpenRouter for model routing and cost optimization
• Context caching in agent harnesses: Google's numbers, and the ones it left out
• Google Cloud Next 2026: TPU 8t/8i, Gemini Enterprise Agent Platform, and the "agentic enterprise"
• $80,000 AI bill in one week: what Slash's Claude story teaches about token cost control

Further reading: Google Cloud Vertex AI — Anthropic Claude models · Google Cloud — Gemini thinking configuration · opencode · promptfoo

Model names, pricing, and API details reflect Claude Fable 5.1 and Gemini 3.8 Flash as described as of September 2026. Publisher-model enablement steps, endpoint paths, and pricing on Google Cloud's Gemini Enterprise Agent Platform can change — verify current values against Google Cloud's own documentation before wiring these calls into production.