GPT-6.1 Terra: Cheap Computer Use and What an Agent Run Really Costs

Python: a plain Responses call with an image

Start at low or medium effort; OpenAI’s guide says to raise it only if the quality gain is worth the time and tokens. The usage fields show what caching did.

# pip install --upgrade openai
from openai import OpenAI

client = OpenAI()  # reads OPENAI_API_KEY

response = client.responses.create(
    model="gpt-6.1-terra",
    reasoning={"effort": "low"},  # none | low | medium (default) | high | xhigh | max
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "Extract vendor, invoice date and total from this invoice. Reply as JSON.",
                },
                {
                    "type": "input_image",
                    "image_url": "https://example.com/invoices/inv-4471.png",
                    "detail": "original",
                },
            ],
        }
    ],
)

print(response.output_text)

details = response.usage.input_tokens_details
print("cache reads:", details.cached_tokens, "cache writes:", details.cache_write_tokens)

Python: the computer tool in a sandboxed Playwright browser

My adaptation of the guide’s loop and Playwright recipes, with an allow list, a step cap, a stop on pending safety checks and no Submit. Point it at a test environment only.

# pip install --upgrade openai playwright && playwright install chromium
# Adapted from OpenAI's computer-use guide and integration recipes. Not run.
import base64
import time
from urllib.parse import urlparse

from openai import OpenAI
from playwright.sync_api import sync_playwright

MODEL = "gpt-6.1-terra"
START_URL = "https://erp.test.example/invoices/new"  # a test copy, never production
ALLOWED_HOSTS = {"erp.test.example"}
MAX_STEPS = 40

BUTTONS = {"left": "left", "right": "right", "wheel": "middle"}
KEYS = {"ENTER": "Enter", "RETURN": "Enter", "ESC": "Escape", "TAB": "Tab",
        "CTRL": "Control", "ALT": "Alt", "SHIFT": "Shift", "CMD": "Meta",
        "SPACE": "Space", "BACKSPACE": "Backspace"}

client = OpenAI()


def run_actions(page, actions):
    for action in actions:
        match action.type:
            case "click":
                button = BUTTONS[getattr(action, "button", "left")]
                page.mouse.click(action.x, action.y, button=button)
            case "double_click":
                page.mouse.dblclick(action.x, action.y)
            case "scroll":
                page.mouse.move(action.x, action.y)
                page.mouse.wheel(action.scroll_x, action.scroll_y)
            case "type":
                page.keyboard.type(action.text)
            case "keypress":
                page.keyboard.press("+".join(KEYS.get(k, k) for k in action.keys))
            case "wait":
                time.sleep(2)
            case "screenshot":
                pass  # a fresh screenshot goes back after every batch
            case _:
                raise ValueError(f"Action not allowed in this driver: {action.type}")
        host = urlparse(page.url).hostname
        if host not in ALLOWED_HOSTS:
            raise PermissionError(f"Left the allow list: {host}")


def screenshot_output(page, call_id):
    png = page.screenshot(type="png")
    return {
        "type": "computer_call_output",
        "call_id": call_id,
        "output": {
            "type": "computer_screenshot",
            "image_url": "data:image/png;base64," + base64.b64encode(png).decode(),
            "detail": "original",
        },
    }


with sync_playwright() as p:
    browser = p.chromium.launch(
        headless=False,
        chromium_sandbox=True,
        env={},
        args=["--disable-extensions", "--disable-file-system"],
    )
    page = browser.new_page(viewport={"width": 1440, "height": 900})
    page.goto(START_URL)

    response = client.responses.create(
        model=MODEL,
        reasoning={"effort": "low"},
        tools=[{"type": "computer"}],
        input="Fill the new-invoice form: vendor ACME Ltd, amount 1250.00, "
        "date 2026-10-28. Do not click Submit. Use the computer tool.",
    )

    for step in range(MAX_STEPS):
        call = next((item for item in response.output if item.type == "computer_call"), None)
        if call is None:
            break  # text answer: check the form yourself before trusting it
        if call.pending_safety_checks:
            raise RuntimeError("Safety check raised: hand this run to a human")
        run_actions(page, call.actions)
        response = client.responses.create(
            model=MODEL,
            reasoning={"effort": "low"},  # keep it constant to protect the cache
            tools=[{"type": "computer"}],
            previous_response_id=response.id,
            input=[screenshot_output(page, call.call_id)],
        )
    else:
        raise RuntimeError("Step limit reached without a final answer")

    print(response.output_text)
    browser.close()

Assumptions

• • 40 steps (Responses requests) to fill a multi-page form in a web app, at low effort
• • A 4,000-token stable prefix: instructions, tool definition and task
• • About 2,000 new input tokens per step: a 1440 × 900 screenshot covers 1,305 patches of 32 × 32 pixels, about 1,566 tokens if Terra uses the 1.2 multiplier OpenAI lists for Astra and the 5.6 models (Terra isn’t in that table yet), plus the call and action items
• • 800 output tokens per step, reasoning included
• • Implicit caching with the default 30-minute lifetime: each step reads the earlier context from cache and writes the new suffix at 1.25x input
• • Totals: about 1.8M input tokens (1.716M cache reads and 84K cache writes) and 32K output tokens; the context peaks near 84K, far below the 272K long-context line