Gemini 4 Carbon Is Live, at Gemini 4 Argon's Price

google/gemini-4-carbon is live on BlockRun as of today, November 11, on Base and on Solana. It is the most capable model Google has shipped, built for the problems where being right matters more than being fast: complex software engineering, deep math and science, answers that have to hold up to a fact check, and agents that run on their own for many steps.

It thinks, it reads images, and it calls tools. Send it through the same OpenAI-compatible endpoint as every other model, with no Google account and no key of your own.

What it is for

Carbon now sits at the top of Google's lineup. Google positions it as its strongest reasoner, and that is the work to send it:

• Complex software engineering. Multi-file changes, hard bugs, and design decisions that need the whole system in view. A 1M-token window holds a whole codebase in the prompt.
• Deep math and science. Thinking is on by default, so hard problems get worked through before the model commits to an answer.
• High factual accuracy. Research, analysis and reports where a confident wrong answer costs more than the call.
• Autonomous multi-step agents. Plan, call a tool, read the result, call the next one, and keep the thread across a long session.

Carbon or Argon

Both are Gemini 4, and both cost the same: $2 in, $10 out. The difference is how they spend it.

Argon is the efficient Gemini 4. It answers faster and uses fewer tokens per turn. Thinking tokens bill as output, so at the same rate a turn on Argon usually costs less than the same turn on Carbon. Pick Argon for high-volume agent loops, tool-heavy pipelines, and anything a user is waiting on.

Carbon is the one to call when the answer has to be right. Pick it for the hard step: the architecture call, the proof, the bug that three cheaper attempts did not fix, the agent run that cannot afford to wander.

A pattern that works well: run the loop on Argon, and escalate the hard turns to Carbon. They share a model family, a context window and a price sheet, so switching is a one-word change in the model field.

Agent loops work on day one

Gemini 4 requires a thought signature on every earlier tool call in the history, an opaque token that ties the call to the reasoning that produced it. The OpenAI chat format has nowhere to keep it, so an unadapted OpenAI-format agent gets an HTTP 400 on its second step.

BlockRun handles that for every Gemini 4 model, Carbon included. Before listing Carbon we ran a real completion, then a real two-round tool loop through both our streaming and non-streaming paths. Carbon answered itself, with the correct next tool call and finish_reason: "tool_calls", and no fallback stepped in.

So nothing changes on your side. Point your existing agent at google/gemini-4-carbon and the loop runs.

What it costs

$2 in, $10 out per 1M tokens, which is Google's own rate. We pass LLM tokens through at cost, plus a flat $0.001 per call, so the model price you pay is the price Google charges.

That rate runs through November 30, 2026. From December 1, Google's price for Carbon is $4 / $20, with cached input at $0.20, and ours moves with it on the same day. Argon moves on the same schedule. If you have a large job for Google's strongest model, run it before December.

Two more things move the per-call bill:

• Thinking tokens are output tokens. They bill at the $10 rate and count against the same 65,536-token output allowance as the answer. Give reasoning-heavy calls room in max_tokens.
• There is no long-context surcharge. A 900K-token prompt bills at the same $2 per 1M as a 9K one.

If it is unavailable

Carbon falls back to google/gemini-4-argon: same maker, same price, the same 1M context, and the same thinking, vision and tool support. A rescue is never a smaller model standing in for the one you chose, and never costs more than the request you sent.

Calling it

The chat endpoint is OpenAI-compatible, and the SDK handles the payment:

from blockrun_llm import LLMClient

client = LLMClient()  # wallet from BLOCKRUN_WALLET_KEY or ~/.blockrun/.session
print(client.chat("google/gemini-4-carbon", "Find the race condition in this worker pool and prove the fix."))

On Solana, the same call with the Solana client, through the sol.blockrun.ai gateway:

from blockrun_llm import SolanaLLMClient

client = SolanaLLMClient()  # wallet from SOLANA_WALLET_KEY; pays USDC on Solana
print(client.chat("google/gemini-4-carbon", "Derive the closed form, then check it numerically."))

Or call the endpoint directly. Tool calls use the standard OpenAI shape, and the history goes back with no signatures:

curl https://blockrun.ai/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "X-PAYMENT: $PAYMENT_HEADER" \
  -d '{
    "model": "google/gemini-4-carbon",
    "tools": [{"type": "function", "function": {
      "name": "bash", "description": "run a shell command",
      "parameters": {"type": "object", "properties": {"command": {"type": "string"}}, "required": ["command"]}
    }}],
    "messages": [
      {"role": "user", "content": "Run the tests, then fix whatever fails."},
      {"role": "assistant", "content": "", "tool_calls": [{"id": "c1", "type": "function",
        "function": {"name": "bash", "arguments": "{\"command\":\"pytest -q\"}"}}]},
      {"role": "tool", "tool_call_id": "c1", "content": "1 failed, 41 passed"}
    ]
  }'

The first response is a 402 carrying the exact price. Sign it, retry, and the next tool call comes back. Teams can use an API key with a card or invoice instead, and an autonomous agent can pay per call from its own wallet in USDC on Base or Solana over x402, with no account at all.

Try it

The full catalog, with live prices, is at blockrun.ai/models, and the docs cover each model's request rules. Give Carbon the task your agent keeps getting wrong, and the price comes back before the work does.