After Google opened Gemini 4 Neon on November 18, how should Interactions JSON set thinking_level, background, and usage when the guide lists xhigh and Antigravity returns 400?

thinking_level sets the depth. background and store set the long decode. The 18 November API guide lists xhigh. Antigravity CLI reports from 18–19 November return 400 for that level.

The model id does not set the thinking depth or the long decode. On 18 November 2026 Google opened Gemini 4 Neon. The id is gemini-4-neon. On the Interactions API, generation_config.thinking_level takes low, medium, high, or xhigh. The default is high. thinking_budget and minimal return HTTP 400. A server-managed long decode sets background to true and store to true, and sets max_output_tokens above 65536 when the answer must pass one foreground segment.

This page is dated 19 November 2026 from the 18 November launch post, the developer guide last updated 18 November 2026 UTC, and Antigravity posts on the Google AI forum from 18–19 November. Yesterday’s note covered GPT-6.2 Astra and Sol. A request that still follows the Gemini 4 Carbon page on this site needs a new default and a harder 400 on thinking_budget.

What opened on 18 November

The launch post prices Neon at $3 per million input tokens, $0.15 per million cached input tokens, and $15 per million output tokens. The cached rate is the 95 percent discount on input. The API window is one budget of 1,048,576 tokens shared by input and output. Output in that budget includes thinking, function calls, and the visible answer. Antigravity’s product post caps that app at 512K tokens. Read the cap from the surface you call.

Price, per million tokensUSD
Input$3
Cached input$0.15
Output, including thinking tokens$15

The launch post opens the paid Gemini API in AI Studio and Android Studio, Gemini for business, and Gemini 4 Neon for paid Google AI Pro and Ultra subscribers in Antigravity and the Gemini app. The Cloud guide adds locations global, us, and eu, and describes Agent Platform access for verified enterprise customers in select regions. Antigravity’s plan note leaves Free and Google AI Plus out. A Pro trial is limited to eligible premium devices. Enterprise gets Neon through Gemini for business. That same note leaves Orchestrator (Neon) off the enterprise row.

Google reports an Artificial Analysis Intelligence Index of 61 at xhigh, third overall, and about 32 percent lower cost per task than Carbon at the default high level. Those figures are Google’s. The migration note keeps everyday agent loops on gemini-4-hydrogen, bulk classification on gemini-3.5-flash-lite, and Fairwind cybersecurity testing on gemini-4-carbon-cyber-permissive. A Neon cyber rollout for that program is a separate model path. thinking_level on gemini-4-neon stays low, medium, high, or xhigh.

thinking_level, and the 400 for xhigh

POST the Interactions body with the lowercase level. GenerateContent REST spells the same control as generationConfig.thinkingConfig.thinkingLevel and uses the uppercase enum LOW, MEDIUM, HIGH, or XHIGH. This Interactions body is the default case.

{
  "model": "gemini-4-neon",
  "input": "Review the retry path and name the lock that can deadlock.",
  "generation_config": {
    "thinking_level": "high"
  }
}
thinking_levelWhat the Neon guide assigns it
xhigh / XHIGHProofs, scientific analysis, and the hardest multi-file engineering
high / HIGHDefault. Multi-step tool loops, code, refactors, dense multimodal work
medium / MEDIUMGeneral coding, tools, document questions, video, when latency matters
low / LOWClassification, routing, summaries, structured metadata

Leave the field out and the server uses high. Carbon, Argon, and gemini-3.8-flash defaulted to medium. A migration that wants that latency sends medium on purpose. thinking_budget returns HTTP 400. minimal and MINIMAL return HTTP 400. max_output_tokens above 1,048,576 returns HTTP 400.

Antigravity’s forum post selects the level in the CLI with --model gemini-4-neon-xhigh or --effort xhigh. That model string belongs to Antigravity. The Interactions body keeps model at gemini-4-neon and puts the level in thinking_level. Developers on the same forum reported that CLI 1.5.11 returns INVALID_ARGUMENT 400, Thinking level is unsupported: THINKING_LEVEL_XHIGH, for gemini-4-neon-xhigh, including when agy models lists the id. The API guide dated 18 November still lists xhigh. When a surface returns that 400, send high, the documented default, and keep that same level on every continuation segment.

background, continuation_token, and status

