GPT-6.1 Terra, Ultrafast and agents that use a computer

The news, and what is confirmed

OpenAI’s autumn has been about agents that work for a long time on your behalf: writing code in Codex, clicking through websites, filling in spreadsheets. On 26 October it released GPT-6.1 Terra, a cheaper model built for exactly that kind of work. Five weeks earlier, at DevDay, it sold speed itself as a product, with an Ultrafast tier and a $500-a-month plan, and gave developers computer use in its Agents API. Under all three sit the same questions: how fast is fast, why does speed cost money, and how often does a 100-step task go right?

What was released?

GPT-6.1 Terra (26 October) is, in OpenAI’s words, “a fast, efficient model that combines detailed visual reasoning and precise computer use alongside clearer, more natural writing”. It is not OpenAI’s flagship: it sits in the middle of its range, above GPT-6 Luna and below GPT-6.1 Sol and GPT-6 Astra (Simon Willison). Its pitch is value. The API price is $1 per million input tokens and $5 per million output, half that of GPT-5.6 Terra and GPT-6.1 Sol, and OpenAI says it completes tasks “over 3× faster on average than both Astra and GPT-6.1 Sol” (OpenAI developer announcement). At maximum reasoning effort it solves 50.3% of Terminal-Bench 4.0 tasks, against 21.5% for GPT-5.6 Terra (OpenAI, as also reported by Help Net Security).

At DevDay (29 September), OpenAI launched Ultrafast, a premium speed tier that “offers up to 8x faster token generation (300 tokens per second) in Codex and up to 6x in the API” (OpenAI). In the API it covers GPT-6 Astra and GPT-6.1 Sol, not Terra (API docs), and The Decoder reports it costs six times the standard rate. A new Pro 500 plan, $500 a month with 25 times the Plus allowance, includes it in ChatGPT Work and Codex (plan description). And the Agents API gained computer use, in beta, in a browser OpenAI hosts (API docs).

A third OpenAI release in the same fortnight, GPT-6 Rosalind for life-sciences research (30 October), is a different story and is not covered here.

Key takeaways

• GPT-6.1 Terra is a mid-tier model for agentic, computer-use and writing work at $1/$5 per million tokens, half its predecessor’s price.
• DevDay sold speed as a product: Ultrafast (up to 300 tokens/s in Codex, six times the price) and the $500 Pro 500 plan.
• Size, architecture, training data and absolute speeds are undisclosed; the benchmarks are OpenAI’s own.

What tokens per second means

“300 tokens per second” sounds like a single number for speed. For a person reading a chat reply it barely matters past reading pace. For an agent that writes thousands of tokens across dozens of steps, it can be the difference between a coffee break and an afternoon. And for both, it is only one of two numbers.

What is it?

A model writes text one token at a time. Two numbers describe how quickly. Time to first token is the wait before anything appears: the request travels, waits for a slot, and the model reads the whole prompt (the prefill). Throughput, in tokens per second, is how fast the rest streams out once it starts. Ultrafast is a throughput claim.

How does it work for an agent?

An agent is a loop (see AI agents): think, call a tool, read the result, think again. Each turn pays the first-token wait again, writes its reasoning and tool call, then waits for the tool. For a run that repeats the loop many times, the time is roughly:

Each part can dominate. A faster tier shrinks only the middle term; the first-token wait and the tools are untouched.

Why does it matter?

Speeding up one part of a job only speeds up the whole job in proportion to that part’s share, the same logic as Amdahl’s law. If generation is 80% of an agent’s time, an 8× faster tier makes the whole task about 3.3× faster; if it is 30%, barely 1.4×. That is also how to read OpenAI’s “up to 8×” alongside “up to 6×” in the API: both are generation speeds, and what you feel is the whole loop.

Two things show up quickly. For a single chat answer, the first-token wait is a big share and a faster tier saves seconds you might not notice. For a long computer-use run with short actions, the screenshot and page-load time between steps can dominate, so the model’s speed is not the bottleneck at all. Fast generation pays most for agents that write a lot per step, such as code, and for runs where a person is waiting at the end.

Key takeaways

• Speed is two numbers: time to first token (the wait) and tokens per second (the stream).
• An agent pays both on every step, plus tool time; total ≈ steps × (wait + tokens ÷ speed + tools).
• A faster tier speeds up the whole task only in proportion to generation’s share of the time.

