Gemini 4 Argon 对开发者开放了，但它的首发价格有个保质期

先看条款，再看跑分

三件事确定无疑：付费 API 层已全面可用；Google AI Ultra 订阅者可以在 Antigravity 里用到它；首发价是 $2 进、$10 出，11 月 30 日之后翻倍。

如果你正在规划一个跨季度的代码迁移项目，那 10 月的账单和 1 月的账单根本不是同一个形状。我把费率旁边写上日期——「我们是按首发价算的」这句话，是我见过最容易在一季度闯祸的一句话。

一个很朴素的例子：一个月的迁移工作，4000 万输入 token（仓库上下文，按文件批次重复发送）、400 万输出 token，首发价下是 120 美元，翻倍后是 240 美元。数字不大，但它是线性的，项目越长差得越多。

# The launch terms matter more than the benchmark chart, so start there.
# From the Google announcement dated October 13, 2026:
#
#   paid tier of the Gemini API       -> generally available
#   Google AI Ultra subscribers       -> available in the Antigravity agent IDE
#   list price at launch              -> $2.00 / 1M input, $10.00 / 1M output
#   that price is scheduled to double -> after November 30, 2026
#
# Two numbers, one deadline. If you are budgeting a long migration project,
# the January invoice is not the same shape as the October invoice.
# Write the date down next to the rate, because "we priced it at launch rates"
# is the sentence that gets people in trouble in Q1.

python3 - <<'PY'
launch_in, launch_out = 2.00, 10.00
later_in, later_out = launch_in * 2, launch_out * 2

def cost(mtok_in, mtok_out, rin, rout):
    return round(mtok_in * rin + mtok_out * rout, 2)

# A plausible month of code migration work:
# 40M input tokens (repo context, repeated per file batch)
# 4M output tokens (rewritten files, explanations)
for label, rin, rout in (("launch", launch_in, launch_out), ("after Nov 30", later_in, later_out)):
    print(f"{label:14s} ${cost(40, 4, rin, rout):>8,.2f}")
PY

# Output:
#   launch         $  120.00
#   after Nov 30   $  240.00
#
# Double the output tokens relative to input and the gap widens fast, because
# output is five times the price of input. That ratio is the whole story of
# how this model should be used.

真正的成本变量不是单价，是输入输出的比例

输出是输入的 5 倍价钱。这一条比单价本身重要得多，因为它决定了这个模型该用在什么形状的任务上。

同样是 5000 万 token 的处理量：读得多、答得少（10% 输出）大约 65 美元；读写均衡（30% 输出）大约 250 美元；写得比读得多（70% 输出）大约 825 美元。差 12 倍，而模型没换、价格没变。

所以我的用法很明确：Argon 放在输出小、判断难的地方——看 diff、做迁移规划、测试分诊、判断一段旧代码的真实依赖。不做批量代码生成，那个活交给便宜模型加编译器，两个维度都赢。

# Here is the part the pricing table hides: output is 5x input.
# $2.00 in, $10.00 out. Any workflow that generates more than it reads
# is paying for the expensive direction.

python3 - <<'PY'
rin, rout = 2.00, 10.00      # launch rates, USD per 1M tokens
ratio = rout / rin
print(f"output:input price ratio = {ratio:.1f}x")

# Compare two shapes of the same job at equal total token volume.
# Shape A: read a lot, answer briefly (classify, route, review a diff)
# Shape B: read little, generate a lot (write a whole module)
total_mtok = 50
for name, share_out in (("read-heavy (10% out)", 0.10), ("balanced (30% out)", 0.30),
                        ("write-heavy (70% out)", 0.70)):
    mout = total_mtok * share_out
    min_ = total_mtok - mout
    print(f"{name:22s} in={min_:.0f}M out={mout:.0f}M -> ${min_*rin + mout*rout:,.2f}")

# Same 50M tokens, 5.6x difference in bill. Model choice is only half the
# decision; the input/output mix is the other half, and you control it.
PY

# Practical rule: use Argon where the output is small and the judgement is hard.
# Diff review, migration planning, test triage. Not for bulk code generation,
# where a cheaper model plus a compiler will beat it on both axes.

百万上下文不是免费的自助餐

「上下文很长」这件事会被滥用。就算它能装下，把 80 万 token 的仓库上下文塞进对话，第 1 轮付了钱，第 2 到第 20 轮还在付。

算一下：80 万上下文的对话跑 12 轮，累加输入接近 1170 万 token，约 23 美元；如果第 1 轮之后压缩到 5 万，只需要 1.6 万 token 起，不到 1 美元。让人吃惊的从来不是第一次调用，是第十次。

压缩要保留什么，我有一条清单：目标 API 的契约（一页，逐字保留）、已经转完的文件清单和提交哈希、到目前为止撞过的失败模式（一行一个）。其他都能从仓库里重读，没必要花钱让它保持热气。

# The million-token context is the feature people will abuse. Context is not
# free even when it fits: every token you send on turn 1 is billed again if
# you keep it in the conversation for turns 2-20.

python3 - <<'PY'
rin = 2.00
ctx_mtok = 0.8          # 800K tokens of repo context, fits fine
turns = 12
growing = sum((ctx_mtok + 0.02 * t) for t in range(turns))
reset_once = ctx_mtok + sum((0.05 + 0.02 * t) for t in range(turns))

print(f"keep full context for {turns} turns : {growing:6.2f}M in  = ${growing*rin:8,.2f}")
print(f"compact to 50K after turn 1        : {reset_once:6.2f}M in  = ${reset_once*rin:8,.2f}")

