Gemini 4 Argon: Developer Guide | Google AI Studio

Developer guide for our frontier model, Gemini 4 Argon. What is new and tips and tricks to get the most out of the model.

Developer guide

Gemini 4 Argon is our new frontier model for complex workflows across real-world software engineering, enterprise knowledge work, and cybersecurity defense.

Published October 13, 2026

Today, we are rolling out Gemini 4 Argon globally to developers and enterprises. You can start building using the paid tier of the Gemini API in Google AI Studio, and for Google AI Ultra subscribers in AI Studio and our agent-first development platform, Google Antigravity.

Gemini 4 Argon is trained to work longer and retain context better than any previous Gemini model. From large-scale codebase refactoring and performance optimizations to vulnerability patching and multimodal synthesis, it is built to take on your hardest tasks, from start to finish.

Gemini 4 Argon model overview

Argon supports a unified 1M token context window via the Gemini API for input and output tokens (up from 64k in previous models), tunable thinking levels (low, medium, high), and the same suite of built-in Gemini API tools.

In this guide, we cover what is new in Gemini 4 Argon and share practical tips for building with the model. For more on how Gemini 4 Argon is being used across robotics, science, finance, legal and more, check out our announcement blog post.

What Gemini 4 Argon unlocks across developer workflows

Gemini 4 Argon's enhanced reasoning and problem solving capabilities give it the room to work through massive problems from start to finish.

1. Long-horizon engineering and security tasks: Hand Argon a measurable target—like untangling a legacy subsystem, refactoring a codebase from C++ to Rust, or remediating security vulnerabilities and let it build its own verification harness, test hypotheses against compiler or runtime output, and iterate until the task is done.
2. End-to-end multimodal and business workflows: Point Argon at dense folders mixing long videos, PDFs, spreadsheets, financial ledgers, or legal filings to cross-reference facts across formats and turn unstructured inputs directly into interactive dashboards, slides, or audited redlines.
3. 3D visualizations, simulations, and full-stack apps: Combine Argon's spatial reasoning and visual code generation across tools like Blender, Three.js, and WebGPU to build complex 3D scenes, physics simulations, and full-stack web apps. Check out our companion guide, Building 3D Games and Procedural Worlds with Gemini 4 Argon, for practical workflows.

What’s new in the API

Before diving into workflow tips, here are the key API updates to know when calling gemini-4-argon via the Gemini API:

Controlling reasoning depth with thinking_level

Gemini 4 Argon uses thinking_level ("low" | "medium" | "high") to control how much reasoning (thinking) the model does before responding:

• "high": Maximizes reasoning depth for multi-file root-cause debugging, security vulnerability patching, formal math, and upfront architecture design.

• "medium" (default): Recommended when you want an optimal balance of speed, cost efficiency, and high first-pass accuracy across interactive coding and agentic tool use.

• "low": Minimizes latency and cost for high-speed classification, routing, and targeted extraction.

python

12345678910111213141516

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-argon",
    input=(
        "Build a single-file HTML drum machine and synth using the "
        "Web Audio API with a 16-step sequencer, tempo slider, and "
        "a live waveform visualizer."
    ),
    generation_config={
        "thinking_level": "medium"  # "low" | "medium" (default) | "high"
    },
)
print(interaction.output_text)

123456789101112131415

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
  model: "gemini-4-argon",
  input:
    "Build a single-file HTML drum machine and synth using the " +
    "Web Audio API with a 16-step sequencer, tempo slider, and " +
    "a live waveform visualizer.",
  generation_config: {
    thinking_level: "medium", // "low" | "medium" (default) | "high" 
  },
});
console.log(interaction.output_text);

Unified 1M input-output token limit and long decodes

Earlier Gemini models capped max output (thinking + response) at 64K tokens. In Gemini 4 Argon, input, thinking, and output share a unified 1M-token window in the Gemini API, and you can use long decode to generate past 64K tokens (up to 1M tokens minus your input) so Argon can think as long as needed and still return complete multi-file diffs, test suites, or long-form proofs in a single pass.

• Default output limit is 65,536 (64K) tokens: On the Interactions API, both streaming and non-streaming requests default to 65,536 tokens with no code changes required.
• Generate up to 1M tokens with background=True: To generate past 65,536 tokens on the Interactions API, set background=True and set max_output_tokens above 65536. Set it high enough that thinking doesn't cut the answer short, and low enough to limit spend when a hard prompt uses all of it.

NOTE: If you need finer-grained control over long decode, you may prefer client-side continuation for long decoding, which is currently only available via the legacy GenerateContent API. Client-side continuation will soon come to the Interactions API as a more advanced option to manage your own resilience.

See the long decode docs for more details

python

12345678910111213141516171819202122232425262728293031

import time

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-argon",
    input="Write a complete, rigorous proof of the prime number theorem.",
    background=True,
    generation_config={
        "max_output_tokens": 262144,
        "thinking_level": "high",
    },
)

