GPT-6 Astra can use your computer. Give it your OpenAPI spec instead.

The headline feature of GPT-6 Astra is that it can use a computer. Not in the 2025 sense, where a model clicked its way through a demo and then got lost on a dropdown. In the OpenAI launch post, Astra scores 72.6% on OSWorld 2.0 at roughly 40 minutes per task, fills out forms, updates CRMs, installs software, and runs frontend QA checks on a site it built itself. OpenAI calls it “the world’s best computer use model,” and for once the demos back the claim.

If you build or test APIs, that capability points at a tempting shortcut: point Astra at your app and let it click. This post argues you should do something less impressive and more useful. Give it the contract. An OpenAPI spec is a faster, cheaper, and more verifiable interface for a model than a screen, and a model this capable will use it well. We saw Astra make that switch on its own during our two-day hands-on test, and the rest of this piece explains why that was the right call and how to set it up with Apidog.

TL;DR

GPT-6 Astra’s computer use is real: 72.6% on OSWorld 2.0, 92.7% on ScreenSpot-Pro, and a Codex harness that finishes computer-use tasks 1.9x faster than the GPT-5.6 Sol experience. But screen-driving costs tens of minutes and many image tokens per task, and it tests the UI, not the API. For your own services, hand Astra the OpenAPI spec through the Apidog MCP Server or as function tools, let it write the test scenarios, and run them from the Apidog CLI in CI. Keep computer use for the surfaces that have no API.

What computer use in GPT-6 Astra can do

The capability is broader than “browse a website.” OpenAI lists tedious knowledge work (online forms, CRM records, calendars), research and drafting inside a document editor, scientific data analysis with plots, building and hosting a website through ChatGPT Sites, and frontend QA on that site. The demos include laying out a printed circuit board in KiCad and modeling a house in Blender.

The benchmark numbers, all OpenAI-run from the launch post:

Two details matter more than the scores. Astra finishes OSWorld tasks in about 47% less time than Sol, and on Agents’ Last Exam it uses roughly 65% fewer output tokens than Opus 5 at the highest-scoring settings. Alongside the model, OpenAI updated the Codex harness so computer-use task completion is 1.9x faster than the current Sol experience on Mind2Web. Faster loops mean cheaper loops, which is the part that matters for anyone paying per token.

Behavior improved too. Astra asks focused questions only when the answer would change the outcome, stays oriented when you steer it mid-task, and in Codex it can ask asynchronously while continuing work that doesn’t depend on your reply. On OpenAI’s internal computer-use safety benchmark, where lower is better, Astra scores 2.4% against Sol’s 22.0%.

What a 40-minute task costs

Computer use is a loop: screenshot, reason, act, screenshot again. Every screenshot is image input, every step carries the conversation so far, and a task that takes 40 minutes takes hundreds of steps. At Astra’s standard rate of $10 per million input tokens and $50 per million output, with prompts over 272K input tokens billed at $20 per million, a long session that keeps its full history in context drifts into long-context pricing before it finishes. Prompt caching helps with the repeated prefix, at $1 per million cached tokens, but the screenshots themselves are new every step.

Compare that with the contract path. Your OpenAPI spec is one prefix, cached once. Each test the model writes is a few hundred tokens of JSON. Each run of that test is an HTTP call that costs nothing on the model side, because a test scenario, once written, doesn’t need a model to execute it.

There’s a second cost that has nothing to do with money. OpenAI’s safety overview says its production misalignment monitor “can sometimes slow, pause, or stop legitimate work,” and calls out “tasks in which an agent is running for an extended period.” In ChatGPT or Codex you’ll be asked to review the action. In the API, the task stops. A 40-minute screen-driving session is exactly the shape of task most exposed to that interruption. A five-second API call is not.

Computer use versus the contract: when each wins

The distinction is what you’re testing. Computer use tests the pixels. The spec tests the promise. When a frontend breaks, the API is usually still fine, and when the API breaks, the frontend can hide it behind a friendly error. Both matter, but API teams ship the promise, so test the promise first.

How to hand Astra your API contract

There are three ways to give Astra a spec, and they stack.

1. Give it the file. Export the OpenAPI spec from your Apidog project (or import your existing spec into Apidog first) and include it in the request. Astra’s 1,050,000-token context window holds any real-world spec in one prompt, and OpenAI’s MRCR retrieval test shows it keeps 96.3% accuracy in the 512K to 1M range, where Sol drops to 73.8%. Large specs stop being a chunking problem.

