When Antigravity Swaps Its Default Model, Only the Jobs You Narrowed First Survive

The split is decided by output freedom, not model quality

With the inventory done, the next question is which jobs to move onto the new default.

Most people reach for a benchmark table here. I did too, at first. But when I thought back to the times a model change actually cost me something, quality was never the issue.

Among the jobs I run as an indie developer, some survive a model swap untouched and some need hand-fixing every time. Wallpaper category classification is the first kind. The agent can only return one of thirty identifiers, and a downstream validator rejects anything else. Classification quality may drift a little; the shape of the output cannot.

Generating multilingual store release notes is the second kind. What comes back is prose. Change the model and the heading style shifts, the bullet granularity shifts. Nothing is broken — something merely different arrives. And when something different arrives, the formatting step downstream stops fitting.

So resilience to a model swap is not a property of using a good model. It is a property of how much of the output space you closed off in advance.

I wrote about closing off that space from the classification side in How Far to Narrow an Agent's Choices in a 30-Category Wallpaper Classification Pipeline. Back then the goal was accuracy. That the same decision bought immunity to default-model changes is something I only understood this week.

Scoring that freedom from the schema is steadier than eyeballing it.

#!/usr/bin/env python3
"""Score how much freedom an output contract leaves open.
 
More freedom means more breakage when the default model changes.
Breakage is not a function of model quality. It is a function of how
much of the output space you closed off in advance.
 
Score: 0 (fully closed) to 100 (fully free-form).
"""
import json
import pathlib
import sys
 
# Points added per unit of allowed freedom. Strings can be closed with an
# enum, so only unclosed strings are penalized.
WEIGHTS = {"open_string": 25, "open_array": 15, "no_schema": 100,
           "additional_props": 20, "optional_field": 5}
 
 
def score_schema(schema: dict):
    reasons = []
    points = 0
    props = schema.get("properties") or {}
    required = set(schema.get("required") or [])
 
    if schema.get("additionalProperties") is not False:
        points += WEIGHTS["additional_props"]
        reasons.append("additionalProperties is not closed")
 
    for name, spec in props.items():
        kind = spec.get("type")
        if kind == "string" and "enum" not in spec and "pattern" not in spec:
            points += WEIGHTS["open_string"]
            reasons.append(f"{name}: free string with no enum or pattern")
        elif kind == "array":
            item = spec.get("items") or {}
            if "enum" not in item and item.get("type") == "string":
                points += WEIGHTS["open_array"]
                reasons.append(f"{name}: array with unclosed items")
        if name not in required:
            points += WEIGHTS["optional_field"]
            reasons.append(f"{name}: not required (presence may vary)")
 
    return min(points, 100), reasons
 
 
def verdict(score: int) -> str:
    if score <= 20:
        return "move now (a swap shows up in validation)"
    if score <= 55:
        return "conditional (move it if a validator sits downstream)"
    return "hold (narrow the contract before moving)"
 
 
def main() -> int:
    worst = 0
    for path in sorted(pathlib.Path(sys.argv[1]).glob("*.json")):
        schema = json.loads(path.read_text(encoding="utf-8"))
        score, reasons = score_schema(schema)
        worst = max(worst, score)
        print(f"{path.name}  freedom {score:>3}/100  -> {verdict(score)}")
        for r in reasons:
            print(f"    - {r}")
    print(f"\nHighest freedom contract: {worst}/100")
    return 0
 
 
if __name__ == "__main__":
    sys.exit(main())

Scoring the classification schema next to the release-note schema:

category.json  freedom   5/100  -> move now (a swap shows up in validation)
    - confidence: not required (presence may vary)
release_note.json  freedom 100/100  -> hold (narrow the contract before moving)
    - additionalProperties is not closed
    - title: free string with no enum or pattern
    - title: not required (presence may vary)
    - body: free string with no enum or pattern
    - body: not required (presence may vary)
    - highlights: array with unclosed items
    - highlights: not required (presence may vary)
 
Highest freedom contract: 100/100

The absolute numbers mean nothing on their own — tune the weights to your own workload. What matters is the ordering. If you can hold the 100 and move the 5, the tool has done its job.

Do not read the 100 as a bad schema. Release notes are supposed to be prose. A correctly free job is correctly fragile under model changes. That is all it says.

You cannot verify a pin by re-reading your config

For the jobs marked hold, you pin the model. This is where I tripped.

You add the model name, you open the file again to confirm you added it, and you consider it handled. The flaw in that check is that you are confirming what you wrote, not what ran.

There is more than one invocation path: the IDE, the CLI, the SDK, and delegation through a subagent. Which layer wins can change between versions, and whether a subagent inherits the parent's selection depends on how you assembled it.

The reliable check is to look at what came out.

#!/usr/bin/env python3
"""Reconcile the model that actually ran against the one you declared.
 
A pin in configuration can still miss a path, because the IDE, CLI, SDK
and subagent routes resolve selection differently. Reading the config
again proves nothing; reading the run output does.
 
Key names in the usage object drift between versions, so this searches a
set of known candidates depth-first. Not finding one is itself a result.
"""
import json
import pathlib
import sys
 