Why faster costs more

Ultrafast costs six times the standard API rate. That is not just a premium for a premium product: on the same hardware, serving one person faster really does cost more per token. The reason is batching.

What is it?

Batching means decoding many users’ requests together. Each step of decoding has to stream the model’s weights from GPU memory, and that takes about the same time whether the step produces one token for one user or one token each for a hundred. Modern servers use continuous batching, adding and removing requests at every step (Yu et al., 2022), and fit as many as their KV-cache memory allows (Kwon et al., 2023).

How does it work?

A bigger batch makes each step a little slower, because there is more arithmetic and more cache to read, so every user sees fewer tokens per second. But the server as a whole produces far more tokens, so each costs less. A small batch is the opposite: quick for the few people in it and expensive per token, because the same hardware serves far fewer of them. A speed tier is a promise to run your request in the fast, expensive part of that curve, or on hardware set up for it.

In this toy model, a batch of one gives each user nearly twice the speed of a batch of 64, at more than thirty times the cost per token. Notice what batch size alone cannot do: even a batch of one is only about 50 tokens per second here. Getting several times faster than standard needs other levers, such as splitting the model across more chips so each streams fewer weights, faster memory or specialised accelerators, and speculative decoding, which checks several drafted tokens per pass. OpenAI has not said which of these Ultrafast uses.

Key takeaways

• Each decoding step costs about the same whether it serves one request or many, so big batches are cheap per token.
• Smaller batches are faster per user and much more expensive; a speed tier is priced on that trade-off.
• Large speedups also need more hardware per request or tricks like speculative decoding; OpenAI has not said how Ultrafast works.

How computer-use agents work

Most software was built for people with a mouse, not for programs with an API. A computer-use agent closes that gap by using the screen the way you do: it looks, decides where to click, and looks again. Terra is pitched on doing this well, and DevDay put the same ability into OpenAI’s Agents API.

What is it?

A computer-use agent is a model that operates a graphical interface. Instead of calling a function such as create_invoice(), it sees a screenshot and outputs low-level actions such as “click at (412, 220)” or “type ‘March report’”. Anything a person can do in a browser or desktop app is, in principle, within reach.

How does it work?

It is a loop. In the Agents API, the agent runs in an OpenAI-hosted browser and uses “what it observes in the browser to decide what to do next”, with screenshots streamed as it goes (OpenAI docs). Two guard rails are built in: your application must approve each new website origin the agent wants to visit, and passwords are entered through a separate sign-in flow so that they “stay outside the agent’s model input”.

Why does it matter?

It turns any website or legacy app into something an agent can use, which is why OpenAI stresses visual reasoning for Terra: reading a cluttered screen and picking the right element is the hard part. On the OSWorld benchmark of real desktop tasks, its authors found that agents mostly failed at exactly that, grounding clicks on the right element, and at recovering from their own mistakes (Xie et al., 2024). It is also slow and long: every action needs a fresh screenshot, so even a simple job is dozens of steps, which brings us to the arithmetic of reliability.

Key takeaways

• Computer use is a loop: screenshot in, one action out (click, type, scroll), then a new screenshot.
• OpenAI’s Agents API runs it in a hosted browser, asks before each new site and keeps passwords out of the model’s input.
• Picking the right element on screen is the hard part, and each action costs a step.

Errors compound over steps

An agent that gets 98 of every 100 actions right sounds excellent. Ask it for a 50-step job and it will finish without a single mistake only about one time in three. Long tasks multiply small error rates.

What is it?

If each step of a task succeeds with probability p, and steps succeed or fail independently, the chance that all n steps succeed is p multiplied by itself n times. The chance falls exponentially with length.

The half-life is the number of steps after which the task succeeds only half the time.

How does it work in practice?

At 98% per step the half-life is about 34 steps; at 99% about 69; at 99.9% about 693. So a model that moves from 98% to 99% per step does not get 1% better on long tasks: it can do twice as many steps for the same reliability. The other lever is recovery. An agent that notices a wrong click, because the next screenshot does not look as expected, and fixes it turns a failure into a delay. If half of all mistakes are caught, a 98% step behaves like a 99% one.

