If you looked at my AI engineering telemetry at the start of June 2026, the data told a singular, indisputable story: Anthropic’s Claude was my entire world.
In our internal engineering repository—Manthan, which serves as the shared brain and observability hub for all our AI workloads across Homeville Group and Bharat Housing Network (BHN)—Claude was logging 99 out of every 101 sessions. Over 98% of our compute, token consumption, and daily agent runs flowed through a single model family. Claude Sonnet was our default hammer for everything: drafting Architecture Decision Records (ADRs), refactoring co-lending microservices, parsing regulatory circulars, and troubleshooting CI/CD harnesses.
Fast forward to late August 2026, and the picture has inverted entirely.
In our latest daily telemetry runs, Claude accounts for less than 15% of active sessions. The bulk of our high-velocity software engineering, context synthesis, and background automation has migrated to Google’s Antigravity (powered by Gemini 3.1 Pro/Flash) and autonomous headless agents like LivAgent.
This was not an ideological shift. It was the natural, inevitable outcome of two converging architectural breakthroughs: the launch of Antigravity’s agentic orchestration engine and the establishment of a model-agnostic, Git-backed shared memory layer.
Here is the hard data from 308 production sessions and over 14 million tokens, why the shift happened, and what it reveals about the future of enterprise AI orchestration.
The Telemetry: 308 Sessions Under the Microscope
In our Manthan Observability infrastructure, every single agent session—whether interactive pair-programming or headless cron—is instrumented. We record wall-clock duration, input/output tokens, tool call latencies, error frequencies, and task outcomes.
Here is our cumulative telemetry breakdown across 308 production sessions:
| Agent / Engine | Total Sessions | Total Tokens | Avg Duration | Primary Operational Role |
|---|---|---|---|---|
| Claude (Sonnet / Opus) | 178 (57.8%) | 7,322,730 (51.8%) | 2,275s (~38 min) | Principal Architecture, Complex ADRs, CCB Governance |
| Antigravity (Gemini 3.1 Pro/Flash) | 71 (23.1%) | 2,967,400 (21.0%) | 1,342s (~22 min) | Interactive Coding, Fast Refactoring, Harness Automation |
| LivAgent (Headless Cron) | 55 (17.9%) | 3,848,500 (27.2%) | 7,116s (~118 min) | ERP Triage, Telemetry Aggregation, Background Syncs |
| Other / Specialized | 4 (1.3%) | — | — | Experimental harnesses & benchmark evaluations |
While the all-time cumulative numbers still show Claude in the lead due to our massive volume in Q1 and Q2, the trajectory over time tells the real story:
- June 4, 2026: Claude: 99 sessions | Antigravity: 2 sessions | LivAgent: 0 sessions (Claude = 98.0%)
- July 21, 2026: Claude: 11 sessions | Antigravity: 4 sessions | LivAgent: 0 sessions (Claude = 73.3%)
- August 14, 2026: Claude: 2 sessions | Antigravity: 0 sessions | LivAgent: 2 sessions (Claude = 50.0%)
- August 25, 2026: LivAgent: 5 sessions | Antigravity: 2 sessions | Claude: 1 session (Claude = 12.5%)
Across the entire ecosystem, our overall task success rate climbed to 98.95% (284 successes, 0 hard failures, 3 blocked on external dependencies). How did unbundling Claude across multiple models improve efficiency while driving down latency?
Catalyst 1: The Shared Brain Commoditized the Model
In The Git-Backed Brain and Deterministic AI, I explained why we rejected vector databases in favor of a centralized Git repository with Open Knowledge Format (OKF v0.2) frontmatter and Anthropic’s Model Context Protocol (Dnyankosh MCP).
What I did not fully appreciate at the time was the secondary effect of this decision: once institutional memory lives in Git, the LLM becomes interchangeable compute.
When you rely on an LLM’s conversational history or proprietary vendor memory silos, switching models incurs a massive context penalty. You stay with Claude not because it is the optimal tool for every sub-task, but because “Claude knows the project history.”
By enforcing our Interim Coding Agent Workspace & Memory Protocol (ADR-015), any agent entering our repository follows a strict 4-phase hydration cycle:
┌─────────────────────────────────────────────────────────────────────────┐
│ THE MODEL-AGNOSTIC MESH │
└────────────────────────────────────┬────────────────────────────────────┘
│
┌─────────────────────────┼─────────────────────────┐
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ CLAUDE │ │ ANTIGRAVITY │ │ LIVAGENT │
│ (Arch & Strategy│ │ (Interactive IDE│ │ (Headless Cron │
│ Reasoning) │ │ & Fast Code) │ │ & Telemetry) │
└────────┬────────┘ └────────┬────────┘ └────────┬────────┘
│ │ │
└─────────────────────────┼─────────────────────────┘
│ Standardized MCP & OKF
▼
┌─────────────────────────────────────────────────────────────────────┐
│ MANTHAN / DNYANKOSH REPOSITORY │
│ │
│ /decisions/ (ADRs: Immutable Architecture Constraints) │
│ /context/coding/ (Active tasks, coding standards, branch state) │
│ /observability/ (Session JSON telemetry, daily digests) │
└─────────────────────────────────────────────────────────────────────┘Because the agent hydrates its state from /context/status-dashboard.md, /context/coding/active-coding-tasks.md, and /decisions/, we can swap between Claude, Antigravity, or LivAgent mid-sprint without losing a single line of architectural context.
Catalyst 2: The Rise of Specialized Agent Topologies
Once models became interchangeable, we quickly realized that forcing one model to handle every tier of work is like asking your Chief Technology Architect to manually run nightly database backups and resolve Jira tickets. It is a severe misallocation of capability and latency.
Our workload naturally bifurcated into three distinct agent topologies:
1. Antigravity: The High-Velocity Pair Programmer
Google’s Antigravity (built on Gemini 3.1) entered our stack and immediately took over the interactive development loop. Why?
- Execution Latency: Antigravity sessions clock in at an average of 1,342 seconds (~22 minutes) compared to Claude’s 2,275 seconds (~38 minutes)—a 41% reduction in turn-around time.
- Tool Calling Velocity: Antigravity handles rapid-fire multi-file operations (
view_file,multi_replace_file_content,run_command) with near-instantaneous execution. - Huge Token Ingestion: Ingesting massive repo structures, ASTs, and test logs without running into strict token throttling allowed us to complete full refactorings in a single pass.
2. LivAgent: The Headless Background Daemon
For operations that don’t require interactive human feedback, we deployed LivAgent. LivAgent operates as an autonomous worker on long-running tasks:
- Running nightly ERP ticket triage across 80+ open support issues (fetching tickets, classifying categories, updating 200+ database fields, and posting executive digests to Microsoft Teams).
- Executing scheduled git synchronization harnesses (
sync_manthan.py) and calculating rolling daily/weekly metrics. - LivAgent accounts for over 3.84M tokens across 55 sessions, running marathon background tasks (averaging 7,116 seconds) without tying up human attention or burning high-cost frontier interactive quotas.
3. Claude: The Chief Architect & Deliberative Reasoner
Does this mean Claude is obsolete? Absolutely not. Instead, Claude has been promoted to our Principal Architect.
When we need to draft foundational architectural specs—such as ADR-016 defining our Three-Layer Appropriation Logic for co-lending collections, or evaluating the regulatory boundaries of Direct Assignment Phase 2 under RBI mandates—Claude remains unmatched in structural nuance, cautious reasoning, and adversarial edge-case analysis. We invoke Claude when the cost of ambiguity is existential.
Catalyst 3: Data Residency & Infrastructure Realities
There was also a pragmatic, regulatory driver behind our migration. As a regulated fintech platform processing over 600 loans a month (scaling to 1,500/month), data sovereignty is non-negotiable under India’s DPDPA 2023 and client bank SLAs.
As documented in our infrastructure evaluation (ADR-013):
- Running AI inference across international cloud regions created compliance friction with bank partners.
- With Gemini 3.1 becoming available natively within Indian GCP regions (and AWS India-hosted partner tiers), we gained the ability to run high-throughput document verification, income extraction, and codebase synthesis with India-only data residency guarantees.
Key Lessons for Engineering Leaders
If your team is currently locked into a single AI model or wrestling with ballooning API costs and developer latency, here are three principles from our transition:
1. Decouple Memory from Compute
Never let an AI vendor or proprietary platform become the sole custodian of your organizational memory. Store your decisions, system boundaries, active tasks, and glossaries in plain, version-controlled Markdown. Use open protocols like MCP so any agent can connect on demand.
2. Match the Model to the Execution Topology
Stop looking for the “one model to rule them all.” A mature AI engineering stack requires a portfolio:
- Deliberative Reasoners (Claude Opus/Sonnet): For high-governance ADRs, legal compliance, and architecture design.
- Agile Synthesizers (Antigravity / Gemini Pro): For high-cadence IDE interaction, refactoring, test execution, and harness development.
- Autonomous Daemons (LivAgent / Flash models): For scheduled maintenance, ticket enrichment, and telemetry pipelines.
3. Measure Everything with Deterministic Observability
You cannot optimize an agentic workflow by intuition. Instrument your tool calls, record token efficiency metrics, track session duration, and inspect error distributions. The moment we saw Antigravity completing coding sessions in half the time of our legacy setup with identical 100% test pass rates, the migration became an obvious engineering decision.
The Future is a Multi-Agent Mesh
The narrative in generative AI has long been dominated by the “Model Horse Race”—which lab has the top leaderboard score this week. But in production engineering, the frontier model is just a component in a larger orchestration harness.
By pairing Antigravity’s agile execution with Claude’s architectural precision, LivAgent’s tireless background automation, and Manthan’s deterministic Git-backed brain, we achieved something far more valuable than picking a single winner:
We built a resilient, multi-model AI mesh that moves as fast as we can think.