Gemini 4 Argon continuation: why another “continue” prompt is the wrong request

Your evaluation harness receives finish_reason=CONTINUATION, but the visible text is empty. It marks the answer as failed, sends “continue,” and gets a different trajectory. A long generation was mistaken for a new conversation turn.

Gemini 4 Argon's long decode uses a continuation token to resume the same generation. In a custom client, preserve the original request and pass the latest token. For most applications, a supported Google Gen AI SDK manages this sequence instead.

One shared limit, several requests

The developer guide specifies 1,048,576 tokens shared by input and output. Output includes thinking, function calls and final text. It is not a million input tokens plus another million output tokens.

A streaming request generates up to 65,536 output tokens per segment; non-streaming direct HTTP requests generate up to 32,768. Long decode can extend one generation over multiple requests, subject to the shared limit and the requested output cap. If input uses 200,000 tokens, the arithmetic ceiling left for output is 848,576—not a prediction of actual output length.

Google's October 13 announcement supplies the release context. For a client migration, the current protocol and response fields matter more than benchmark headlines.

Choose who owns continuation

Long decode currently requires v1beta1 on GenerateContent, not v1. The SDK uses v1beta1 by default unless explicitly overridden. The Interactions API does not support long decode; ordinary conversation continuation with an interaction ID is a different operation. Older SDKs and the OpenAI compatibility layer cannot retrieve long completions through these tokens.

Set max_output_tokens above 65,536 for streaming or 32,768 for non-streaming when long decode is needed. Do not request the maximum by habit: latency-sensitive chat, extraction and many short tool turns usually do not need it.

A custom loop must resend the original inputs

Freeze contents, system_instruction, tools and generation settings before the first request. On continuation, resend them and the latest token. Do not append partial model text to contents, replace the prompt with “continue,” or change the task midway. The token carries generation state and a hash of the original prompt.

The following is control-flow pseudocode, not a tested API client. extract and final_usage represent helpers you must implement for the chosen SDK or REST representation.

original = immutable_copy(authorized_request)
latest_token = absent
for segment in bounded_segment_count:
    response = call_v1beta1(original, latest_token)
    save_redacted_segment_metadata(response)
    accumulate_parts(response)
    reason, token = extract(response)
    if reason == STOP:
        assemble_one_model_turn()
        finish()
    if reason == CONTINUATION and token exists:
        check_elapsed_time_and_total_budget()
        latest_token = token
        continue
    stop_for_explicit_handling(reason, token)

A thinking-only segment may contain parts: [{"text": ""}]. If it has CONTINUATION and a token, empty visible text alone is not failure. Conversely, missing token or an unexpected finish reason should not enter a blind retry loop.

MAX_TOKENS with a token means the requested generation cap was reached. Google's guide describes raising the cap to continue. That is a budget decision: record truncation and obtain the permitted higher cap rather than silently increasing it. Only after STOP combine accumulated parts into one model turn for later conversation history.

Usage counters are not interchangeable

In Python SDK generate_content and generate_content_stream, the final response or chunk's usage_metadata accumulates billed tokens across continuation requests. Do not sum repeated cumulative totals.

In a custom REST loop, usage is cumulative within each request. Sum each request's final prompt, cached-content, candidate and thought counters across requests. Do not add every streaming snapshot. Keep per-request counters and the final aggregate so accounting can be inspected.

Continuation re-prefills previous partial completions; cumulative prompt_token_count therefore grows. Use initial_prompt_token_count for the original context measurement, and postpone compaction until generation finishes with no continuation token. Rewriting history during the sequence breaks the preserved-request contract.

Implicit caching gives eligible back-to-back continuations a 95% discount on cached context, with a 6,144-token minimum and the documented 15–20 minute cache TTL. This is not a 95% discount on the whole job. Thinking, output and other billable work remain relevant; missed cache conditions can change cost. Explicit context caching is unsupported.

Remove old parameters deliberately

LOW, MEDIUM and HIGH are valid thinking levels. MEDIUM is the default for gemini-4-argon; the cyber-permissive variant defaults to HIGH. thinking_budget and MINIMAL return HTTP 400. Unsupported frequency_penalty, presence_penalty and candidate_count also return 400; remove them. Custom temperature, top_k and top_p values are ignored, so changing them is not a reliable tuning strategy.

Function responses must match the preceding function calls by ID, name and order. Keep tool execution and generation retries separate. A dropped stream is not permission to repeat an already executed payment, send or database write.

Test the stopping rules before a large job

Use proposed acceptance cases: a short response that ends with STOP; a thinking-only continuation; several segments with unchanged input; cap exhaustion; an unsupported SDK or endpoint; and a transport failure after a tool side effect. Check request fingerprints, termination, usage aggregation and the side-effect journal. These are suggested tests, not results from a live API run.

Save the migration checklist and redacted traces in Drive. An Agent Workspace can hold those files and authorized client code; protocol support still depends on the actual client you run. A Buda model selector or wrapper should not be assumed to implement this loop.

When can long decode stay off?

When one response comfortably finishes below the per-request cap. Summaries, classification and short-turn tool workflows are common examples. A large input also leaves less shared budget for output.

Why not send “continue”?

It starts a different conversation request instead of resuming the stored generation state. Use the token with the original request; put completed output into history only after termination.

What should a cost dashboard read?

The final cumulative Python SDK usage, or the sum of final per-request REST usage. Label the method and retain segment IDs so the same tokens are not counted twice.

Start with a small controlled request and prove termination and accounting before increasing the output cap. A larger generation allowance is useful only when the client can resume, stop and explain what it spent.