Software engineering started rapidly shifting toward agentic development since last 10 months.
We started increasingly relying on large language models to write, refactor, and review our code.
However, the boardroom discussions surrounding these tools have recently shifted from capability benchmarks to budget concerns.
Large-scale token generation is wildly expensive.
Most people are still fighting over Claude vs Antigravity vs Codex.
But, we have always diversified things everywhere (from life to CLIs)
A recent project by developer Yuting highlighted a brilliant solution to this growing bottleneck.
He built a plugin that links Claude Code with Google’s Antigravity CLI.
Instead of treating these frontier models as mutually exclusive competitors, the plugin forces them to collaborate.
The Token Cost Snowball
As organizations roll out AI coding assistants to thousands of engineers, budgets are evaporating in mere months.
The structural problem is simple to understand but hard to bypass.
Token-billed agents cost more as they become more useful.
During prolonged coding sessions, agents re-read the entire context window with every single turn.
This context snowball means that the tenth prompt in a session costs significantly more than the first.
Generating more tokens does not necessarily yield better code, but it absolutely yields higher bills.
To maximize value, developers need to keep the context lean and push high-volume tasks to more cost-effective models.
The Conductor and Executor Model
The core concept behind this dev’s tool and case study is splitting the development agent into two distinct layers.
- The Conductor (Claude Code): Handles requirements gathering, system design, complex edge cases, and final code reviews.
- The Executor (Gemini): Takes care of boilerplate generation, initial test scaffolding, basic code implementation, and web searches.
By running this architecture, you reserve the expensive, high-reasoning tokens for the exact moments they are needed.
The implementation acts as a thin wrapper around the CLI.
A delegation sub-agent is restricted from writing files directly, forcing file generation to happen on the cheaper executor model.
Running this kind of setup inside a highly tuned WezTerm environment makes the entire agentic workflow feel seamless.
You get the speed of a local terminal workflow combined with the intelligence of cloud-based LLM routing.
Real-World Cost Reduction
The results speak for themselves.
I tested this hybrid architecture against a complex multi-agent build to see how the numbers stacked up against using a single premium model.
The hybrid approach reduced costs by up to 43 percent compared to running the most powerful model alone, all while maintaining the exact same output quality and passing identical evaluation gates.
Because the system required fewer turns to complete the objective, it drastically cut down on cached read tokens.
This scale-dependent optimization is exactly what teams need when managing massive infrastructure or tuning complex master data pipelines.
When building tools like GritGlean , optimizing data extraction and routing workflows is critical.
The exact same principle applies here.
You want to route heavy, deterministic tasks to the most efficient processor available.
Cost reduction is a massive benefit, but chaining two different models together unlocks architectural advantages that a single model cannot provide.
- Internal Data Grounding: You can leverage native search integrations to ground the executor on your own specific product requirements and standard operating procedures.
- Cross-Model Verification: Having a completely different model family review the generated diffs prevents single-model hallucination loops.
- Deep Research: The cheaper model can perform exhaustive web sweeps to gather context, while the premium model synthesizes and corroborates the claims.
I am glad I came across:
https://github.com/yuting0624/antigravity-for-claude-code
My small, isolated tasks are still best handled by a single prompt.
The overhead of delegating a tiny python script is not worth the round-trip latency.
But for substantial feature development, massive test generation, and deep architectural refactoring, hybrid delegation is the pragmatic path forward.
We have essentially solved pure text generation.
The next hurdle in agentic software development is verification and intelligent routing.
Forcing two distinct AI systems to cross-check each other while optimizing your token burn rate is exactly how modern development should look.
In case we are meeting for the first time, come over here, it’ll be worth the roller coaster of articles that are gonna come up in the next few weeks.