A friend asked me an inconsequential question at work and I had an agent research my recent chats and docs and it found the right answer but it cost me $38!!!. That was a bad ROI. Sure my time is valuable, but I wouldn’t have actually spent that time and this task didn’t really need expensive planning capabilities.
We can do better.
Google Cloud's Gemini Enterprise Agent Platform offers Model Garden, with convenient API access to many top models including Google’s, Anthropic’s, and even xAIs. In fact every model on Huggingface is available to deploy on your own, but for this article we will focus on Anthropic’s new Claude Fable 5.1 and Google’s new Gemini 3.8 Flash. Developers now have two differently shaped frontier models sitting behind the exact same enterprise API surface.
Fable 5.1 brings Mythos-class autonomous planning, a 1-million-token context window, and deep multi-step diligence. Gemini 3.8 Flash brings near-frontier reasoning and incredible token velocity at Flash economics ($0.75 per million input tokens, $3.75 per million output tokens) with tunable thinking controls.
It might be easy to pick one and route everything through it. That is a mistake.
If you run routine developer churn through a deep planner, you are paying frontier token rates to parse git diffs. If you force a fast model to tackle an irreversible database migration without a formal plan, it will charge ahead and break state before you finish your coffee.
We can get vastly improved “tokenomics” very simply, by using 2 models and routing tasks.
By Alan Blount (@zeroasterisk)
Here is the full walkthrough to get you there:
- Configure both models behind a single unified governance plane.
- Benchmark routine tasks before picking a default.
- Use the fast model as your frontline coordinator and use the deep planner whenever you know you need more power or when the fast model needs to escalate.
- Form a mental model on Task ROI and the value (not just cost) of your tokens.
1. Configure both models behind a single unified governance plane
Picking your LLM inference platform requires consideration across many design choices. Cost, capacity, security, choice of model, serving features, developer friction, even more security (API keys are risky). Gemini Enterprise Agent Platform (formerly Vertex AI) is a comprehensive option with unique capabilities, and because it exposes both Gemini and Anthropic models as managed APIs, a single secure authentication covers both workloads.
But let’s be honest, some journeys have higher friction than I would like. I like to joke that “impossible things are easy, but easy things are hard.” That’s part of why I'm writing this post.
Before you deal with the models, login to gcloud, read the docs for variations.
To get access to Claude Fable 5.1, you need to enable the API and then enable Claude Fable 5.1 and fill out a very quick form about your use case. But you’re not done yet.
Now Fable falls under Google Cloud's Advanced AI Safety Addendum. Before you can send a single prompt to aiplatform.googleapis.com, you must explicitly configure prompt-response sharing and accept publisher terms at the project level.
Here are the exact working instructions for the global endpoint, read the docs for variations.
First let’s set up a few variables which will help us out. Note that the model name in the URL path is claude-fable-5-1 with hyphens, not dots, and make sure you enter your project ID and location, then possibly change your endpoint depending on your region:
Next call the setPublisherModelConfig API setting dataSharingEnabledProvider to ANTHROPIC - note that this is in all caps:
The initial call returns a completed operation object confirming that data sharing is active:
If you’ve already done this, you will get HTTP 409 error that this setting already exists:
This 409 is not a problem at all.
Test out your access to the model, and you should get a response:
If you did not do this correctly, you will get a HTTP 403 error which looks like this:
To get access to Gemini 3.8 Flash, make sure you see it as enabled the model card and it should just work:
… whew. We did it 🎉!
Need more quota? You can manage quotas for any model and pay for provisioned throughput for some models.
2. Don't Trust Benchmarks, Run Your Own
If you ask five engineers which model to use for an agent setup, you will get more than five conflicting opinions based on Twitter vibes and synthetic leaderboards.
Public benchmarks provide a fantastic resource, but they test isolated prompts or increasingly tasks in a vacuum. Production use cases, or your local agentic SDLC agents are never a perfect match to public benchmarks. Your work is shaped differently than any benchmark, today.
So you could build your own benchmarks (Agent Ops and Evals FTW!) and automate this at scale, or you can just do your own simple tasks side-by-side. As long as you don’t change the files in your task, you should be fine and with almost no effort you get a feeling for the tasks.
Here’s an example using promptfoo to drive opencode to do the same 2 tasks with each model. You’d want to change the task description and set up your environment for this to work, but it shouldn’t be too hard.
Configure Promptfoo to comparing opencode agentic task executions, not just single prompts and models.
Run your own side-by-side comparison using Promptfoo:
promptfoo eval -c promptfooconfig.yaml --no-cache
Here are my results from running this evaluation in a cleanroom dev container:
When checking a PR branch, Claude Fable 5.1 conducted multiple turns of meta-reflection, re-inspecting tree hashes that did not change. It took nearly 6 seconds and cost 23 times more. Gemini 3.8 Flash recognized the intent instantly, fired the git tools, and answered in 1.1 seconds for less than a tenth of a cent.
On the complex database migration, the picture flipped. Gemini 3.8 Flash produced a solid, clean linear sequence in 3 seconds. But Fable 5.1 spent 12 seconds generating a complete, formal directed acyclic graph (DAG). It identified clock skew risks in dual writes, generated idempotency key requirements, and defined a reversible rollback gate.
This is just one illustrative example, you should compare with your own tasks.
3. Practical usage in day to day usage and production
Whether you use off-the-shelf coding tools or build custom agent services, the winning pattern is asymmetric coordination: cheap speed for frontline execution, paired with deliberate depth for architectural checkpoints. Spend expensive tokens on tricky problems or planning work, but default to cheaper tokens for simpler tasks.
Coding Agent Harneses (OpenCode, Aider, etc)
Do not force one model to be your universal default. Configure specialized subagents mapped to distinct models. Using the same unified provider comes with security and cost benefits. Using different model families can benefit having them check each other.
Use the deep thinker agent to identify the root cause and plan a solution for this problem, and then use the worker agent to handle each of the tasks and report status. The deep planner checks their work and either confirms success or reassigns.
Custom Agents "as a Service" (Google ADK, LangGraph, custom code, etc)
When building your own agent harnesses and your own agent services, you have complete architectural freedom
- Reshape the harness for the model: Give Gemini 3.8 Flash 3 to 5 focused tools (read_file, write_file, run_tests) with strict JSON schemas. Fast models excel at focused execution, but a 50-tool catalog causes parameter confusion and context waste. Give Claude Fable 5.1 architecture docs, schemas, and guidelines, but strip away direct file write permissions.
- Ground in Evals: Do not guess which model fits which node. Run automated evaluation suites with deterministic assertion checks on your repo tasks to find where a smaller model delivers 95% quality at 10% cost. This is easy to say but hard to do, hard to know what scenarios you want to evaluate. Check out our Kaggle 5 day courses (agents, videcoding) for more.
- Use the "Ask for Help" Escalation Pattern: Start every incoming request on the fast worker. Give the worker an explicit tool: ask_for_help(reason, failed_attempts, context). The worker handles 85% to 90% of requests directly. It escalates only on ambiguity, irreversible actions, or two consecutive tool failures.
The Reality Check on Automated "Smart" Model Routers
Smart routers have a long history in predictive ML (ad tech, fraud detection). Multi-armed bandits and cost-quality routers are mature because features are tabular, inputs are bounded, and feedback (clicks, chargebacks) is both immediate and can be measured on a long time horizon.
In generative AI, multi-turn agents are a different story. Dynamic routers can struggle with three production realities:
- Single turn context may not contain enough signal about the task, to choose
- Success metrics are not clearly extrapolated to features, so the router cannot “learn” quickly
- False choices get re-run on the other path, eating into any potential savings and adding latency
The Verdict: Keep it boring. Compose your agents explicitly and route by task boundary. Define clear roles, and let concrete code assertions or human intent control handoffs.
4. The Token ROI Equation: What Are You Actually Paying For?
Raw pricing sheets ($/1M tokens) are not a good map of production value. Calculating costs is only part of the equation. It’s impossible to give you a calculation which is always going to work, across coding and product and manufacturing and every other job-to-be-done out there.
A starting point might be to think about the business value you are getting.
- The cost of human time saved, employees completing more work, and spending less time on toil and automated tasks.
- The value of shipping features to production faster, while improving customer satisfaction and retention because of those features.
- The errors mitigated and the production outages avoided due to improved safeguards and engineering practices.
Subtract the token cost, and the cost of upskilling your team to build and manage their agents and you have a rough ROI calculation.
You can influence these calculations by using fewer and cheaper tokens, but you will probably influence them the most by getting more work done, faster. Pick high leverage tasks. Pick tasks which result in saved overhead or increased revenue, which can be verified, and which are worth automating. And as you decompose those tasks, perhaps you want to think super deeply and plan and are willing to pay more and wait, or perhaps you want to execute fast and reliably. You’ll need both.
Tokenomics is a hot topic right now, and there are many more options to reduce costs and maximize value. The main point of this article is that it’s really simple to set up a few different agents on 2 models with different profiles and route tasks yourself. That’s the easiest place to start.
If you found this breakdown useful, check out our previous piece on 5 things every AI engineer should know about agent sandboxes. Follow @GoogleCloudTech and @zeroasterisk for more deep dives from the builder trenches.