Why Agile Teams Should Use GPT-6.1 Terra for UI Testing

Your sprint review has a bad habit: it is the first time anyone looks at the screen. The story promised "the results header shows how many filters are applied," the tests are green, and then the product owner opens the page in the demo and the count is clipped off the edge. GPT-6.1 Terra UI testing moves that discovery to Tuesday afternoon: give the model a screenshot and the story's acceptance criteria, and get back a verdict per criterion with the evidence it used.

Why the demo is a late place to find UI bugs

Unit and API tests prove the code does what the developer wrote. They say little about whether the screen matches what the story promised. Pixel-diff tools for visual regression go the other way: they flag every shifted pixel, so teams learn to click "approve all." Acceptance criteria sit in the gap, written in plain English and checked by whoever happens to be watching the demo.

A model that reads images can check plain-English criteria against a real render. That is the whole case for AI UI acceptance testing, with a human still signing off. It complements pixel diffs; it does not replace them.

What GPT-6.1 Terra brings to UI acceptance testing

OpenAI released GPT-6.1 Terra on October 26, 2026, describing it as "a fast, efficient model for visual reasoning, precise computer use, and clear, natural writing." The model page lists what matters for this job:

• Model ID gpt-6.1-terra, in the Responses and Chat Completions APIs (tool calling needs Responses).
• Text and image input, text output, structured outputs.
• $1 per million input tokens and $5 per million output tokens.
• reasoning.effort of none, low, medium (default), high, xhigh or max.

OpenAI also says Terra completes tasks more than three times faster than GPT-6 Astra and GPT-6.1 Sol, as reported at launch. None of that is a UI-testing benchmark, so the case here is a reasoned bet, not a measured result. Test it on your own screens first.

The money part is easy arithmetic. A check that uses 10,000 input tokens and 5,000 output tokens costs about 3.5 cents at list price ($0.01 plus $0.025). A hundred checks cost $3.50.

Check acceptance criteria against a screenshot

This script renders a page at 1440x900, sends the screenshot and the criteria to Terra, and forces a structured verdict for each criterion. unclear is a legal answer, which matters in a minute.

import base64
import json

from openai import OpenAI
from playwright.sync_api import sync_playwright

client = OpenAI()  # reads OPENAI_API_KEY

CRITERIA = [
    'The Filters panel is open and lists Status, Owner and Date range.',
    'The results header shows how many filters are applied.',
    'The Apply button is enabled.',
]

VERDICT_SCHEMA = {
    'type': 'object',
    'properties': {
        'results': {
            'type': 'array',
            'items': {
                'type': 'object',
                'properties': {
                    'criterion': {'type': 'string'},
                    'verdict': {'type': 'string', 'enum': ['pass', 'fail', 'unclear']},
                    'evidence': {'type': 'string'},
                },
                'required': ['criterion', 'verdict', 'evidence'],
                'additionalProperties': False,
            },
        },
    },
    'required': ['results'],
    'additionalProperties': False,
}


def capture(url: str, out_path: str) -> str:
    with sync_playwright() as p:
        browser = p.chromium.launch()
        page = browser.new_page(viewport={'width': 1440, 'height': 900})
        page.goto(url)
        page.wait_for_load_state('networkidle')
        png = page.screenshot(path=out_path)
        browser.close()
    return base64.b64encode(png).decode()


def check(url: str, story_id: str) -> dict:
    b64 = capture(url, f'{story_id}.png')
    numbered = ' '.join(f'({i + 1}) {c}' for i, c in enumerate(CRITERIA))
    prompt = (
        'You are checking a web page against acceptance criteria. '
        'Judge only what is visible in the screenshot. '
        'If you cannot tell, answer unclear. Criteria: ' + numbered
    )
    resp = client.responses.create(
        model='gpt-6.1-terra',
        reasoning={'effort': 'medium'},
        input=[{
            'role': 'user',
            'content': [
                {'type': 'input_text', 'text': prompt},
                {'type': 'input_image', 'image_url': f'data:image/png;base64,{b64}'},
            ],
        }],
        text={'format': {
            'type': 'json_schema',
            'name': 'ui_verdict',
            'strict': True,
            'schema': VERDICT_SCHEMA,
        }},
    )
    return json.loads(resp.output_text)

The strict JSON schema keeps the output machine-readable, and the evidence field gives a reviewer something to disagree with. Point url at your preview or staging environment, one call per story.

Keep a human sign-off on every story

Turn the verdicts into an unchecked checklist and let the product owner tick the boxes during review.

from pathlib import Path


def write_report(story_id: str, verdicts: dict) -> None:
    lines = [f'## {story_id}: UI check (advisory)', f'Screenshot: {story_id}.png', '']
    for r in verdicts['results']:
        v, c, e = r['verdict'].upper(), r['criterion'], r['evidence']
        lines.append(f'- [ ] **{v}** {c} Evidence: {e}')
    lines += ['', 'Tick a box only after you have looked at the screen yourself.']
    Path(f'ui-check-{story_id}.md').write_text('\n'.join(lines))

The model's job is to turn the review from a first look into a two-minute confirmation of evidence. Nothing is accepted until a person ticks it. Run the check as advisory, not a required CI gate, for the first couple of sprints.

The objection: a model grading your team's work is flaky

Fair, and it will be wrong sometimes, in both directions. Four habits keep that survivable:

• Let it abstain. Route fail and unclear to a person. Only pass stays quiet, and even that gets a human tick.
• Write observable criteria. "Shows 3 applied" can be checked from pixels. "Feels fast" cannot.
• Run it twice. Treat disagreement between runs as unclear. You cannot pin determinism with temperature: the GPT-6 guide says to remove temperature and top_p when reasoning effort is not none.
• Keep a golden set. Save 15 or 20 screenshots from past sprints with the verdicts your team agreed on, and rerun them whenever you change the prompt or the effort level. The model page lists a single snapshot name, gpt-6.1-terra, with no dated versions, so rerun the set periodically too.

When a criterion needs interaction, such as opening a panel or submitting a form, the Responses API computer tool takes over. The model returns actions, your code runs them in a browser, and you send a fresh screenshot back, as the computer use guide describes. That guide's examples use GPT-6.1 Sol, so test the loop with Terra before trusting it, and point it only at staging with a throwaway account.

Start with last sprint's UI stories

Take the acceptance criteria from last sprint's three UI stories, capture the screens, run the script, and compare the verdicts with what your team remembers from the review. If it catches one thing the demo missed and invents nothing, wire it into CI as an advisory check.

For anyone shipping AI-backed features to production, an evidence-backed first look at every screen means fewer surprises after release, and the human sign-off keeps accountability where it belongs.