• 運算
  • 客戶
  • 價格
登入
More Blog Posts
XDiscordLinkedInYouTube

產品

  • GPU
  • MaaS
  • Studio

開發者

  • 模型總覽
  • 技術文件
  • 詞彙表

公司

  • 關於我們
  • 部落格
  • 活動
  • 合作夥伴
  • 新創計劃
  • 職涯
  • 大使計畫
  • 使命與願景

熱門模型

    掌握 AI 最新動態

    提交即表示您瞭解我們會收集並使用您提交的資訊,其中可能包含個人資訊。

    XDiscordLinkedInYouTube

    Copyright ©2026 All rights reserved.

    隱私政策使用條款法律文件
    More Blog Posts
    Research

    GPT-6.1 Sol Debugs Itself to a Green Pull Request With No Human in the Loop

    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.

    The model

    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

    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 run

    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.

    The red run: two failing tests after the first write, the CLI diff open on the right

    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 final board: 13 turns, 7 files, 23 of 23 tests, 483 s, $0.4564 on Sol against $2.397 on Astra

    What it cost

    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.

    Where to be careful

    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.

    Try It on GMI Cloud

    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.

    The Question to Answer

    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

    Build AI Without Limits

    GMI Cloud helps you architect, deploy, optimize, and scale your AI strategies

    Ready to build?

    Explore powerful AI models and launch your project in just a few clicks.

    Get Started