while interaction.status in ("in_progress", "queued"):
    time.sleep(5)
    interaction = client.interactions.get(id=interaction.id)

# Each segment adds a model_output step, so join the text of all of them.
text = "".join(
    content.text
    for step in interaction.steps
    if step.type == "model_output"
    for content in step.content
    if content.type == "text"
)
print(text)
print("Status:", interaction.status)
print("Usage:", interaction.usage)

See the What's new in Gemini 4 Argon for details on updating hardcoded 64K synchronous output limits, background retention, dynamic output clamping, and stateless continuation.

Migrating from previous models

When migrating to Gemini 4 Argon, clean up the following parameters:

• Replace thinking_budget with thinking_level: thinking_budget is deprecated and returns a warning.
• Remove temperature, top_p, and top_k: Custom sampling values are ignored by gemini-4-argon and return a deprecation warning.
• Move off explicit context caching: Remove calls that create or pass explicit cached_content. Implicit caching is enabled automatically at a 95% discount on cached input tokens.
• Increase client timeouts: Hard reasoning prompts can take several minutes. Use background=True on the Interactions API, or set your HTTP client timeout to at least 15 to 20 minutes.

For full details, check out our migration checklist, or install the gemini-api-devskill in your coding agent and ask it to migrate your codebase to gemini-4-argon.

Use Gemini 4 Argon in managed agents

You can also use gemini-4-argon as the model for Managed Agents in the Gemini API. Managed agents provide a hosted sandbox and the Antigravity harness where Argon's frontier reasoning can search the web, write code, verify work, and call MCP tools all with a single API call.

python

123456789101112131415161718192021

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    agent="antigravity-preview-09-2026",
    agent_config={
        "type": "antigravity",
        "model": "gemini-4-argon",
    },
    input=(
        "Audit https://web.dev for performance, Core Web Vitals, and SEO. "
        "Query Google's PageSpeed Insights API for both Mobile and Desktop strategies. "
        "Check search indexing with Google Search for site:web.dev. "
        "Format the output as a side-by-side scorecard table with prioritized fixes."
    ),
    environment="remote",
)

print(interaction.output_text)

1234567891011121314151617181920

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({});

let interaction = await client.interactions.create({
    model: "gemini-4-argon",
    input: "Write a complete, rigorous proof of the prime number theorem.",
    background: true,
    generation_config: {
        max_output_tokens: 262144,
        thinking_level: "high",
    },
});

while (["in_progress", "queued"].includes(interaction.status)) {
    await new Promise((resolve) => setTimeout(resolve, 5000));
    interaction = await client.interactions.get(interaction.id);
}

console.log(interaction.output_text);

Finance Story

A personalized interactive visualization for your finances built by Argon. Drop in your transactions from the past year and let the agent turn them into animations and visuals.

Pixel Arcade

An arcade machine that lets you generate your own personalized games. Choose a character and type of game style you want and a managed agent builds, plays, and returns you a working game.

5 practical tips for building with Gemini 4 Argon

Here are five patterns we’ve seen our teams use to get the most out of the model and tackle their hardest problems.

1. Align on intent before long runs

Gemini 4 Argon can work on a task independently for a long time. This means that clear alignment upfront on measurable goals and key milestones helps you get to your result most effectively. Once pointed at a clear goal, the model holds context across long runs on its own really well. To make sure a long autonomous run is pointed at the exact right target from step one:

• Share your goal and ask Argon to surface clarifying questions about edge cases and success criteria upfront.
• Ideate with Argon while scoping: Use the planning phase to pressure-test architecture and explore creative solutions. In our workflows, we’ve seen it suggest novel upgrades across the stack - from designing surprising gameplay mechanics and procedural visual effects to recommending cleaner data models and more intuitive API design.
• Run a quick pre-flight check: Have Argon confirm it has access to the required tools, docs and understands the intent before starting.
• Step back and let Argon run to completion: Instead of prompting turn by turn, let Argon execute the full plan autonomously - writing code, running checks, and iterating across files until it hits the target you agreed on, while pausing for your confirmation before taking irreversible steps.

2. Give the model a way to verify its work

Argon does its best long-horizon work when it can test its own changes against a real feedback loop. Instead of making Argon guess whether a fix worked, give it a concrete signal to check: point it at your test suite, pipe in runtime logs, let it take browser screenshots to inspect the UI, or ask it to write a verification script and iterate in a loop until every check passes. Better yet, have Argon write a reproducible verification script, record a baseline score, and test every change against that script in a loop until the target is met. With a concrete pass/fail target, Argon can record a baseline, test hypotheses in a loop, and iterate until the checks are green.

If you don’t have something to measure, ask Argon to help analyze your project and build a baseline benchmark.

prompt

