Gemini 4 Carbon Now Available: November 10 Access Update

If you already use another coding or reasoning model, you can now compare Carbon on real work: does it locate the cause of a difficult bug, identify reproducible issues in code review, or reach well-supported conclusions from dense documents?

If your application already calls several models through EvoLink, you can evaluate Carbon using the same API key and account balance, then add suitable tasks to your existing API workflow.

What changed between the October announcement and public availability?

Developers can start putting Carbon into their own request flows to test tool calling, output formats and existing business tasks. Individual users should first identify the Google product they want to use and check whether their account has access there.

What changes when Google's introductory period ends?

• Introductory cost: 0.1 × $2 + 0.01 × $10 = $0.30.
• From December 1, the same usage costs 0.1 × $4 + 0.01 × $20 = $0.60.

For long-term use, record the introductory bill alongside its equivalent at regular rates. That makes it easier to judge whether the project remains within budget after November.

Which tasks should you try with Carbon first?

That suggests three useful starting points for an evaluation.

For simple rewriting, routine extraction or frequently interactive features, compare quality, duration and cost against your existing model before switching. Deeper reasoning earns its extra spend when it improves the delivered result.

How should you evaluate Carbon through EvoLink after the public launch?

A useful evaluation has three steps:

1. Keep the inputs and acceptance rules fixed. Select a set of difficult bugs, review tasks or text-based document questions. Run Carbon and your current model with the same evidence and checks, and count accepted results and manual rework.
2. Measure the complete task. Record the model ID, thinking level, duration, token usage and retries. Calculate the cost per accepted result across all requests, including thinking tokens, rather than comparing the visible answer or a single token rate.
3. Move one stage at a time. Keep Carbon for tasks where the measured result justifies the time and spend. Retain the existing model for other requests and test a fallback path before increasing traffic. EvoLink provides the shared API access; your application defines task routing and acceptance.

curl "https://direct.evolink.ai/v1beta/models/gemini-4-carbon:generateContent" \
  -H "Authorization: Bearer $EVOLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -X POST \
  -d '{
    "contents": [{
      "role": "user",
      "parts": [{
        "text": "Review this retry policy: a payment request is retried after a timeout without an idempotency key. Explain the duplicate-charge risk and propose a minimal validation plan."
      }]
    }],
    "generationConfig": {
      "thinkingConfig": { "thinkingLevel": "medium" },
      "maxOutputTokens": 32768
    }
  }'

How do you make your first request to Google's API?

curl "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -X POST \
  -d '{
    "model": "gemini-4-carbon",
    "input": "Review this retry policy: a payment request is retried after a timeout without an idempotency key. Explain the duplicate-charge risk and propose a minimal validation plan.",
    "generation_config": {
      "thinking_level": "medium"
    }
  }'

Alongside the first answer, save request duration, usage data and task acceptance results. Add timeouts, retry handling, spending limits and failure handling before putting it into a production workflow.

How should you set thinking effort and long output?

Output length has separate constraints:

• Input, thinking and output share a 1,048,576-token context window.
• The default synchronous response limit is 65,536 tokens.
• Longer output requires the appropriate long-decode execution mode. For example, use background execution in the Interactions API and raise max_output_tokens; available room still depends on the shared context limit.

What does Antigravity's /swarm add?

This provides a concrete pattern for combining models: Carbon handles architecture, difficult investigations and independent review; faster models carry out routine implementation; verification checks the changes. Google also warns that parallel multi-agent work consumes quota faster than a standard chat.

For an existing production application, a manageable starting point is one clearly defined stage: review high-risk changes, for example, or handle failure cases your current model cannot solve. Record what Carbon discovers, how much rework it prevents, and the time and cost of the whole workflow before expanding its role.

Frequently asked questions

Is Gemini 4 Carbon generally available or still in preview?

Do I need Google AI Ultra to call the Carbon API?

Why can my account not see Carbon yet?

Can Carbon generate images, speech or video directly?

Should I replace all my existing models with Carbon immediately?

Start with one stage in complex debugging, independent review or dense document analysis. Alongside quality, record the whole task's cost, waiting time and rework, then decide which requests should stay with your current model and which should go to Carbon.