GPT-6.1 Terra: Uso de Computadora Barato y Cuánto Cuesta de Verdad un Agente

Python: un request simple a Responses con una imagen

Empezá en low o medium; la guía de OpenAI dice que lo subas solo si la mejora de calidad compensa el tiempo y los tokens. Los campos de usage muestran qué hizo el caché.

# 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: la herramienta computer en un navegador Playwright aislado

Mi adaptación del loop y de las recetas de Playwright de la guía, con allow list, tope de pasos, corte ante safety checks pendientes y sin Submit. Apuntalo solo a un entorno de prueba.

# 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()

Supuestos

• • 40 pasos (requests a Responses) para completar un formulario de varias páginas en una app web, con effort low
• • Un prefijo estable de 4000 tokens: instrucciones, definición de la herramienta y tarea
• • Unos 2000 tokens nuevos de entrada por paso: una captura de 1440 × 900 ocupa 1305 parches de 32 × 32 píxeles, unos 1566 tokens si Terra usa el multiplicador de 1,2 que OpenAI publica para Astra y los modelos 5.6 (Terra todavía no está en esa tabla), más los items de la llamada y de las acciones
• • 800 tokens de salida por paso, razonamiento incluido
• • Caché implícito con la duración por defecto de 30 minutos: cada paso lee el contexto anterior desde caché y escribe el sufijo nuevo a 1,25x el precio de entrada
• • Totales: unos 1,8M de tokens de entrada (1,716M de lecturas de caché y 84K de escrituras) y 32K de salida; el contexto llega como máximo a unos 84K, muy por debajo del umbral de 272K de contexto largo