Real agents are not coin flips: some steps are trivial, a few are hard, and some errors are harmless while others are fatal. But the shape holds up in measurement. METR found that the length of task models can finish with 50% reliability doubled roughly every seven months between 2019 and 2025, and that success falls steeply as tasks get longer (Kwa et al., 2025). OpenAI’s Terminal-Bench and Agents’ Last Exam numbers for Terra are claims about exactly this: how many multi-step tasks end correctly.

Key takeaways

• Success over n independent steps is pⁿ, so it falls exponentially with task length.
• Raising per-step accuracy from 98% to 99% doubles the steps you can take at the same reliability.
• Catching and fixing mistakes is as powerful as being more accurate in the first place.

Long tasks, and choosing

Speed, price and reliability pull against each other. A long agent run is where all three meet, and where the cheapest model per token is not always the cheapest per finished task.

What makes long tasks reliable?

Four things. A more accurate model per step, which is what reasoning effort buys (see reasoning models). Checks: run the tests, re-read the screenshot, compare totals, so mistakes are caught. Memory that lasts: Terra’s 1,050,000-token context and the Agents API’s context compaction both aim to keep a long run from forgetting what it was doing (model page, The Decoder). And shorter chains: split a job into pieces with a human review between them, which resets the compounding.

Why does it matter?

The figure that matters is cost per successful task: price per attempt divided by the chance an attempt succeeds. A model that is half the price but succeeds half as often costs the same per finished job and wastes your time. OpenAI’s claim for Terra, scoring higher than its predecessor at about a third of the cost, is a claim about that ratio, measured on its own tasks. Check it on yours.

Key takeaways

• Long-run reliability comes from per-step accuracy, checks that catch mistakes, lasting memory and shorter chains.
• Judge models by cost per successful task, not price per token.
• Pay for speed when a person is waiting; pay for accuracy when mistakes are expensive.

Check your understanding

Seven scenarios, from a slow chatbot to a booking agent that meets a malicious web page.

A support team uses a chatbot whose answers are about 150 tokens. They are offered a tier that streams 8× faster at six times the price. Their users complain of a two-second pause before anything appears. Will the tier fix the complaint?

References

Model details come from OpenAI’s GPT-6.1 Terra announcement, developer post, model page and system card, and DevDay details from OpenAI’s posts and API documentation, checked on 5 November 2026. Figures quoted from the press are labelled as such. Background on batching, computer-use agents and long-task reliability comes from papers.

Sources

1. [1]

   Introducing GPT-6.1 Terra(opens in a new tab)

   OpenAI, 2026

   Announcement (26 October 2026): “a fast, efficient model that combines detailed visual reasoning and precise computer use alongside clearer, more natural writing”. At medium reasoning effort it scores 15 points above GPT-5.6 Terra on Agents’ Last Exam at about a third of the cost; at maximum effort it solves 50.3% of Terminal-Bench 4.0 tasks against GPT-5.6 Terra’s 21.5%; it completes tasks over three times faster on average than GPT-6 Astra and GPT-6.1 Sol. API price $1 input and $5 output per million tokens.

2. [2]

   GPT-6.1 Terra(opens in a new tab)

   Willison, S., 2026

   Places Terra in OpenAI’s middle tier, below GPT-6.1 Sol and GPT-6 Astra and above GPT-6 Luna; notes the price is about half that of GPT-5.6 Terra and GPT-6.1 Sol.

3. [3]

   GPT-6.1 Terra: delivering fast and capable computer use at a lower price(opens in a new tab)

   OpenAI (Developer Community announcement), 2026

   OpenAI’s developer announcement (26 October 2026): model id gpt-6.1-terra; rolling out to Plus, Pro, Enterprise and Edu users in ChatGPT Work and Codex; standard API prices 50% below GPT-5.6 Terra; completes tasks “over 3× faster on average than both Astra and GPT-6.1 Sol”; supports reasoning effort “none”.

4. [4]

   GPT-6.1 Terra meets OpenAI’s Critical cyber threshold, and it’s cheaper than GPT-5.6 Terra(opens in a new tab)

   Help Net Security, 2026

   Summarises OpenAI’s launch numbers: $1/$5 per million tokens, $0.05 cached input, Terminal-Bench 4.0 50.3% vs 21.5%, and the Critical cybersecurity classification.