MODEL_KEYS = ("model", "model_name", "model_version", "modelId")
 
 
def find_model(node, path="$"):
    if isinstance(node, dict):
        for key in MODEL_KEYS:
            value = node.get(key)
            if isinstance(value, str):
                return value, path + "." + key
        for key, value in node.items():
            found, where = find_model(value, path + "." + key)
            if found:
                return found, where
    elif isinstance(node, list):
        for i, value in enumerate(node):
            found, where = find_model(value, path + "[" + str(i) + "]")
            if found:
                return found, where
    return None, None
 
 
def main() -> int:
    expected = sys.argv[1]
    failures = 0
    for path in sorted(pathlib.Path(sys.argv[2]).glob("*.json")):
        payload = json.loads(path.read_text(encoding="utf-8"))
        actual, where = find_model(payload)
        if actual is None:
            print("? " + path.name + "  no model name in output (check this path)")
            failures += 1
        elif actual == expected:
            print("  " + path.name + "  " + actual + "  (" + where + ")")
        else:
            print("! " + path.name + "  expected " + expected + " / got " + actual + "  (" + where + ")")
            failures += 1
    print("\n" + str(failures) + " runs fall outside the pin")
    return 1 if failures else 0
 
 
if __name__ == "__main__":
    sys.exit(main())

Fed three runs saved with --output-format json:

  classify.json  gemini-3.7-flash  ($.model)
! release-note.json  expected gemini-3.7-flash / got gemini-3.5-flash  ($.meta.runtime.model_name)
? subagent-translate.json  no model name in output (check this path)
 
2 runs fall outside the pin

The third line is the interesting one. The subagent run carries subagent_info with a conversation_id and a log_uri, but no model name anywhere in the payload.

That is not a failure of the check. It is the check telling you where your visibility ends. Following log_uri may well answer it — and knowing that an extra hop is required is worth more than a green checkmark would have been. Had I treated "no model name found" as a pass, that whole path would have stayed invisible.

The multi-candidate key search exists for the same reason. Bet on a single key name and a version bump silently converts "key renamed" into "nothing wrong here." Absence always counts as a result.

One note for running this in production: put the reconciliation after your scheduled jobs, not before. Placed in front, it runs with no results on disk yet and stops on "no model name in output" every single time. I now sweep the day's JSON in one pass once the nightly jobs finish. Not exactly a trap, but it cost me a day of useless alerts before I moved it.

Freezing the output itself is a separate job, which I covered in Pin Your Agent's Output With Golden Snapshots Before Switching Models. This article is the step before that one: deciding what deserves a snapshot in the first place.

A promotional price is a bad reason to migrate

Now the cost question.

The Gemini 3.7 Flash introductory rate runs through December 31, 2026. The day after, input and output both double.

"Move while it's cheap" does not survive that table. If the destination doubles in under six months, a price-based migration loses its justification in January — and a migration whose justification evaporated is a migration you get to revisit.

Price is a legitimate input only when it is stable, or at least stable for longer than the horizon you are planning against. A promotional rate with a fixed end date is better read as a discount on evaluation than as a reason to commit.

That is how I used it. Even the jobs I decided to hold get run once against the new default during this window, with only the diffs reviewed. Observe without deciding. When the January price change arrives, the decision is made from evidence already sitting on disk.

I have been burned by the adjacent version of this before — assuming a model change would make things faster, and ending up at When a Fast Model Feels Slow, Look at Reasoning Effort Before Switching Models. There is often a cheaper variable to move before you touch the model name.

How the split actually landed

After the inventory and the scoring, my jobs fell into three buckets.

The second row surprised me. I had filed it under hold, on the logic that prose is fragile. But the reason to hold was never "this output is free-form" — it was "something downstream depends on its form." Output that a human reads and then discards can change shape without costing anyone anything.

The real axis turned out to be who absorbs the freedom. If a machine absorbs it, hold. If a person absorbs it, move. Once that came into focus, the sorting took minutes rather than an afternoon.

The third row ships to both the App Store and Google Play, and each locale has its own length limits and line-break conventions. As long as a machine performs that formatting, a shift in phrasing style breaks it. Hence the hold. The second row has identical output freedom and the opposite decision, purely because a person absorbs the variance.

Jobs that are free-form yet demand strict key structure downstream — localized string resources being the obvious case — land in the middle. Those need their contract narrowed before they can move, and narrowing is where the time actually goes. In that case I would recommend rewriting the contract before touching the model. Do it the other way around and you end up designing a contract while staring at broken output, which clouds the judgment you were trying to make.

What to do next

Run default_model_exposure.py at the root of your own repository once. Even the raw count changes what you are deciding about.

For a long time I read "default" as a synonym for "stable." It is closer to a synonym for "the place I never decided." Once you can count how many of those you have, the next time a default moves is a day you verify rather than a day you get surprised.

Pricing and availability figures here come from Introducing Gemini 3.7 Flash on the Google blog and the Gemini API model documentation. Versions and prices move, so confirm against primary sources before you act on them.