# The number that surprises people is not the first call, it is the tenth.
# A 800K-token conversation replayed 12 times bills like 9.5M tokens.
# Compaction is not an optimisation, it is the difference between a project
# that fits its budget and one that gets shut off mid-migration.
PY

# What compaction should preserve for a migration job:
#   1. the target-API contract (one page, verbatim)
#   2. the list of files already converted, with commit hashes
#   3. the failure patterns hit so far, one line each
# Everything else is re-readable from the repo. Do not pay to keep it warm.

同样 5000 万 token，输入输出比例不同，账单能差 12 倍。

迁移项目真正烧钱的地方是没法复现

一千个文件的迁移，出问题的几乎从来不是模型价格，而是「哪批文件转过了、谁转的、能不能接着跑」。

我要求的是一个 manifest，每个文件记三件事：源文件哈希、状态、用的模型 id。续跑时只有源哈希仍然匹配才能跳过——这看起来反直觉，但改了文件就该失效重跑，不然你会在某个下午发现一个半迁移的文件被当成已完成。

两个性质必须在第一次付费之前具备：可重跑（中途被杀，重启不会重复付钱）和可审计（每个改过的文件都有哈希、模型和日期）。缺了这两个，便宜的模型不会更便宜，只是失败的方式不一样。

# The trap that actually costs money in migration work is not price, it is
# non-determinism across a thousand files. You need a manifest that proves
# what was converted by whom, and a way to resume without redoing it.

import json, hashlib, pathlib

MANIFEST = pathlib.Path(".migration/manifest.jsonl")

def fingerprint(path):
    return hashlib.sha256(pathlib.Path(path).read_bytes()).hexdigest()[:16]

def done_set():
    if not MANIFEST.exists():
        return set()
    seen = set()
    for line in MANIFEST.read_text().splitlines():
        if line.strip():
            rec = json.loads(line)
            if rec.get("status") == "ok":
                seen.add((rec["path"], rec["src_hash"]))
    return seen

def record(path, status, model, notes=""):
    rec = {"path": str(path), "src_hash": fingerprint(path), "status": status,
           "model": model, "notes": notes}
    MANIFEST.parent.mkdir(parents=True, exist_ok=True)
    with MANIFEST.open("a") as f:
        f.write(json.dumps(rec) + "\n")

# Resume logic: a file is skippable only if the source hash still matches.
# Editing a converted file invalidates its record on purpose, because a
# re-run must not silently accept a half-migrated file.
skip = done_set()
todo = [p for p in pathlib.Path("src").rglob("*.java")
        if (str(p), fingerprint(p)) not in skip]
print(f"skip={len(skip)} todo={len(todo)}")

# Two properties worth having before you spend anything:
#   - rerunnable: killed mid-run, restart costs nothing already paid for
#   - auditable: every converted file has a hash, a model id and a date
# Without these, a cheaper model is not cheaper. It just fails differently.

上线前这张清单比跑分有用

六件事。一，把截止日期换算成你自己时区的真实日期，别靠记忆。二，把确切的模型标识钉死在代码里，不要用会漂移的 latest 别名，并在每条结果旁边记下你实际调的是哪个 id。三，先证明你的输出 token 占比，那是最大的成本杠杆。四，设上限：单次输出上限、轮次上限、每日硬性支出上限——一个能循环的智能体也能在贵模型上循环。五，现在就定好降级模型和验收测试，等费率变化逼你切换时已经晚了。六，留账本。

还有一件事值得单独说：Google 把它定位成网络安全防御场景的前沿模型，并且提到 Argon 之前是通过 Fairwind 计划先给受限的防御方使用的。如果你的负载涉及安全分析，这一段值得读原文，因为访问路径和普通 API 用户不完全一样。

最后是我自己的判断。首发价是对早期采用者的补贴，不是长期价格。所以真正该问的问题不是「Argon 值不值 2 块钱一百万字」，而是「在 11 月 30 日之前，有哪一部分工作只有它能做，而那部分工作值多少」。答得出这个问题，就动手；答不出来，先用便宜模型把管道跑通。

#!/usr/bin/env bash
# Pre-flight for anyone about to move a real workload onto launch pricing.
# Run this before the first paid batch, not after the invoice.
set -uo pipefail

echo "== 1. what is the deadline in your timezone =="
# Nov 30 2026 pricing change. Use a real date command, not memory.
date -u -v+35d 2>/dev/null || date -u -d "+35 days" 2>/dev/null || echo "check the announcement date yourself"

echo "== 2. pin the model id, do not trust an alias =="
# An alias like a moving 'latest' tag can repoint under you mid-project.
# Record the exact identifier you called, next to every result row.
grep -R "gemini-4-argon" --include=*.py --include=*.ts . 2>/dev/null | head -5 || echo "nothing pinned yet"

echo "== 3. prove the output mix before you commit =="
# The single biggest cost lever is output token share. Log it per request.
echo "required log fields: model, input_tokens, output_tokens, cached_tokens, task_id"

echo "== 4. cap the blast radius =="
# Per-run spend ceiling. An agent that can loop can also loop on a premium model.
echo "set: max_output_tokens, max_turns, and a hard daily spend limit in the console"

echo "== 5. agree on the fallback model now =="
# Decide the cheaper model and the acceptance test BEFORE a rate change forces it.
echo "fallback model: ______   acceptance test: ______   owner: ______"

echo "== 6. keep the receipts =="
mkdir -p .migration/receipts
echo "ledger -> .migration/receipts/\$(date +%Y%m%d)-batch.jsonl"

迁移的成本不在模型，在没法复现：manifest、哈希、可续跑，缺一样都不算便宜。