GPT-6.1 Sol Is Live, at GPT-6 Sol's Price

openai/gpt-6.1-sol is live on BlockRun as of today, October 9, on Base. It is OpenAI's September 29 refresh of the GPT-6 Sol tier, with a knowledge cutoff of April 30, 2026, at the same token price as the model it refreshes.

It takes images and does reasoning. There is no API key and no subscription: every call is quoted in dollars before it runs and paid per call in USDC.

What it is for

Sol is the middle of the GPT-6 lineup, below the Astra flagship ($10 / $50) and above Luna ($0.10 / $0.50). OpenAI positions it for complex coding and agentic workflows, and that is where it earns its price: multi-file changes, agents that plan and call tools over many steps, long reviews where a 1M context lets the whole codebase or document set sit in the prompt.

At $2 / $10 it costs a fifth of Astra. For most coding agents that is the tier to try first, and only escalate to Astra for the steps the cheaper model keeps getting wrong.

What 6.1 adds over GPT-6 Sol is knowledge. Its cutoff is April 30, 2026, so it knows about libraries, APIs and events that the earlier Sol does not, which matters most for coding against recently released SDKs and for questions about the last year.

What it costs

The token price is identical to GPT-6 Sol: $2 in, $10 out per 1M. Two things change the per-call bill.

The 272K line reprices the whole request. Once a prompt passes 272K input tokens, OpenAI bills the entire request at 2x input and 1.5x output, which is $4 / $15 here. Not just the tokens above the line: a 300K-token prompt costs $4 per 1M for all 300K. BlockRun bills it the same way, because that is how it is billed upstream. If your agent accumulates context over a long run, keeping each prompt under 272K is the largest saving available.

Reasoning tokens are output tokens. They bill at the $10 rate and count against the same output allowance as the answer. A small max_tokens with a high effort can end with finish_reason: "length" before any visible text, so give reasoning-heavy calls room.

OpenAI's cached-input rate for 6.1 is $0.10 per 1M, half of GPT-6 Sol's $0.20, and it is published with the model's other rates in /v1/models. Be clear about what that means on BlockRun today, though: a pay-per-call request is quoted before it runs, when nobody knows how much of the prompt will hit the cache, and OpenAI models settle at the standard input rate. On a pay-per-call bill the lower cache rate is not yet a saving.

Same price, different request rules

GPT-6.1 Sol shares a price with GPT-6 Sol but not its request contract. We measured every rule on 6.1 itself before listing it, rather than copying them from the model next to it, because the two differ in exactly the places where a wrong copy costs a caller money.

• reasoning_effort starts at low. The model rejects "none" and "minimal". On a gateway that settles payment before the upstream call, an unhandled "none" would be a paid call that can only fail, so the gateway raises both to "low", the least the model accepts.
• Tool calls work as usual. OpenAI does not serve function tools on chat completions for this model at any effort. Send tools to /v1/chat/completions the normal way; the gateway serves the call through OpenAI's Responses API at the effort you asked for and hands back an ordinary chat-completions response. Nothing changes on your side.
• "max" effort depends on the call. OpenAI's model page lists it, and it is accepted on tool calls, which are served through the Responses API. On plain chat it is rejected, so the gateway lowers it to "xhigh" there.
• The rest matches the GPT-6 family. max_tokens is accepted and sent as max_completion_tokens, and sampling parameters the model refuses, such as temperature other than 1 and top_p, are dropped rather than failing the call.

If it is unavailable

GPT-6.1 Sol falls back to GPT-6 Sol: same maker, same tier, same $2 / $10, same 1M context. If the upstream for 6.1 fails, the request is served by GPT-6 Sol at the price you were quoted. A rescue is never a smaller model standing in for the one you chose, and never costs more than the request you sent.

GPT-6.1 Sol or GPT-6 Sol?

The token price is the same, so the choice comes down to two rules.

Pick GPT-6.1 Sol when fresher knowledge matters: code against libraries released this year, questions about recent events, anything where a cutoff a few months later changes the answer.

Stay on GPT-6 Sol for two kinds of work. It accepts reasoning_effort: "none", including on tool calls, so an agent that makes many simple tool calls can skip reasoning entirely and pay no reasoning tokens; 6.1's floor is low. And GPT-6 Sol accepts OpenAI's Flex tier, at half the standard rate, for batch work that can wait. We asked for Flex on 6.1 before listing it and OpenAI answered that it was unavailable, so it is not offered on 6.1 yet. We will turn it on once a Flex request is actually served.

Switching between the two is a one-word change to model.

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("openai/gpt-6.1-sol", "Refactor this module and explain each change."))

# Keep reasoning short on a simple call
print(client.chat("openai/gpt-6.1-sol", "Summarise this diff in three bullets.",
                  reasoning_effort="low"))

Or over plain HTTP, where the first response is a 402 carrying the exact price:

curl https://blockrun.ai/api/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "X-PAYMENT: $PAYMENT_HEADER" \
  -d '{
    "model": "openai/gpt-6.1-sol",
    "messages": [{"role": "user", "content": "Find the bug in this function."}]
  }'

Sign the payment, retry, and the completion comes back. No account, no key: the wallet is the identity.

Try it

The full catalog, with live prices, is at blockrun.ai/models, and the docs cover each model's request rules. Send a request, and the price comes back before the work does.