A long answer from Gemini 4 Argon can now cross several network requests while appearing to an agent application as one response. The Pydantic AI 2.56.0 release, published early October 14 in Paris, adapts the framework in pydantic/pydantic-ai to Google’s continuation mechanism. It preserves the pieces of the answer and distinguishes how much work was billed from how much context the model occupies.
The timing matters. Google announced broad Argon availability on October 13, including its paid API, after the September 30 introduction began with selected cyber defenders. Its promise of longer, more demanding work now has a released integration that ordinary framework users can inspect.
For someone building an evaluator or an agent that tackles a difficult specification, the useful change is room to continue one response past a transport limit. It is not a reason to make every answer longer. The public code explains how the response travels; it cannot establish that extra generation makes a difficult answer correct.
A larger allowance still needs a handoff
Google’s initial announcement described an expansion from 64K to one million output tokens. The current operational guide gives the precise boundary: 1,048,576 tokens shared by input, thinking and output. A large prompt consumes room that would otherwise be available for generation. This clarifies the usable budget; it does not establish that an earlier implemented entitlement was withdrawn.
The guide distinguishes the limits along the route. Streaming calls and current SDK calls default to 65,536 output tokens; direct non-streaming REST requests have a 32,768-token limit per request. Continuing beyond those boundaries requires the appropriate client support and a larger overall output setting. Merely changing the model name leaves the ordinary limit in place.
Google’s Python SDK implementation does the handoff. When the service returns a continuation token, the SDK repeats the original request with that token. It continues until the response finishes or cannot continue, then combines the pieces. The application does not have to send a conversational “please continue” prompt for each segment.
That ownership is important: Pydantic did not invent long decoding. It is making Google’s existing mechanism fit the contract its own users already rely on. The adapter keeps the boundaries between response parts as requests change, including during streaming, rather than flattening away the metadata attached to an earlier part.
One response needs two token counts
A subtler change appears in the counters. Each continuation includes work generated so far in the model’s input. Adding the input usage from every request therefore counts some material repeatedly. That is meaningful for usage accounting, but it is a poor measure of the space occupied by the conversation.
The distinction is visible in a small compaction test. It models a first request with 50,000 input tokens, a continuation with 50,500, and 1,000 output tokens overall. The accumulated input usage is 100,500, but the context estimate is 51,000: the original input plus the generated output.
Pydantic’s new context-size helper preserves that distinction for context checks and compaction, which shortens a conversation when it approaches its space limit. Without it, repeated input accounting could make a conversation appear fuller than it is and cause the framework to shorten it prematurely. Usage totals remain available for accounting; the context estimate answers a different question.
The long-decode suite also includes upstream recordings of counting tasks that cross a request boundary, alongside scripted continuation and failure cases. The streamed recording reports 72,897 output tokens from an initial prompt of 110 tokens. That is concrete evidence of the integration’s intended shape, not a benchmark of scientific or coding judgment. We inspected the code, fixtures and release ancestry; we did not execute the suite or make an authenticated Argon request.
Choose who carries the unfinished response
The framework still sees one logical model request. Its release documentation explains the practical consequences: request-count limits count one, and non-streaming token-limit checks happen after the combined request completes. The explicit max_tokens setting bounds the generation. Google providers now create clients with a twenty-minute read timeout for each request; an outer job deadline must still allow for the complete sequence.
There is also a choice of execution model. Google’s Interactions API offers background execution in which its servers manage the continuation steps. The client polls or streams the interaction and joins its output steps. Google recommends that route for new projects. Pydantic’s integration serves applications using the GenerateContent path; developers need not adopt a framework solely to obtain long decoding.
Interruption remains part of that choice. In Pydantic’s non-streaming path, a later request failure can leave the caller without earlier output that has already incurred usage. Streaming can preserve emitted output and the completed requests’ usage as an interrupted response. These are different recovery contracts for the same longer generation.
The next useful comparison is a fixed difficult task run with and without continuation, using the same acceptance criteria and recording total usage and elapsed time. The released plumbing now makes that experiment practical inside Pydantic. Its value will be established by completed work that the shorter run could not deliver—not by the size of the allowance alone.