GPT-6.1 Sol on GMI Cloud took one feature request through read, write, test, fix and pull request on its own: thirteen turns, 23 of 23 tests green, 46 cents, against $2.40 for the same tokens on GPT-6 Astra.
2026年11月10日

I gave GPT-6.1 Sol on GMI Cloud one feature request and did not touch the keyboard again. It read a small real repository, wrote the code and the tests, ran the suite, watched tests go red, read the failing assertions, fixed the CLI and its own test, ran the suite again to 23 of 23 green, and wrote the pull request for only 46 cents. The same tokens on GPT-6 Astra, on the same endpoint, would have cost $2.40. Writing the code was the easy part. What it did when the code was wrong was pivotal.
GPT-6.1 Sol is the middle of OpenAI's GPT-6 family: Astra is the flagship, Luna is the small model, and Sol is the one OpenAI positions for agentic coding, computer use and professional work that you run many times a day. It shipped on September 29, 2026, one week after GPT-6 Sol, and the headline change from 6 to 6.1 is what happens inside a loop: cached input fell from $0.20 to $0.10 per million tokens, and the agent benchmarks moved up.
GPT-6.1 Sol on GMI Cloud | |
|---|---|
Model id | openai/gpt-6.1-sol |
Context | 1,050,000 tokens in, up to 128,000 out |
Input | Text and images |
Reasoning effort | low, medium, high, xhigh and max on the API; the demo exposes low, medium and high (no none or minimal) |
List price | $2 in, $10 out per 1M tokens; cached input $0.10 |
Over 272,000 prompt tokens | $4 in, $15 out, applied to the whole request |
GPT-6 Astra, same endpoint | $10 in, $50 out; cached input $1 |
The benchmark story is about cost per task as much as score. On DeepSWE v1.1, which drops an agent into real repositories with long-horizon tasks, Sol scores 75.2% at high effort, about the same as Astra at the same setting (73.2% in OpenAI's chart), for $0.65 a task against $3.92. On OSWorld 2.0, the computer-use benchmark, Astra keeps a two-point lead. Where Astra clearly wins is Terminal-Bench Science, by eleven points, and OpenAI itself says the flagship is for the hardest scientific research tasks. That is the line I use to decide which model gets a job.
OpenAI's launch charts for GPT-6.1 Sol, September 29, 2026, at the high and max settings, as read by Kingy AI and DataCamp
The launch charts report Sol's DeepSWE result at high effort, so the demo's effort toggle is set to high before the run starts, and that is the setting I use for coding agents now.
The repository. shortly is a URL shortener in Python: a library, a JSON file store, a command line, nine files, about 280 lines, thirteen tests, all green. Small enough that every diff fits on a screen, real enough that a feature has to touch the library, the CLI and the tests at once.
The ticket. The whole brief, as pasted into the page:
Add link expiry. shorten() takes an optional ttl in seconds. An expired code resolves to None and is removed from the store the next time it is touched. The CLI gets --ttl on add, and ls shows the time left for links that expire while leaving other lines exactly as they are. Add tests and keep the suite green.
No function tools, on purpose. GPT-6.1 Sol takes tool calls only through the Responses API, so on the chat-completions endpoint the page is the runtime and the model drives it with four text commands: @@read <path>, @@write <path> ... @@end, @@run tests, and @@done <PR title and body> ... @@end. Several commands can ride in one reply and run in order. Each reply is one streamed completion carrying the full transcript; the runtime's output comes back as the next user message. Tests really execute: the page copies the working tree to a temp directory and runs unittest discover with a 30-second timeout. The page refuses @@done unless the last green run matches the current files.
Read. Sol got the file list and the five commands. No planning stage. It read five files in one turn and left a one-line note before writing anything, and the note settled the design: expiry would be a timestamp stored on each record, with expired links removed lazily the next time they are touched. That is the decision that keeps this feature small, and it was made before a line of code was written.
Write. Three files landed in the next turn, with the diff opening on the right as each one was written. The Sol cost tile barely moved while they did, because every turn re-sends the transcript and the part Sol had already seen was served from cache at ten cents per million. The Astra tile, pricing the identical tokens at list, climbed five times faster.
Test, and the part the title is about. Sol ran the suite on its own and it went red: two failing tests after the first write. It read the assertions, said what it had got wrong, rewrote the CLI, fixed its own test, and ran the suite again. Green, with the existing tests untouched. Read the failure, fix the cause, verify. That loop is what the DeepSWE number measures, and here it cost a few cents.
Ship. The page only lets a pull request through on a green suite. The PR Sol wrote has a short title, "Add TTL-based link expiry", the approach, the files touched, the new tests, and the ls fix described in its own words. It reads like a PR from a teammate, and I would approve it after reading the diff.
The final board. Thirteen turns, seven files, 23 of 23 tests green, 483 seconds. $0.4564 on Sol. $2.397 for the same tokens on Astra.
The run cost 46 cents on Sol. The same tokens on Astra, at list price on the same endpoint, would have cost $2.40, a 5.3 times gap. The ratio is above the 5 times you get from the headline prices because two-thirds of the input was served from cache, and the cache discount is deeper on Sol.
Tokens | Sol rate per 1M | Sol | Astra rate per 1M | Astra | |
|---|---|---|---|---|---|
Input, uncached | 102,668 | $2.00 | $0.205 | $10.00 | $1.027 |
Input, cached | 230,144 | $0.10 | $0.023 | $1.00 | $0.230 |
Output, including reasoning | 22,806 | $10.00 | $0.228 | $50.00 | $1.140 |
Run | 355,618 | $0.456 | $2.397 |
The cache is why the Sol tile barely moved during the write stage. Every turn re-sends the whole transcript, and by turn thirteen the model had seen 332,812 input tokens in total, but only 102,668 of them were new. At ten cents per million, the repeats cost two cents for the entire run. Output is the other half of the bill: 22,806 tokens, most of them code and reasoning, at $10 per million.
Time was 483 seconds, eight minutes for thirteen turns, each one a full streamed completion with the suite run on my machine in between. The page prices every uncached input token at the $2 rate; the GMI catalog also lists a separate cache-write rate, so a bill from the console can differ slightly from the tile. Every number here is a list price from the GMI Cloud inference engine on a Tier 5 account; cost and wait times vary with account tier, queue load and provider capacity, and a dedicated endpoint runs on reserved capacity without the queue.
The benchmark figures are OpenAI's. The DeepSWE, OSWorld, GDP.pdf and Terminal-Bench Science numbers come from OpenAI's launch charts, with the per-effort Astra figures as third parties read them off those charts. They are why I tried Sol on a ticket, not proof of anything. The run above is one run, on one small repository.
Tool calls need the Responses API. On the chat-completions endpoint, GPT-6.1 Sol accepts no function tools, which is why the demo uses a text command protocol. If your agent already uses function calling on chat completions, plan the migration before you switch models.
Mind the request shape. Use max_completion_tokens, not max_tokens. Leave out temperature; reasoning models refuse it. Pick an effort level from low, medium, high, xhigh and max, since none and minimal are gone on 6.1.
The tests run on your machine. The page executes the model's code in a temp directory with a timeout. That is fine for a local demo and not something to expose on the public internet.
One streamed call is all the demo does, thirteen times. Set reasoning_effort to high, use max_completion_tokens rather than max_tokens, leave out temperature, and ask for usage in the final chunk so you can price the run:
curl https://api.gmi-serving.com/v1/chat/completions \
-H "Authorization: Bearer $GMI_API_KEY" -H "Content-Type: application/json" \
-d '{
"model": "openai/gpt-6.1-sol",
"reasoning_effort": "high",
"max_completion_tokens": 24000,
"stream": true,
"stream_options": {"include_usage": true},
"messages": [
{"role": "system", "content": "You are a senior engineer shipping one feature in a small Python repository. Reply with @@read <path>, @@write <path> ... @@end, @@run tests, or @@done <PR title and body> ... @@end. Always run the tests after writing. Only @@done on a green suite."},
{"role": "user", "content": "Feature request: add link expiry with a --ttl flag. Repository files: README.md, shortly/__init__.py, shortly/core.py, shortly/cli.py, shortly/store.py, tests/test_core.py, tests/test_cli.py. The suite is green right now (13 tests)."}
]
}'Swap the model id for openai/gpt-6-astra to see the same loop at flagship price.
A model that writes plausible code is common now. What I had been paying flagship prices for was a model that reads a failing assertion, says what it got wrong, fixes the cause and verifies, without a person in the loop. Sol did that for 46 cents. Before you pick a model for your next agent, price what happens on your bill when the first draft is wrong.
Ready to build? Get Started
Grace Deng
DevRel @ GMI Cloud
GMI Cloud helps you architect, deploy, optimize, and scale your AI strategies