5. [5]

   This is Ultrafast(opens in a new tab)

   OpenAI, 2026

   DevDay post (29 September 2026): “Our premium speed tier, Ultrafast offers up to 8x faster token generation (300 tokens per second) in Codex and up to 6x in the API.”

6. [6]

   Ultrafast mode(opens in a new tab)

   OpenAI API documentation, 2026

   Ultrafast is selected with service_tier: "ultrafast" and is offered for GPT-6 Astra and GPT-6.1 Sol only, with its own rate limits. Recommends WebSocket connections to cut network overhead, and says to “use it when speed justifies the higher cost”.

7. [7]

   OpenAI expands Codex and its API at DevDay with security scans, a Decisions API, and Ultrafast(opens in a new tab)

   The Decoder, 2026

   DevDay, 29 September 2026: Ultrafast for GPT-6 Astra at six times the standard API rate; the $500-a-month Pro 500 plan includes it in ChatGPT Work and Codex; computer use added to the Agents API, alongside multi-agent support, tool search and context compaction.

8. [8]

   ChatGPT Pro 500: the $500 plan that came with a Pro 200 cut(opens in a new tab)

   Sebastien, D., 2026

   Quotes OpenAI’s plan description: Pro 500 “offers our highest usage allowance at 25 times the ChatGPT Plus allowance and includes access to Ultrafast”, at $500 a month.

9. [9]

   Computer use (Agents API)(opens in a new tab)

   OpenAI API documentation, 2026

   Beta (OpenAI-Beta: agents=v1). The agent works in an OpenAI-hosted browser and uses “what it observes in the browser to decide what to do next”; screenshots stream during the run. Each new website origin needs approval from your application, and sign-in values are entered through a separate flow and “stay outside the agent’s model input”.

10. [10]

    GPT-6.1 Terra model page(opens in a new tab)

    OpenAI API documentation, 2026

    Text and image input, 1,050,000-token context window, 128,000 maximum output tokens, knowledge cutoff 1 June 2026, reasoning effort from none to max. $1 per million input tokens, $5 per million output; cached input at 5% of the input rate; prompts over 272K tokens billed at 2× for input. Computer use, web search, file search and code interpreter tools through the Responses API.

11. [11]

    Addendum to GPT-6 Astra System Card: GPT-6.1 Terra(opens in a new tab)

    OpenAI Deployment Safety Hub, 2026

    System card addendum (26 October 2026): “a fast, efficient model for high-volume professional work, with strong image analysis and computer use capabilities.” Treated as Critical capability in cybersecurity and High in biology and chemistry under the Preparedness Framework, below High in AI self-improvement; deployed with the same safeguards stack as GPT-6.1 Sol and GPT-6 Astra.

12. [12]

    Orca: A Distributed Serving System for Transformer-Based Generative Models(opens in a new tab)

    Yu, G.-I., Jeong, J. S., Kim, G.-W., Kim, S., Chun, B.-G., 2022

    Introduced iteration-level (continuous) batching: requests join and leave the batch at every decoding step, which raised throughput many times over request-level batching at the same latency. OSDI 2022.

13. [13]

    Efficient Memory Management for Large Language Model Serving with PagedAttention(opens in a new tab)

    Kwon, W., Li, Z., Zhuang, S., Sheng, Y., Zheng, L., Yu, C. H., Gonzalez, J. E., Zhang, H., Stoica, I., 2023

    vLLM: decoding is limited by memory, and larger batches raise throughput until KV-cache memory runs out; paging the cache lets more requests share a GPU. SOSP 2023.

14. [14]

    OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments(opens in a new tab)

    Xie, T., Zhang, D., Chen, J., Li, X., Zhao, S., Cao, R., et al., 2024

    A benchmark of real desktop tasks scored by scripts. Agents see screenshots and act with mouse and keyboard; the authors found that grounding clicks on the right element and recovering from mistakes were the main failure modes. NeurIPS 2024.

15. [15]

    Measuring AI Ability to Complete Long Tasks(opens in a new tab)

    Kwa, T., West, B., Becker, J., et al. (METR), 2025

    Measures the length of task, in human working time, that models complete with 50% reliability, and finds it doubled roughly every seven months from 2019 to 2025. Success falls steeply as tasks get longer.