# A Practical Guide to Gemini 4: Choosing Models, Thinking Levels, Quota Efficiency, and Prompt Caching Published: 2026-11-18 Updated: 2026-11-19 Author: Alexander Conroy Categories: Technology Tags: cloud, google, programming, Technology Description: A mental-model-first breakdown of Gemini 4 Hydrogen, Neon, and Carbon—when to use each thinking level, how token economics drive agentic subscription burn, how prompt caching works under the hood, and how to orchestrate subagents cleanly. --- The **Gemini 4** lineup is a three-tier curve trading off **latency and cost** against **reasoning depth and long-horizon judgment**. Whether you are working inside an agentic IDE like Google Antigravity or calling the Gemini API directly, understanding where each model sits on that curve—and how thinking levels and prompt caching interact with token economics—lets you get frontier results without burning through your quota or budget. | Model | Role | Thinking Levels | Core Trade-Off | | :--- | :--- | :--- | :--- | | **Hydrogen** | High-speed execution engine | `Low`, `Medium`, `High`, `XHigh` | Lowest latency and cost; built for fast iteration and parallel worker fan-out. | | **Neon** | Balanced daily driver & steerable builder | `Low`, `Medium`, `High`, `XHigh` | Near-Carbon reasoning with faster turns and high *steerability* (adapts cleanly to mid-flight corrections). | | **Carbon** | Heavy architect & deep strategist | `Low`, `Medium`, `High` | Spends the most thinking tokens stress-testing hypotheses, edge cases, and failure modes before acting. | > **What happened to Argon?** With the launch of **Gemini 4 Neon** on November 18, 2026, Google replaced Argon with Neon in the Gemini app. While `gemini-4-argon` remains active in the API and developer tools for now, Neon delivers near-Carbon intelligence faster and at a lower price point—effectively superseding Argon for new workflows. **Neon (`XHigh`)** can even match or edge out **Carbon (`High`)** on raw analytical benchmarks while staying more responsive, making Neon the default starting point for most hands-on engineering. ## 1. Per-Model Breakdown & Thinking Levels ### Gemini 4 Hydrogen — *The Fast Hands & Swarm Worker* **When to reach for it:** Well-scoped, deterministic execution where the mental model is already clear and you want speed, tight edit-test loops, or parallel subagents handling routine work. * **`Low`** — Mechanical, zero-ambiguity work: quick docs and notes, formatting, log skimming, shell one-liners, boilerplate scaffolding, single-file tweaks. * **`Medium`** — Standard day-to-day execution: writing unit or integration tests, straightforward UI component adjustments, small CLI/automation script updates, running verification sweeps. * **`High`** — *Sweet spot for Hydrogen.* Punches well above its weight on self-contained debugging, multi-file refactors with clear specs, or parallel subagent workers. * **`XHigh`** — Niche: when you want a cheap, fast background worker to grind through a stubborn self-contained test failure or build error without escalating to a heavier model. ### Gemini 4 Neon — *Your Default Daily Driver* **When to reach for it:** Your primary seat for interactive coding, learning-while-building, and rapid break-fix. Neon is built for long, tool-heavy sessions without context bloat, and it excels at **steerability**—so when you interrupt mid-plan to challenge an assumption or change a trade-off, it pivots cleanly instead of fighting you. * **`Low`** — Fast interactive Q&A, explaining *how* a mechanism works under the hood, quick diff sanity checks, or lightweight brainstorming. * **`Medium`** — *Best default for interactive coding.* Building features across backend services, wiring background/scheduled jobs, iterating on Dockerfiles, CI pipelines, and observability configs, or working on frontend and native client flows. * **`High`** — Multi-file debugging and cross-layer tracing (for example, chasing a failure across reverse proxy → API → database/cache, debugging container volume mounts, or reviewing OIDC/auth flows). * **`XHigh`** — Heavy analytical and systems work where you would previously jump straight to Carbon: gnarly race conditions, tricky secrets/infrastructure/boot chains, dense repo audits, or multi-repo refactors where you want deep verification at lower latency. ### Gemini 4 Carbon — *The Architect & Threat Modeler* **When to reach for it:** High-stakes, long-horizon decisions where **getting the architecture and invariants right on pass 1** matters more than turn speed—especially trade-off analysis, threat modeling, and buy-versus-build calls. * **`Low`** — Only for quick clarifications inside an active Carbon design session. * **`Medium`** — Design documents, risk-appetite trade-off analyses, security boundary design (such as zero-secret container isolation, RAM-only secret materialization, or disaster-recovery architectures). * **`High`** — The "bring out the big guns" setting: greenfield system architecture, subtle distributed-systems or cryptographic invariants, deadlocks where Neon hit a wall, or long-horizon autonomous runs. ## 2. Token Economics & Subscription Quota Efficiency In agentic environments like Antigravity on **Google AI Ultra**, all Gemini 4 models draw from a **shared, unified quota pool** (a 5-hour rolling window plus a weekly ceiling), weighted by underlying compute and API cost. Two mechanics dominate your burn rate: 1. **Thinking tokens are billed at Output rates (5x Input).** Reading a 100k-token repository with prompt caching (95% discount) is almost free; letting a model ramble for 15k internal thinking tokens on a trivial edit is what drains your quota. 2. **Thinking level often swings burn *more* than model tier.** Stepping from `Medium` → `High` → `XHigh` can multiply per-turn thinking tokens by **2x–5x+**. | Model | Input / Cached / Output (per 1M tokens) | Relative Rate | Total Burn Profile | | :--- | :--- | :--- | :--- | | **Hydrogen** | `$1.50` / `$0.075` / `$7.50` | **1.0x** (baseline) | **Most quota-efficient** — half the rate of Neon, ~62% cheaper than Carbon. | | **Neon** | `$3.00` / `$0.15` / `$15.00` | **2.0x** | **Best quality-per-credit** — 25% cheaper per token than standard Carbon, with tighter thinking-token discipline. | | **Carbon** | `$4.00` / `$0.20` / `$20.00` *(intro `$2/$10` thru Nov 30, 2026)* | **2.67x** | **Highest burn** — top per-token rate *and* longest internal chain-of-thought per turn. | ### Cost & Credit Efficiency by Model + Thinking Level #### Hydrogen — *Quota Preserver* * **`Low` (Ultra-Cheap):** Virtually negligible quota impact. Best for quick Q&A, notes, formatting, log skimming, and single-file tweaks. * **`Medium` (Very Cheap):** High ROI for standard coding, writing tests, boilerplate, and routine edits. * **`High` (Best Budget Power-User Setting):** Even with deeper thinking, Hydrogen's `$7.50/M` output rate makes `Hydrogen (High)` one of the highest **intelligence-per-credit** settings in the entire lineup—ideal for bounded parallel workers. * **`XHigh` (Watch the Spin):** Can burn as much quota as `Neon (Medium)` if it loops on a hard bug. Only use when you want a cheap worker grinding autonomously on a self-contained failure. #### Neon — *Best Overall Quality-Per-Credit* * **`Low` (Cheap):** Great for fast interactive explanations and diff checks without paying heavy thinking overhead. * **`Medium` (The Daily-Driver Sweet Spot):** Best balance of accuracy, steerability, and quota preservation. Keeps sessions moving in fewer retry turns (which saves *more* credits than using a weaker model that fails twice). * **`High` (Moderate Burn):** Worth the bump for multi-file debugging or cross-service tracing—usually cheaper overall than letting `Medium` guess and retry three times. * **`XHigh` (Expensive per Turn, High Ceiling):** Matches or edges out `Carbon (High)` at 25% lower per-token cost, *but* `XHigh` generates heavy thinking tokens. Use it surgically on hard turns, then drop back to `Medium`. #### Carbon — *Quota Heavyweight (Use Surgically)* * **`Low` (Avoid as a Starting Point):** Paying frontier rates with minimal thinking gives poor ROI; only use to ask a quick clarifying question inside an existing Carbon thread. * **`Medium` (High Burn, High Leverage):** Good ROI for architecture and threat-modeling docs where getting the design right prevents hours of wasted downstream coding turns. * **`High` (Maximum Burn):** Fastest way to hit the 5-hour quota cap. Strictly for greenfield architecture, hard invariants, or deadlocks where Neon got stuck. ### 5 Rules to Preserve Your Agentic Subscription 1. **Live on `Neon (Medium)` or `Hydrogen (High)`** — only escalate to `Neon (High/XHigh)` or `Carbon` for the specific turn that actually needs deep reasoning, then step back down. 2. **Use `Orchestrator (Neon)` or `Orchestrator (Carbon)` for multi-step work** — multi-model orchestration saves roughly **~24% quota** on complex benchmarks by auto-routing mechanical edits and tests to Hydrogen while reserving the heavier model for planning. 3. **Avoid thrashing models mid-thread** — switching models invalidates the **95% cached-input discount** on your conversation history. If a thread gets huge, compact the context before continuing. 4. **Cap parallel fan-out and run workers on `Hydrogen (Medium/High)`** — avoid uncapped swarms, `/teamwork`, `/boost`, `/goal`, or multi-agent workflows without explicit worker caps (≤ 3 concurrent workers is a solid default), and never spawn parallel workers on Carbon when Hydrogen can execute a clean spec at ~35% of the cost. 5. **Short-circuit retries early** — one clean `Neon (High)` pass that nails a bug on turn 1 costs *less* quota than four `Hydrogen (Low)` turns that thrash and bloat the context window. ## 3. How Prompt Caching Works Under the Hood Every time you send a new message in an agentic session, the harness resends the **entire conversation from byte 0** (system prompt, repository rules, tool schemas, prior turns, tool outputs, and your new message). Normally, the model has to run a full **prefill pass**—computing the Transformer attention **Key/Value (KV) matrices** for every single input token before generating the first output token. **Prompt caching** hashes the **exact token prefix** and keeps those precomputed KV tensors in fast inference memory (HBM/RAM): * If the next request starts with the **exact same token prefix byte-for-byte**, the server skips recomputing those KV matrices and only runs prefill on the **new suffix**. * On **Gemini 4**, a cache hit gives you a **95% discount** on cached input tokens (`$0.075` / `$0.15` / `$0.20` per 1M instead of `$1.50` / `$3.00` / `$4.00`) *and* dramatically lowers Time-To-First-Token (TTFT). **The Golden Invariant:** Caching is **strictly prefix-based**. Changing *a single byte* near the top of the prompt (such as a live clock timestamp in the system prompt, adding or removing a tool definition, editing an earlier message, or switching models) invalidates the cache from that point downward. ### Time Windows (TTL) & Gemini 4 Mechanics Unlike older Gemini 2.5 models (which supported *explicit* `caches.create` objects with a configurable 1–60+ minute TTL and hourly storage fees), **Gemini 4 uses automatic, implicit-only caching** (no setup, no storage fee, 95% discount, best-effort): | Mechanic | Gemini 4 Behavior | Practical Meaning | | :--- | :--- | :--- | | **Time Window (TTL)** | **Dynamic LRU eviction** (hard ceiling **≤ 24 hours**; in practice stays hot for **~minutes up to ~15–60 min** of idle time depending on cluster load). | Active back-and-forth coding (turns seconds to a few minutes apart) gets near-100% cache hits. Walking away for an hour and resuming a 150k-token thread usually triggers a **cold miss** on the first turn back (full input price once to re-warm), then 95% off again. | | **Minimum Prefix Floor** | **4,096 tokens** | Standard agentic harnesses (system prompt + repo instructions + tool schemas) clear this on turn 1, so sessions qualify immediately. | | **Multi-Turn Checkpoint Delta** | **~2,050 new tokens** per turn (thoughts + output + tool results) to extend the cached checkpoint forward. | Small banter turns still hit the *existing* prefix cache—they just re-prefill the short uncached tail until it crosses ~2,050 tokens and checkpoints again. | *(For comparison, Claude uses explicit cache breakpoints with a 5-minute—or optional 1-hour—sliding TTL that resets on every hit. Different implementation, same operational rule: **focused bursts beat sparse pokes**.)* ### Switching Models vs. Changing Thinking Levels Mid-Thread * **Switching models mid-conversation (`Neon → Carbon`, `Hydrogen → Neon`) → Guaranteed hard cache miss:** A prompt cache stores the precomputed Transformer **Key/Value (KV) matrices** (`K = X·W_K`, `V = X·W_V`) produced by that specific model's weights and attention head layout. `Carbon` physically cannot read `Neon`'s KV tensors. Switching models inside a 150k-token thread means paying **100% full input rate** for all 150k tokens on that turn (plus a cold Time-To-First-Token spike)—and switching back forces `Neon` to re-prefill any new turns or the entire history if its implicit cache was evicted in the meantime. * **Changing thinking level on the *same* model (`Neon Medium → Neon High`) → Much friendlier, but not a guaranteed free lunch:** Because `thinking_level` is a generation-time config on the same base weights, the cached KV prefix can remain valid. However, with implicit caching, routing `High`/`XHigh` to a different serving replica pool or shifting an internal reasoning preamble can still trigger a miss on that turn. **Takeaway:** Never bounce between different models inside a large thread—delegate cross-model work (`Carbon` or `Hydrogen`) to a fresh subagent or clean session instead. On a single model, pick a sensible default (`Neon Medium`) and step thinking level up or down only when a turn genuinely warrants it rather than toggling every message. ### What Happens on the Wire When You Interrupt or Steer Mid-Turn At the API level, there is no persistent "live brain" connection. Every single step in an agentic loop—even between two tool calls—is a **separate, stateless HTTP request** (`POST .../generateContent`) sending an append-only `contents[]` array. Because prompt caching is prefix-based, **appending** a steering note at the tail keeps your entire prior KV cache intact. #### 1. Normal Tool-Calling Loop ```text # API Call #1 contents: [ [system + rules + tool schemas + prior turns] <-- CACHED (95% off) { role: "user", text: "Add a billing export route" } <-- NEW ] # Model returns: thought + tool_call: ls("src/routes/") # Harness runs ls("src/routes/") locally (no LLM running) ``` #### 2. Queued / Soft Steering (Cheapest Way to Steer) If you send a clarification while a tool is running (or queue a follow-up mid-turn), the harness finishes the tool call and **appends your message at the very tail** of the next API call: ```text # API Call #2 contents: [ [system + rules + tool schemas + prior turns] <-- CACHED (95% off) { role: "user", text: "Add a billing export route" } { role: "model", tool_call: ls("src/routes/") } { role: "tool", output: "auth.ts, billing.ts, ..." } { role: "user", text: "Target /v2/billing, not /v1" } <-- APPENDED AT TAIL (NEW) ] ``` * **Cache impact:** **Zero cache invalidation.** Every token before the tail stays byte-for-byte identical (95% discount); you only pay normal input rate for the tiny newly appended suffix. #### 3. Hard Stop / Cancel Mid-Generation If you hit **Stop** while the model is actively streaming thinking or text tokens: 1. The harness aborts the in-flight HTTP stream (`AbortController.abort()`). You still pay output rates for any thinking/text tokens generated *before* the abort landed (another reason interrupting `Neon Medium` is far cheaper than interrupting `Carbon High`). 2. The harness cleans up any incomplete tool call so the API schema stays valid, and on the next request appends your new message at the tail: ```text # Next API Call contents: [ [system + rules + tool schemas + all completed prior turns] <-- STILL 100% CACHED { role: "user", text: "Hold on, pivot — do Y instead" } <-- APPENDED AT TAIL (NEW) ] ``` * **Cache impact:** Your **entire completed conversation prefix is still 100% cached.** You only lose the aborted partial turn's output tokens—not the cached history. **Summary of what does and doesn't bust your cache:** * **Appending** extra context or a correction at the end → **Cache-safe.** * **Rewinding / editing an earlier message** → **Cache miss** from that edited message forward (mutates the prefix). * **Switching models mid-thread** → **100% full cache miss** from byte 0. ### How to Optimize for Prompt Caching #### In Agentic IDEs & CLI Harnesses * **Work in focused bursts on big threads:** Keep turns close together while the KV cache is hot. If you step away for two hours and return to a 200k-token thread, expect one expensive re-warm turn—if the task is mostly done anyway, start a fresh thread instead. * **Don't switch models mid-thread:** KV caches are tied to a model's weights. Switching `Neon → Carbon → Neon` inside a 150k-token conversation busts the cache **twice** (two full cold prefills). If you need Carbon for one hard architectural call, ask it in a **fresh session** with a tight summary instead of dragging the entire Neon history into Carbon. * **Step thinking level on the *same* model:** Bumping `Neon (Medium)` → `Neon (High)` stays on the same base weights, preserving prefix compatibility far better than jumping model families. * **Don't mutate the prefix mid-session:** Adding or removing MCP servers, editing repository rules files, or rewinding and editing early messages invalidates everything downstream of the change. * **Compact or start fresh between tasks:** Even at 95% off, a 300k-token stale thread still pays `5% × 300k` every turn *and* bloats reasoning/thinking tokens (which are never cached and cost full output rates). #### In Your Own API Pipelines & Multi-Agent Systems * **Enforce strict Static → Dynamic ordering:** Structure every request as: 1. Static system prompt and instructions 2. Deterministically sorted tool and JSON schemas 3. Shared repository, documentation, or domain context 4. Conversation history 5. **Volatile data last** (`current_time`, request IDs, user query) *(Never inject `Date.now()` into the system prompt—it guarantees a 0% cache hit rate.)* * **Fan out parallel workers on a shared prefix:** If you spawn parallel `Hydrogen` workers analyzing the same 30k-token codebase or log bundle, give them the **exact same leading prefix** and place each worker's unique slice or question at the very end—worker 1 warms the prefix, and the remaining workers ride the 95% discount. ## 4. Putting It Together: Orchestration, Sub-Orchestration & the `gemini-orchestrator` Skill Understanding the three-tier curve is only half the win—the real leverage comes from **structuring your agentic sessions around it** so the right model handles each phase without duplicating tokens or locking up your main chat thread. ### The Comms-Driver → Sub-Orchestrator → Workers Pattern Instead of running an entire multi-step epic inside one heavy `Carbon (High)` thread (slow, expensive, and hard to interrupt) or forcing a lightweight model to wing complex architecture, split the work across three layers: 1. **Main Thread — Human Communications & Steering Driver (`Neon Low` or `Neon Medium`):** Keep the thread you actually talk to thin, fast, and responsive. Because agentic harnesses like Google Antigravity run subagents and swarm workers asynchronously in the background, a lightweight Neon driver lets you watch subagent thinking in real time, catch a misinterpretation or voice-to-text slip, and immediately relay a course correction to a running worker without waiting for a heavy turn to finish. 2. **Research & Architecture Sub-Orchestrator (`Carbon High` or `Neon XHigh`):** When a task calls for deep research, trade-off analysis, threat modeling, or a multi-repo audit, delegate that phase to a fresh `Carbon` or `Neon XHigh` sub-orchestrator. Rather than dumping a 12,000-token report back into your main chat, it writes the complete plan or findings to an **artifact file on disk** and returns only a 5–10 line executive summary, the file path, and the key decisions that need your input. 3. **Execution Sub-Orchestrator (`Neon Medium`) + Capped Workers (`Hydrogen Medium/High`):** Once you approve or steer the plan, the main thread hands **only the artifact path and bounded target scope**—never the main thread's chat history—to a `Neon (Medium)` execution sub-orchestrator or a capped group of `Hydrogen` workers (≤ 3 concurrent by default). Each worker starts clean, shares a common static prefix (riding Gemini 4's 95% prompt-cache discount), executes and verifies its slice, and reports back concisely. ### Built-In Guardrails To keep orchestration from burning quota on small requests, the workflow enforces three guardrails on the main human-facing thread: * **3-Tier Complexity Gate:** Quick Q&A, single-file edits, and simple commands stay inline (Tier 0, zero subagent overhead). Self-contained research or test runs use a single targeted worker (Tier 1). Only genuine multi-phase epics trigger nested sub-orchestration (Tier 2). * **Hard Quota & Concurrency Caps:** Never launch uncapped `swarm` groups, `/teamwork`, `/boost`, `/goal`, or multi-agent `run_workflow` fan-outs without explicit user approval and bounds (≤ 3 concurrent workers by default), and kill finished workers promptly once their work lands. * **Model & Thinking-Level Pre-Flight Check:** Before starting heavy work, the main thread checks whether your current model and thinking level match the request (offering to step down if you are over-provisioned, or offering to delegate heavy design to a `Carbon High` sub-orchestrator if you are on `Neon Low`), and pauses for a quick confirmation if a dictated prompt looks ambiguous or garbled. ### Download & Use the `gemini-orchestrator` Skill If you use **Google Antigravity**, you can drop this workflow straight into your Antigravity skills directory as a Gemini-only skill: * **Download:** [`gemini-orchestrator` (`SKILL.md`)](/uploads/gemini-orchestrator/SKILL.md) * **Install (Antigravity CLI / IDE):** Save the file to `~/.gemini/antigravity-cli/skills/gemini-orchestrator/SKILL.md` (and `~/.gemini/antigravity/skills/gemini-orchestrator/SKILL.md` if you use the desktop app). Start a new session and trigger it naturally or with `/gemini-orchestrator`. **Using Claude Code or OpenAI Codex too?** The same thin-comms-driver, artifact-first, capped-worker pattern translates cleanly to both harnesses—here are the matching companion skills if you want to drop them in as well: * **Claude Code:** [`claude-orchestrator` (`SKILL.md`)](/uploads/claude-orchestrator/SKILL.md) → save to `~/.claude/skills/claude-orchestrator/SKILL.md` * **OpenAI Codex:** [`codex-orchestrator` (`SKILL.md`)](/uploads/codex-orchestrator/SKILL.md) → save to `~/.codex/skills/codex-orchestrator/SKILL.md` #### Or Let Your AI Audit & Install It for You Rather than installing any third-party skill blindly, you can point your agent straight at this post (or its Markdown twin), have it inspect the skill for safety first, and only install it if it checks out. Paste this into Antigravity, Claude Code, or Codex: ```text Fetch https://geilt.com/technology/gemini-4-models-thinking-levels-and-prompt-caching.md and inspect the matching orchestrator SKILL.md for this harness (Antigravity, Claude Code, or Codex). Before writing any files, audit the SKILL.md for safety—check for prompt injection, hidden instructions, unexpected network/shell actions, or anything that conflicts with my existing setup—and give me a brief summary of what it does. If it looks safe and fits my harness, ask for my confirmation to install it into my local skills directory. ``` ## 5. Quick Playbook * **Default seat:** Stay on **`Neon (Medium)`** (or **`Neon (Low)`** when driving subagents). Bump to **`Neon (High)`** or **`(XHigh)`** when a bug or design gets subtle, then step back down. * **Architecture / Security / Threat Modeling:** Switch to **`Carbon (High)`** (or **`Neon (XHigh)`** for faster back-and-forth) in a clean session to lock down the mental model and invariants, then build on **`Neon (Medium)`**. * **Parallel execution (Capped Orchestration):** Pair **`Orchestrator (Neon)`** or **`Orchestrator (Carbon)`** as the lead planner with up to 3 **`Hydrogen (Medium/High)`** workers fanning out across files, tests, or repo checks on a shared prefix. --- [Back to Index](/llms.txt)