Routing Between Local Gemma and Cloud Gemini 3.5 Flash by How Easily You Can Verify the Output

Implementing the Router

Left to human intuition, the scoring does not reproduce. So I use a small router that derives the route from a task's attributes. Antigravity agents and scheduled runs pick their model through this one function.

from dataclasses import dataclass
from enum import Enum
 
 
class Route(Enum):
    LOCAL = "local"                     # Gemma via Ollama
    CLOUD = "cloud"                     # Gemini 3.5 Flash
    CLOUD_WITH_REVIEW = "cloud_review"  # cloud + human approval
 
 
@dataclass
class Task:
    kind: str
    auto_verifiable: bool   # decidable by types/tests/linters
    reversible: bool        # revertible at commit granularity
    blast_radius: str       # "local" | "repo" | "production"
 
 
def route(task: Task) -> Route:
    # Anything reaching production: safety over speed. Always gate on approval.
    if task.blast_radius == "production":
        return Route.CLOUD_WITH_REVIEW
 
    # Irreversible work cannot absorb a mistake. Put a human in the loop.
    if not task.reversible:
        return Route.CLOUD_WITH_REVIEW
 
    # Auto-verifiable, revertible, narrow. A failure is absorbed safely.
    if task.auto_verifiable and task.blast_radius == "local":
        return Route.LOCAL
 
    # Otherwise cloud, sized to how heavy the verification is.
    return Route.CLOUD
 
 
# Example
tasks = [
    Task("format_diff", auto_verifiable=True, reversible=True, blast_radius="local"),
    Task("release_note_translation", auto_verifiable=False, reversible=True, blast_radius="repo"),
    Task("admob_config_change", auto_verifiable=False, reversible=False, blast_radius="production"),
]
 
for t in tasks:
    print(f"{t.kind:28} -> {route(t).value}")

The output:

format_diff                  -> local
release_note_translation     -> cloud
admob_config_change          -> cloud_review

Formatting goes local, translation where meaning matters goes cloud, and a revenue-touching config change goes to cloud-with-approval. A decision I used to agonize over is now fixed by the task's attributes alone.

The branching is written flatly on purpose. This is a place I reread and tune by hand while operating. Rather than making it clever, I keep it readable top to bottom. When an agent edits it, an intent that shows up plainly in the diff is safer.

The ordering matters too. Blast radius and reversibility come first because they express irrecoverability. Verifiability shrinks the loss, but in front of an operation you cannot take back, how easy it is to verify becomes secondary. Reject the dangerous conditions first.

Confirming the Routing Was Right, From Measurements

The router is only a hypothesis. A task you judged "local is enough" can turn out to be full of corrections. So I always attach a ledger that measures the outcome afterward.

I record the route, the elapsed time, and most importantly the correction rate: the fraction of that route's output that a human or verifier later had to fix.

import json
import time
from pathlib import Path
 
LEDGER = Path.home() / ".antigravity" / "route_ledger.jsonl"
LEDGER.parent.mkdir(parents=True, exist_ok=True)
 
 
def run_with_ledger(task: Task, execute):
    chosen = route(task)
    started = time.monotonic()
    result = execute(chosen)   # the actual model call
    elapsed = time.monotonic() - started
 
    record = {
        "kind": task.kind,
        "route": chosen.value,
        "elapsed_s": round(elapsed, 2),
        "verified": result.get("verified"),   # passed the verifier
        "corrected": result.get("corrected"), # fixed afterward
        "ts": time.time(),
    }
    with LEDGER.open("a") as f:
        f.write(json.dumps(record, ensure_ascii=False) + "\n")
    return result

After running it for a week, the tendencies per route become visible. Here is one snapshot from my own setup. Treat it as a rough guide; it shifts a lot with model version and task nature.

These numbers drive threshold retuning. If the local correction rate creeps up over time, that is a signal the "absorbs failure safely" premise is starting to break. Either the auto-verification is leaking, or the model is quietly degrading. If a cloud task type shows a low enough correction rate, you can drop the approval and move it to the faster route.

Move thresholds from this ledger's trend, not from instinct. That is what keeps the routing a living part of operation rather than a one-time design.

Where It Quietly Breaks in Operation

This design fails quietly in a few places. Decide in advance where to watch.

First, the verifier going stale. You leaned local on the grounds that the task was "auto-verifiable," but if that verifier stays lax, mistakes slip through. That is exactly why I did not notice the broken diff until morning. Treat the verifier as seriously as the artifact. Revisit the mesh of tests and linters every time you add a route.

Second, the local model degrading silently. A change to quantization settings, a growing context length, a bloating prompt. Each shaves accuracy little by little, yet none surfaces as an error. Only a gradual rise in correction rate reveals it. A weekly glance at the ledger is your only early warning.

Third, misdeclared attributes. If you let the agent do the scoring too, it will sometimes optimistically declare "this is reversible." Reversibility and blast radius should be decided mechanically from observable facts, the repository state and the deploy target, not from the model's self-report. Not delegating the judgment to opinion is what holds this routing's reliability together.

A Step for Tomorrow

Start by writing down about five tasks you routinely hand to an agent and scoring them on the three axes above. Roughly half will likely land in "auto-verifiable, revertible, narrow." Moving just those to local Gemma noticeably eases both your cloud usage cap and the round-trip wait. By contrast, keep changes that ripple outward when they break — an AdMob revenue setting, an App Store submission flow — on cloud-with-approval without hesitation.

And always attach the ledger to what you moved. A single number, the correction rate, will tell you whether your routing was right far more honestly than instinct.

I went through a few quiet failures of my own before arriving at this design. If it spares you even a little of the same detour, I would be glad. Thank you for reading.