Gemini 4 Argon Doubles December 1: Quote for It
Gemini 4 Argon's $2/$10 rate doubles on December 1, 2026. How to price an iOS AI feature and keep the model swappable behind one seam.
Google didn’t bury the increase. Its own pricing page lists two dated prices for gemini-4-argon side by side, and the second one is twice the first. If you are writing a fixed-price quote for an AI feature this month, that table is the most important document in the project.
What Google published, and what it means for a budget
As of October 26, 2026, ai.google.dev/gemini-api/docs/pricing lists gemini-4-argon at $2.00 per million input tokens, $10.00 per million output, $0.10 per million cached input — through November 30, 2026. From December 1, 2026: $4.00, $20.00, $0.20. The page never uses the word “introductory.” It states a dated price and a scheduled change.
There is no free tier for this model. It opened to paid-tier developers in mid-October 2026 (“Gemini 4 Argon is now available for developers”); the September 30, 2026 launch post had it restricted to a set of trusted cyber defenders under the Fairwind Program. So there is no prototype-on-the-free-tier phase here. Every spike is billable from day one.
The cost-relevant spec isn’t the benchmark sheet, it’s the shape of the context window. Argon has a unified 1M-token window shared across input, thinking and output, where Gemini 3 and 2.5 kept separate input and output budgets, and the output ceiling rose from 64K to 1M tokens. Output is priced at five times input, and Google labels that row “Output price (including thinking tokens).” The structural protection against a runaway generation is gone, on the most expensive term in the bill.
A scheduled increase is published, not predicted — and still not certain
Two things are true at once, and a post that picks one is wrong half the time.
The increase is real and documented. Google is re-pricing upward as a pattern, not a one-off: the same pricing page shows time-limited lower rates on other Gemini models ending December 31, 2026, with increases on January 1, 2027 — Gemini 3.8 Flash goes from $0.75/$3.75 to $1.50/$7.50, for example.
But vendors do cancel these. Footnote 3 on Anthropic’s pricing page, verbatim: “The $2/$10 per million input/output token pricing for Claude Sonnet 5, announced at launch as introductory pricing through August 31, 2026, is now the standard price. The previously scheduled increase to $3/$15 per million input/output tokens on September 1, 2026 will not occur.”
So quote the published post-increase number and architect so neither outcome is a crisis. A reprieve is upside you hand back; a doubling you didn’t quote for comes out of your margin.
For context on where $4/$20 lands: as of October 26, 2026 that is twice gpt-6-sol ($2/$10 standard tier) and twice Claude Sonnet 5.5 ($2/$10), and level with Claude Opus 5.5 ($4/$20). The rate that makes Argon look cheap today is, elsewhere, the standing price. And don’t budget off third-party price trackers — one aggregator currently shows Google-direct endpoints at $3.60/$18, which matches Google’s Priority tier and looks like a tier mislabel rather than a real rate.
The seam is now a platform protocol
“Keep the model behind one interface” used to be a pattern you hand-rolled. In iOS 27 (GA reported as September 14, 2026; Swift 6.4 shipped September 15, 2026, with 6.4.1 current) it’s a protocol. Apple’s WWDC26 iOS guide: “You can now work with any language model, including Apple Foundation Models, cloud models like Claude and Gemini, or any other provider that conforms to the Language Model protocol.”
That makes the call site genuinely uniform. The response schema is a @Generable type in your target, the instructions are a constant in your target, and the vendor appears exactly once.
import FoundationModels
@Generable
struct ExpenseDraft {
@Guide(description: "Merchant name as printed on the receipt") var merchant: String
@Guide(description: "Total in minor units, e.g. cents") var totalMinorUnits: Int
@Guide(description: "ISO 4217 currency code") var currency: String
}
struct DraftingService {
let makeCloudModel: () -> any LanguageModel // the only place a vendor is named
func draft(from text: String, useCloud: Bool) async throws -> ExpenseDraft {
let model: any LanguageModel = useCloud ? makeCloudModel() : SystemLanguageModel.default
let session = LanguageModelSession(model: model, instructions: Prompts.receiptExtraction)
do {
return try await session.respond(to: text, generating: ExpenseDraft.self).content
} catch let error as LanguageModelError {
if case .rateLimited = error, useCloud {
return try await draft(from: text, useCloud: false)
}
throw error
}
}
}That rate-limit fallback is Anthropic’s own documented pattern for its conformance. Treat the provider-side APIs as beta-era: Anthropic’s ClaudeForFoundationModels package is at 0.1.0, Apache 2.0, labelled “APIs might change during the beta,” and the LanguageModelExecutor surface shown in WWDC26 session 339 has a prewarm signature that differs between the protocol listing and the sample code. Check the headers in Xcode 27 before writing a conformance.
What the platform seam cannot express
Here is the part worth knowing before you promise cost portability. Anthropic’s “Feature support” page for its Foundation Models package lists what Apple’s protocol can’t carry: “Prompt caching controls (the package applies prompt caching automatically; cache TTL and breakpoint placement are not configurable), Stop sequences, Batch processing, Files API, Token counting, Beta headers.”
Cache TTL, the 50% Batch discount, and token counting are three of the four biggest cost levers available. The vendor implementing the seam is telling you the seam doesn’t expose them. That’s not an abstraction purist’s objection; it’s a documented limitation.
The Google path has its own asterisk. Gemini models reach Foundation Models through Firebase AI Logic (firebase-ios-sdk 12.19.0+ with FirebaseAILogic and FirebaseAppCheck, Xcode 27, iOS and macOS only in this release, gemini-4-argon supported). Firebase’s own documentation says it “is currently in Preview, which means that it isn’t subject to any SLA or deprecation policy” and “could change in backwards-incompatible ways.” That sentence belongs in any fixed-price conversation.
The defensible position: put the seam at the call site, keep the cost levers above it in your own code — your own token budget type, retry policy and usage logging — and allow a provider-specific fast path where a discount is worth more than uniformity. On auth, follow session 339: token providers or sign-in flows rather than raw API keys, tokens in Keychain, App Attest for cloud services. Anthropic’s .apiKey mode is development-only for a reason: “A key bundled into an app is extractable from the shipping binary.”
Estimating per-user cost so a 2x move doesn’t break it
Name every term so it’s visible which one moved.
cost_per_call = (uncached_in × P_in)
+ (cached_in × P_cached)
+ ((visible_out + thinking_out) × P_out)
+ per_call_tool_fees
cost_per_user = cost_per_call × calls_per_user_per_month × (1 + retry_rate)Measure the token terms, don’t guess them. Google documents a pre-flight countTokens endpoint for input, and a usage object on the response carrying total_input_tokens, total_output_tokens, total_thought_tokens, total_cached_tokens and total_tool_use_tokens. The “roughly 4 characters per token” rule from Google’s docs is for sanity-checking an order of magnitude, not for a quote.
Four rules that hold regardless of what Google does on December 1:
- Price output at $20/1M. Output is 5x input post-increase, and thinking tokens are billed there.
- Book cache hits as margin, not budget. Argon supports implicit caching only, with a 4,096-token minimum for a hit; explicit caching isn’t supported on Argon and later. You can shape prompts to earn the discount, not guarantee it.
- Count the tool schemas. Anthropic publishes exact overheads — a bash tool definition is 325 tokens on 4.7+, text editor 974,
computer_toolset_20260801about 4,500. An estimate that omits them is wrong by a fixed amount on every call. - Token counts aren’t portable. Anthropic notes its newer tokenizer “produces approximately 30% more tokens for the same text.” You cannot re-price a Gemini token count against a Claude rate card by swapping the dollar figure.
Illustrative placeholders, chosen for round arithmetic rather than measured from any app: 1,000 uncached input tokens, 500 visible plus 500 thinking output tokens, 20 calls per user per month, no tools, no retries. Today that’s $0.000012 per call, $0.00024 per user per month. At the December 1 rate, $0.000024 and $0.00048. Multiply by the forecast user count and set it against the 15% App Store commission already being paid under the Small Business Program (available below $1,000,000 in proceeds in the prior calendar year). The sentence that matters: model cost is a variable cost sitting behind a fixed subscription price. Carry both columns in the spreadsheet. If 2x on the output term breaks the business case, re-scope now rather than in December.
Fixtures in the repo, because the console is a dependency too
A swap is only cheap if you can prove it didn’t change behaviour. Xcode 27 ships an Evaluations framework for exactly this — WWDC26 session 298 introduces Evaluation, ModelSample(prompt:expected:), Metric, Evaluator, and ModelJudgeEvaluator, with Apple framing it as a way to “verify that your AI features behave correctly across dynamic conditions, going beyond what unit tests alone can catch.” Confirm the type names and OS floor against the current documentation; the API reference page was still thin when these notes were taken.
Two pieces of guidance from that session travel well: the judge model should be at least as capable as the model being evaluated, and judge scales should use an even number of levels so there’s no neutral default.
Keep the fixtures and the prompts in your own test target, for a reason the vendors are supplying themselves. OpenAI’s deprecations page retires reusable prompts (v1/prompts) on November 30, 2026, with the recommended replacement stated as “Move prompt content into application code.” The hosted Evals platform goes read-only October 31, 2026 and shuts down November 30, 2026, with migration to Promptfoo. Agent Builder shuts down the same day. Your prompt store and your eval harness are vendor dependencies with their own expiry dates.
The free path, and its own risk shape
For an iOS app this line item can make the December math moot. Apple’s Private Cloud Compute developer page: “developers in the App Store Small Business Program with fewer than 2 million first-time App Store downloads will be able to use Apple Foundation Models running on Private Cloud Compute (PCC) with no cloud API cost.” Three conditions: Small Business Program enrolment, under 2 million first-time downloads across any of the developer’s apps, and the PCC entitlement on the account. Test installs don’t count.
Read the next two clauses before treating it as free forever. Exceed the threshold or leave the program and “the developer will be notified and must migrate to an alternative solution within 6 months.” And server-side Apple Intelligence features, explicitly including developer apps on PCC, are “subject to daily usage limits” that “may vary by feature, request complexity, system demand, system policies, and other factors,” with expanded access “available for a fee in the future.”
John Gruber argued on June 13, 2026 that these limits are more restrictive than they look: the 2 million figure counts downloads across every app an account has ever released, so a long-tail app from a decade ago can disqualify a new one, and there is “no way (yet?) to buy your way out of these limits.” He cites developer Gui Rambo’s ChibiStudio as an example.
Both readings lead to the same action: check the account’s lifetime first-time-download total before PCC goes into a proposal, because the number that disqualifies you may have nothing to do with the app being quoted. Argon’s risk is a known 2x on a known date. PCC’s risk is an undisclosed cap and an unpriced future. Different shape, not smaller.
What actually goes in the proposal
Make model cost a line item with a model ID, a rate, a rate-card date and a review trigger: gemini-4-argon, $4 per 1M input and $20 per 1M output, per Google’s pricing page as of October 26, 2026, effective December 1, 2026.
The trigger matters more than the date. Re-price if the published rate changes, if measured tokens per call exceed the budgeted figure by an agreed margin, or if the provider announces deprecation. There is no shortage of precedent for the third one: OpenAI announced the GPT-4 series for removal on October 14, 2026 with shutdown on January 14, 2027 — about three months’ notice — and gpt-5, gpt-5-mini, gpt-5-nano, gpt-5-pro, o3 and o3-pro shut down on December 11, 2026.
Name who holds the API account. If the budget holder holds it, a December increase hits their card and your quote survives. If you hold it, you have quietly sold an unhedged commodity forward.
Two terms to get signed off. Gemini’s Additional Terms (effective March 23, 2026) treat paid and unpaid services very differently: on Paid Services Google doesn’t use prompts or responses to improve its products, while on Unpaid Services that content is used “to provide, improve, and develop Google products,” human reviewers may read and annotate it, and the terms say do not submit sensitive, confidential or personal information. In the EEA, Switzerland and the UK, API clients may only be made available using Paid Services. Argon has no free tier at all, which simplifies this particular question.
And App Store Review Guideline 5.1.2(i), retrieved October 26, 2026: “You must clearly disclose where personal data will be shared with third parties, including with third-party AI, and obtain explicit permission before doing so.” Apple’s text says disclose and obtain explicit permission; the common reading that consent must be a dedicated prompt at the moment of sharing is blog interpretation, not Apple’s wording. Either way, note the architectural consequence: the obligation is tied to which third party receives the data. Anthropic’s package routes app → Claude directly, with “Apple is not in the request path”; the Firebase path routes through Google. Same user-facing feature, different disclosure. Swapping providers behind your seam is a review-surface change too — the consent copy and privacy manifest belong inside the seam, not outside it.