One foreground segment stops at 65,536 output tokens, for a stream and for a single response. Output in that cap includes thinking, function calls, and the visible answer. Omit max_output_tokens and the budget is the same 65,536. A longer turn sets max_output_tokens above 65536, up to 1,048,576 minus the input tokens. continuation_token lives on v1beta1. The v1 path has no continuation token.

On Interactions, status requires_continuation means the segment hit 65,536 before max_output_tokens, and the body carries continuation_token. incomplete means the max_output_tokens budget is spent. Sending that token again with the same cap returns HTTP 400, and the guide’s error text is max_output_tokens has already been exhausted. Raise the cap on the next request. completed clears the token. This background body is the server-managed loop. It asks for xhigh. A surface that rejects xhigh uses high in both the first call and every continuation.

{
  "model": "gemini-4-neon",
  "input": "Write a complete proof of the prime number theorem.",
  "background": true,
  "store": true,
  "generation_config": {
    "thinking_level": "xhigh",
    "max_output_tokens": 262144
  }
}

Poll while status is queued or in_progress. The guide’s poll list also names completed, incomplete, failed, and cancelled. background: true requires store: true. A stored continuation sends previous_interaction_id of the segment that issued the token, sends continuation_token, and omits input. Keep thinking_level identical to the segment that issued the token.

{
  "model": "gemini-4-neon",
  "store": true,
  "previous_interaction_id": "SEGMENT_1_ID",
  "continuation_token": "CONTINUATION_TOKEN",
  "generation_config": {
    "max_output_tokens": 262144,
    "thinking_level": "xhigh"
  }
}

A stateless continuation sets store to false, resends the original input, sends continuation_token, and omits previous_interaction_id. A loop can move from store: true to store: false. The other direction has no stored parent for previous_interaction_id. A new user turn, meaning previous_interaction_id plus new input and no continuation_token, returns HTTP 400 while the segment is still requires_continuation or incomplete. Finish to completed, or start the next turn from the latest completed id. Changing model, system_instruction, or tools on a continuation segment returns HTTP 400. The known-issue note says a mid-loop edit to thinking_level passes validation, and tells you to leave the level and the built-in tools google_search, code_execution, and url_context unchanged for the whole loop.

GenerateContent reports finish_reason CONTINUATION and a candidate continuationToken. The next call resends the original contents and puts continuationToken at the top level. The level enum is uppercase.

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "Write a complete proof of the prime number theorem."
        }
      ]
    }
  ],
  "continuationToken": "CONTINUATION_TOKEN",
  "generationConfig": {
    "maxOutputTokens": 131072,
    "thinkingConfig": {
      "thinkingLevel": "XHIGH"
    }
  }
}

Each segment has a 20 minute limit. Streaming checkpoints start at 65,536 output tokens and then every 5,000 tokens. Automatic continuation on Interactions needs Python google-genai >= 2.34.0, JavaScript @google/genai >= 2.32.0, Go >= 1.77.0, or Java >= 1.80.0. Automatic continuation on GenerateContent needs Python >= 2.30.1. A handoff that passes previous_interaction_id to gemini-4-hydrogen runs a worker turn. The published Neon sample sends thinking_level again on the next Neon turn. The server drops the previous model’s signatures on that handoff.

Fields the request drops

temperature, top_p, and top_k are ignored. frequency_penalty, presence_penalty, and candidate_count greater than 1 return HTTP 400. candidateCount stays 1. Remove cached_content. Implicit caching starts at 4,096 tokens, with durable caching on by default, so the static prefix goes first. A history payload ends on a user turn. Prefilled model turns are rejected.

Word, PowerPoint, Excel, and OpenDocument files (docx, pptx, xlsx, odt, odp, ods, plus older doc, ppt, and xls) go inline or by a gs:// URI, including inside a function response. Uploaded video defaults to media_processing static. agentic is the opt-in value.

thoughtSignature on the first functionCall

On a parallel tool turn, the signature sits on the first functionCall part. The developer guide calls that value thought_signature. The GenerateContent reference spells the JSON field thoughtSignature. The second call in the same model turn omits it.

{
  "role": "model",
  "parts": [
    {
      "functionCall": {
        "name": "read_file",
        "args": {}
      },
      "thoughtSignature": "SIG_FROM_MODEL"
    },
    {
      "functionCall": {
        "name": "list_dir",
        "args": {}
      }
    }
  ]
}