2. Connect the project through MCP. The Apidog MCP Server exposes your Apidog project, your published documentation, or an OpenAPI file to any MCP-capable client, so Astra reads the current contract instead of a stale export. Codex and the desktop agents can pull the endpoint definitions as they work. That’s the setup that let Astra, in our test, find and read the spec on its own.

3. Turn the spec into tools. For programmatic use, convert endpoints into function tools and call Astra through the Responses API, the pattern we cover in OpenAPI to AI agent tools. The model page lists function calling, structured outputs, and file search among Astra’s features, and tool calling requires the Responses API, not Chat Completions.

A minimal request that asks Astra to draft test scenarios from a spec looks like this:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "reasoning": {"effort": "medium"},
    "input": [
      {"role": "developer", "content": "You are writing API test scenarios. Bias towards action. Only ask a question if the answer changes the test design. Output JSON matching the schema."},
      {"role": "user", "content": "Here is our OpenAPI 3.1 spec. Draft a test scenario per resource: happy path, auth boundary, and one negative case each.\n\n<paste spec>"}
    ],
    "text": {"format": {"type": "json_schema", "name": "scenarios", "schema": {"type": "object", "properties": {"scenarios": {"type": "array"}}, "required": ["scenarios"]}}}
  }'

Two notes from OpenAI’s model guidance. Astra has no none or minimal effort, so start at low or medium, and it “asks for clarification more readily” than earlier models, so the “bias towards action” line in the developer message is doing real work.

4. Run the scenarios without the model. Import the generated scenarios into Apidog, attach assertions on status codes and response schemas, and run them from the Apidog CLI in your pipeline. The model wrote the tests once. Your CI runs them a thousand times for free. That’s the economic argument in one sentence, and it’s why Download Apidog sits next to the API key in this workflow.

Keep the guardrails, even though Astra respects them

OpenAI’s alignment results for Astra are the best it has published. In the honeypot test built after the Hugging Face incident, Sol went beyond the authorized target 48% of the time and Astra did so 0% of the time. Astra never attempted to circumvent a Codex auto-review denial, even when the denial was deliberately configured to be evadable. Its indirect prompt-injection robustness is 99.79%, up from 96.23%.

None of that removes the need for gates. It means the gates fire less often. A model with a 1M-token window, a Critical cyber rating, and the ability to send arbitrary requests to your API should still run against staging with scoped credentials, an approval gate on mutations, and a trace of every call. Astra’s monitor may also stop a run mid-task, so treat every long job as resumable. The test design for non-deterministic agents applies unchanged: assert on the contract, not the transcript.

Where computer use still earns its place

Don’t read this as “never let it click.” Three cases are better on the screen. A partner portal or admin console with no API. A release-day frontend check that a human would otherwise do by hand. A legacy desktop tool where the UI is the only surface. Astra is the first model where those jobs are worth delegating at all, and the Codex harness speedup makes them cheap enough to run nightly.

The practical rule: reach for the contract when a contract exists, and reach for the screen when it doesn’t.

FAQ

Does GPT-6 Astra’s computer use work through the API? Yes. Computer use is listed among Astra’s supported tools on the Responses API, alongside web search, file search, code interpreter, and image generation. Your application supplies the environment and executes the actions the model proposes. The API also carries the stricter side of OpenAI’s safeguards: a task paused by the misalignment monitor stops instead of waiting for review.

How large a spec can I give it? The context window is 1,050,000 tokens with 128,000 tokens of output. A spec with hundreds of endpoints and full schemas fits with room to spare. Prompts over 272K input tokens bill at 2x the input and cache rates, so cache the spec prefix and keep the per-test messages small.

Will it hallucinate endpoints that aren’t in the spec? Less than earlier models. OpenAI’s internal hallucination benchmark, where lower is better, has Astra at 4.2% versus Sol’s 12.2%, and it is three times less likely to misrepresent its own capabilities. Structured outputs plus a schema-validated run in Apidog catch the rest, which is why the contract test is the last word, not the model.

Is this cheaper than GPT-5.6 Sol for test generation? Per token, no. Astra costs $10 and $50 per million tokens against Sol’s promotional $4 and $20. Per finished task, OpenAI claims Astra uses far fewer tokens, and the spec-first workflow makes the model cost a one-time expense. Measure it on your own spec before you decide; the API guide shows how to compare both side by side.

The short version

GPT-6 Astra can drive your computer, and for surfaces without an API that is a real gift. For the API you own, the screen is the slow path. Hand the model the contract, let it write the scenarios, run them in CI, and keep the gates. Astra reached that conclusion on its own inside twenty minutes. Your team can start there.