We want to fix accessibility and layout issues across our web app, but we don't have automated checks yet. First, write a headless Chrome script that crawls every route in src/routes/, inspects the live DOM and accessibility tree, and logs all violations to record our baseline score. Group the failing checks into shared root causes across our shared components, then fix them one cluster at a time. Re-run your script after each change to verify that each single fix resolves the entire cluster with zero regressions. Keep going until all routes pass with zero violations.

3. Use multimodal references

Gemini models have long been great at multimodal capabilities and Gemini 4 Argon is no different. It can take in images, audio, video, code, and text as input. Pass reference images when building frontends or recreating images in 3D builds, or pass it a video when you want to recreate a certain animation or interaction on your web app.

If you have a specific target style in mind for your project, point Argon at 1–2 concrete visual references, or ask it to summarize your typography, color palette, and layout rules into a lightweight DESIGN.md file first so every component stays visually cohesive.

Gemini 4 Argon also includes agentic video understanding, which lets the model dynamically scrub across timestamps, inspect individual frames in high resolution, and connect what it sees on screen with spoken narration or console audio. Try recording a quick screen-share where you click through your app and talk through rough edges out loud, capturing a tricky timing bug alongside your live console logs, or drop in a 20-minute user testing recording and ask Argon to pinpoint where users got stuck and patch the underlying components.

4. Use Argon as an orchestrator

For deeply technical tasks, Argon is great at orchestrating subagents to parallelize work. While you can let Argon steer multiple Argon subagents for complicated tasks, developers across Google frequently enjoy pairing Gemini 4 Argon with Gemini 3.8 Flash subagents as high-speed implementation workhorses. Argon handles the heavy architectural reasoning and code review, while Flash speeds through parallel execution, giving you the best of both worlds in terms of speed, cost, and code quality.

• Use Gemini 4 Argon (thinking_level="medium" or "high") as the lead orchestrator to break down the problem, design interfaces, and review finalized work.
• Delegate parallel, well-scoped tasks, such as fast codebase explorations, writing boilerplate tests, migrating individual leaf modules, or running high-frequency checks to Gemini 3.8 Flash subagents (model: flash).
• For rich interactive apps, let Argon orchestrate specialized models across modalities: Nano Banana for UI images, textures, and sprites, and Gemini 3.8 Flash TTS or Lyria for voice and music

5. Have Argon reflect on past work

At the end of a complex task - or mid-session when tackling a particularly gnarly problem - ask Argon to step back and review the trajectory so far. Because Argon excels at synthesizing details across long histories, building a habit of reflection pays off in two ways:

• Skip repeated trial-and-error on codebase quirks: Every repo has non-obvious gotchas - custom test flags, strict lint rules, or deprecated helpers - that can cost extra turns to diagnose. Having Argon write those lessons into AGENTS.md or a reusable skill means future sessions take the direct path on the first try
• Turn one-off debugging into reusable team skills: Once Argon figures out a reliable multi-step workflow (like running a tricky local migration or verifying a build), ask it to package those exact steps into a reusable skill so you - and your teammates - never have to rediscover them from scratch.

Try prompting Argon with:

prompt

Investigate our current session to see where things stalled or required extra steps, and analyze why. Propose updates to our AGENTS.md or custom skills so we can improve our flow and take a more direct path next time.

When Argon completes a long autonomous run across dozens of files, reading the raw diff isn't always the fastest way to build a mental model of what changed. Try asking Argon to generate an interactive visual explainer of its solution - like a live architecture diagram, a data-flow map, or a step-by-step pipeline walkthrough. It’s a fast way to sanity-check the design before merging, get up to speed on unfamiliar math or rendering logic, or see the progress on your 3D render in a satisfying animation so you can understand which changes had the biggest impact.

Getting started

You can start building with Gemini 4 Argon today across Google’s developer platforms:

• Google AI Studio: Test prompts in Playground or build full-stack apps in Google AI Studio Build, available to Google AI Ultra subscribers and developers using a paid tier in the Gemini API.
• Gemini API: Use gemini-4-argon in the Interactions API with day-one support across the google-genai SDKs and in Managed Agents.
• Google Antigravity: For Google AI Ultra subscribers, select Gemini 4 Argon (gemini-4-argon) as your active model in Google Antigravity for complex planning, /goal runs, and multi-agent orchestration.
• Developer Documentation: Read the full Gemini 4 Argon and Long Decode documentation, plus our companion guide on Building 3D Games and Procedural Worlds with Gemini 4 Argon.
• Use your favorite development tools: You can also start building with Gemini 4 Argon today across popular tools and harnesses such as Vercel, LiteLLM, OpenRouter, Pydantic, OpenCode, LiveKit, BrowserBase, Eigent, and Cua.
• Gemini API skill: Install the gemini-api-devskill in your coding agent and ask it to migrate your codebase to gemini-4-argon.