Omitting thoughtSignature on the first functionCall of the active turn returns HTTP 400. Copying it onto a sibling functionCall returns HTTP 400. Splitting the calls and the responses across alternating turns returns HTTP 400. Keep every earlier signature on its original part, including final text parts. Stripping those values can finish as MALFORMED_FUNCTION_CALL. The placeholder skip_thought_signature_validator drops the reasoning context. Match each function response to the call id, name, and order.

usage at $3, $0.15, and $15

Replace the zeros with the fields on the response. The shape below is the Interactions object the guide names. It is a field list, with zeros standing in until the response arrives.

{
  "status": "completed",
  "usage": {
    "initial_input_tokens": 0,
    "total_input_tokens": 0,
    "total_cached_tokens": 0,
    "total_output_tokens": 0,
    "total_thought_tokens": 0,
    "total_tokens": 0
  }
}

Uncached input is total_input_tokens minus total_cached_tokens, at $3 per million. total_cached_tokens is $0.15 per million. total_output_tokens plus total_thought_tokens is $15 per million. Leave total_tokens out of that sum. On a summed background response, initial_input_tokens is the first prompt and already sits inside total_input_tokens. Leave it out of the bill a second time. Use initial_input_tokens when you decide to compact. total_input_tokens grows across continuation segments because each segment re-prefills the prompt and the tokens already decoded.

Automatic continuation and background: true already sum usage across segments. A custom loop, and a streamed interaction.completed event, report one segment’s delta, so add those deltas yourself. The GenerateContent SDK accumulates usage_metadata and keeps initial_prompt_token_count. A custom REST loop adds prompt_token_count, cached_content_token_count, candidates_token_count, and thoughts_token_count across segments. Each finished segment is billed when that segment ends, including when a later segment fails or is cancelled. Grounding queries bill separately, and the guide counts tool instructions and function declarations as processed tokens.

JSON to verify before launch

  1. The body has gemini-4-neon. Interactions thinking_level is low, medium, high, or xhigh. GenerateContent uses thinkingLevel in uppercase. The body has no thinking_budget, minimal, temperature, top_p, top_k, frequency_penalty, presence_penalty, candidate_count, or cached_content.
  2. A call past 65,536 tokens sets max_output_tokens above 65536 and uses v1beta1. background: true arrives with store: true. Continuation segments keep model, system_instruction, tools, and thinking_level.
  3. An Antigravity id such as gemini-4-neon-xhigh stays in that CLI. The API model field stays gemini-4-neon. A 400 that says THINKING_LEVEL_XHIGH is followed by high on that surface.
  4. Parallel tool parts keep thoughtSignature on the first functionCall only.
  5. The bill uses uncached input, cached input, output tokens, and thought tokens. It leaves out total_tokens and a second add of initial_input_tokens.

Check the JSON locally with the JSON validator, JSONPath ($.usage.total_thought_tokens), and JSON Diff against the previous request. Nothing is uploaded.

FAQ

Is the default still medium, as on Carbon?

Neon’s default is high. Send medium when you want the latency Carbon, Argon, and gemini-3.8-flash used as their default.

Can I send thinking_level xhigh?

The 18 November API guide lists xhigh on Interactions and XHIGH on GenerateContent. Antigravity CLI reports from 18–19 November return HTTP 400 Thinking level is unsupported: THINKING_LEVEL_XHIGH for the model id gemini-4-neon-xhigh. The API body uses model gemini-4-neon plus thinking_level. When that 400 comes back, send high.

Does background work with store false?

The guide requires store true together with background true. A foreground stateless loop can set store false, resend the original input, and pass continuation_token.

Should the bill add total_tokens?

Leave total_tokens out. Price uncached input at $3, total_cached_tokens at $0.15, and total_output_tokens plus total_thought_tokens at $15, per million. initial_input_tokens is already inside the summed input count.

Where does the parallel signature go?

On the first functionCall part only, in the field thoughtSignature. Sibling functionCall parts in that same model turn omit it. Copying the signature onto a sibling returns HTTP 400.

Is Antigravity’s window 1,048,576 tokens?

The API guide’s unified window is 1,048,576 tokens. Antigravity’s 18 November post says up to 512K tokens in that product.

Summary

Neon, opened 18 November 2026, bills $3, $0.15, and $15, and defaults thinking to high. Send gemini-4-neon with thinking_level at low, medium, high, or xhigh. Pair background: true with store: true and a max_output_tokens above 65536 when one segment is too small. Keep thoughtSignature on the first parallel functionCall. When Antigravity returns 400 for THINKING_LEVEL_XHIGH, send high on that surface and keep the API model id unsuffixed.