How to Use GPT-6.1 Terra for Computer Use and AI Workflow Automation

Much office work means moving the same information between browser tabs, web forms, spreadsheets, and business applications. It is slow, and every manual copy is a chance for error. GPT-6.1 Terra is OpenAI’s model for this kind of work. OpenAI describes it as a fast, efficient model for visual reasoning, precise computer use, and clear writing. It launched on October 26, 2026, and is available in ChatGPT Work and Codex and through the API as gpt-6.1-terra. This guide explains how to access the model, how computer use works, how to set up an API integration, and how to build and verify a workflow safely.

GPT-6.1 Terra: Quick Summary

• What it is: A mid-tier model in OpenAI’s GPT-6 family. It accepts text and image input and returns text.
• What computer use enables: The model reads screenshots and chooses actions such as clicks, typing, and scrolling. Those actions run only in an environment that you or a provider controls.
• Where to access it: ChatGPT Work and Codex on eligible plans, and the API.
• Coding required: No for ChatGPT Work or Codex. Yes for a custom API integration.
• Key limitation: The model cannot operate a computer by itself. Reliable results depend on your environment, permissions, and verification.

What Is GPT-6.1 Terra and How Does Computer Use Work?

GPT-6.1 Terra is a model, not a finished automation product. It interprets what it receives, including screenshots, and proposes the next action. A separate component must perform that action. That component is a browser, a desktop, or an application environment that you control.

Key GPT-6.1 Terra Capabilities

OpenAI’s model page lists the following:

• Visual reasoning: It interprets screens, product photos, and technical drawings.
• Computer use: The model supports the computer-use tool in the Responses API.
• Tool calling: It supports function calling, web search, file search, and MCP. Tool calling requires the Responses API.
• Context and output: A 1,050,000-token context window and up to 128,000 output tokens.
• Reasoning effort: none, low, medium (default), high, xhigh, and max.

OpenAI also reports that Terra completes tasks more than three times faster than GPT-6 Astra and GPT-6.1 Sol on its own tests. Treat that as a vendor claim until you measure it on your own tasks.

How AI Computer Use Works

A computer-use session runs in a loop:

1. The application sends the task and the current screen.
2. The model inspects the interface.
3. The model selects an action, such as a click or a keystroke.
4. The environment executes the action.
5. The environment returns an updated screenshot.
6. The loop repeats until the model finishes or needs human help.
7. You verify the result in the target application.

Keep three parts distinct: the model reasons and proposes actions, the tool interface carries those proposals in a structured format, and the environment performs the actions and captures the results.

How to Access GPT-6.1 Terra

Use GPT-6.1 Terra in ChatGPT Work

OpenAI’s announcement says the model is rolling out to Plus, Pro, Enterprise, and Edu users in ChatGPT Work and Codex. Some outlets also list Business, so confirm eligibility for your workspace. If the model does not appear in the model picker, the rollout may not have reached your account yet. Terra is not offered in standard ChatGPT Chat. OpenAI’s changelog describes the same arrangement for other GPT-6 models: available in Work and Codex, but not Chat.

Use GPT-6.1 Terra in Codex

Codex is OpenAI’s agent for development and computer-based work. It runs in the desktop app, the CLI, the IDE extension, and the cloud. Use it when a task involves files, code, or applications, rather than a conversation. Select the model inside the session. OpenAI’s changelog documents a –model flag for other GPT-6 models, so confirm that the Terra identifier appears in Codex’s model list before you script it.

Access GPT-6.1 Terra Through the API

API access requires an OpenAI API key with billing enabled and access to the model. Tool calling requires the Responses API. The model cannot act on a computer through the API alone. You must also provide an execution environment, which you can build yourself or obtain from a partner. Browserbase, Browser Use, Daytona, and E2B offer hosted browser or desktop environments.

Non-developers can use ChatGPT Work or Codex. The API route requires programming.

How to Use GPT-6.1 Terra for Computer Use Step by Step

This tutorial uses the ChatGPT Work and Codex workflow. Interface labels change, so the steps describe actions rather than exact buttons.

Step 1: Choose a Clearly Defined Task

Start with low-risk work, such as comparing sample product listings with a spreadsheet or entering test data into a practice form. Avoid live payments, customer emails, and deletions until you have tested the workflow.

Step 2: Define Instructions and Permissions

State the starting application, the desired result, the allowed actions (for example, reading pages and typing into test fields), the prohibited actions (submitting forms, sending messages, deleting records), and the completion criteria.

Step 3: Provide Screen Context and Limit Access

Give the model access only to the applications the task needs. Use a separate browser profile, and avoid signing into accounts that the task does not require.

Step 4: Monitor the Actions

Review what the model does as it works. Stop the run if it drifts from the instructions or takes an action you did not expect.

Step 5: Verify Completion

Check the actual application, including saved values, confirmation messages, and incomplete fields. Do not rely only on the model’s final summary.

Short answer:

1. Pick a low-risk task.
2. Define allowed and forbidden actions and the completion criteria.
3. Give access only to the apps the task needs.
4. Monitor each action.
5. Verify the result in the application itself.

How to Set Up GPT-6.1 Terra Computer Use Through the API

OpenAI’s Python and Node SDKs run the tool loop. Your application supplies a driver, which reads the environment and performs allowed actions. Python 3.11 or later, or Node.js 22.6 or later, is required.

Step 1: Configure the Development Environment

Install the packages pinned in OpenAI’s current guide:

bash

python3 -m venv .venv

.venv/bin/python -m pip install openai==3.31.0 playwright==1.61.0

.venv/bin/python -m playwright install chromium

Step 2: Configure the Model Request

Set model to gpt-6.1-terra. In the raw Responses API, the computer tool is enabled with tools=[{“type”: “computer”}]. The model page lists computer use as supported. OpenAI’s examples use other GPT-6 models, so run the example below once in a test environment to confirm the Terra configuration works for your task.

Step 3: Implement the Computer-Use Loop

The SDK sends the task and screenshots to the model. When the model requests an action, your driver checks it against an allowlist and executes it. It then returns a fresh screenshot, and the loop continues. Reject any action that is not explicitly permitted.

Step 4: Preserve State and Handle Failures

Keep the browser open for the whole run, and close it in a finally block. Set a maximum number of steps and a request timeout. Treat any status other than completed as a failure. Continuing a conversation does not restore a browser session, so keep the environment alive yourself.

Step 5: Verify the Output

After the run, check the page state directly. Compare the result with your expected values before you record success.

The example below uses OpenAI’s documented Python pattern for a sandboxed page. It allows screenshots and one left click on a single control, blocks all network requests, and checks the page after the run.

python

import asyncio

import base64

from openai import AsyncComputerToolset, AsyncOpenAI

from playwright.async_api import async_playwright

class PickupDriver:

    def __init__(self, page):

        self.page = page

    async def screenshot(self):

        image = await self.page.screenshot(type=”png”)

        return {“type”: “computer_screenshot”,

                “image_url”: “data:image/png;base64,” + base64.b64encode(image).decode()}

    async def allowed(self, action):

        if action.type == “screenshot”:

            return True

        if action.type != “click” or action.button != “left” or action.keys:

            return False

        box = await self.page.locator(“summary”).bounding_box()

        return bool(box and box[“x”] <= action.x < box[“x”] + box[“width”]

                    and box[“y”] <= action.y < box[“y”] + box[“height”])

    async def click(self, action):

        if not await self.allowed(action):

            raise RuntimeError(“Click not allowed.”)

        await self.page.mouse.click(action.x, action.y)

    async def refuse(self, action):

        raise RuntimeError(f”This exercise does not allow {action.type}.”)

    double_click = drag = keypress = move = scroll = type = wait = refuse

async def main():

    async with async_playwright() as playwright, AsyncOpenAI(timeout=30, max_retries=0) as client:

        browser = await playwright.chromium.launch(env={}, chromium_sandbox=True)

        try:

            page = await browser.new_page(viewport={“width”: 1024, “height”: 768})

            await page.route(“**/*”, lambda route: route.abort())

            await page.set_content(

                “<title>Parcel pickup</title><main><h1>Parcel pickup</h1>”

                “<details><summary>Show pickup details</summary>”

                “<p>Locker 18. Pickup code: 6249.</p></details></main>”)

            driver = PickupDriver(page)

            tools = AsyncComputerToolset(driver)

            try:

                response = await tools.run(

                    client,

                    {“model”: “gpt-6.1-terra”, “store”: False,

                     “input”: “Take a screenshot. Open ‘Show pickup details’ and report “

                              “the locker and pickup code. Use only screenshots and left clicks.”},

                    before_action=driver.allowed,

                    max_steps=6,

                )

            finally:

                tools.close()

            if await page.locator(“details”).get_attribute(“open”) is None:

                raise RuntimeError(“Pickup details are still closed.”)

            print(“Verified:”, await page.locator(“details p”).inner_text())

            print(“Answer:”, response.output_text)

        finally:

            await browser.close()

if __name__ == “__main__”:

    asyncio.run(main())

You must install Chromium, replace the sample page with an environment you control, and extend the allowlist only for actions your task requires. Sites that process untrusted content need stricter controls than this sample provides.

How to Build an AI Workflow Automation With GPT-6.1 Terra

Use one end-to-end scenario rather than a list of disconnected tasks.

Example: Automating Invoice Data Entry

1. Read a sample invoice. (Document processing or structured extraction is more reliable than screen reading.)
2. Extract the vendor, invoice number, date, and total.
3. Validate required fields and flag inconsistencies.
4. Open a test accounting interface. (Computer use is useful here if no integration exists.)
5. Enter the verified values.
6. Review the populated fields.
7. Request human approval before submission.
8. Confirm the saved record and produce a completion report.

Steps 1 to 3 are often better handled by a document parser or a direct API. Computer use fits steps 4 to 5, where the accounting system has no usable integration. Step 7 is mandatory.

Example Prompt for Workflow Automation

Goal: Enter the invoice fields from the attached PDF into the test accounting form at the open browser tab. Context: This is a sandbox with fictional data. Permitted actions: Read the invoice, click into fields, and type values. Constraints: Do not click Submit, Save, or Approve. Do not open other tabs. Verification: After entry, confirm each field matches the extracted values and report any mismatch. Completion report: List the fields entered, the values, any flags, and the steps that still need human approval.

Other Practical Use Cases

• Product catalog updates: Repetitive edits across listings save time. Changes still need review, because a wrong price spreads quickly.
• CRM maintenance: Updating contact fields can be automated. Duplicate or conflicting records require a human decision.
• Spreadsheet administration: Formatting and copying can be automated. Formulas need a check, because a shifted cell reference can go unnoticed.
• Browser-based research: The model can gather information from several pages. Sources still need verification.
• Marketing asset quality checks: The model can flag cropping or text overlap. Its judgments need a human reviewer before publication.

Best Prompts for GPT-6.1 Terra Computer Use

Browser-Based Data Entry

Copy the item name, SKU, and price from the supplier page into the test catalog form. Fill only the Name, SKU, and Price fields. Do not change any other field. Stop and report if a required value is missing or the SKU already exists. Do not click Publish.

Spreadsheet and CRM Updates

In the open spreadsheet, update the Status column for rows 2 to 40 only, using the statuses listed in the attached table. Leave the Owner and Notes columns unchanged. If a record is missing or has conflicting values, skip it and list the row number in a final report. Do not delete rows.

Visual Quality Assurance

Open the staging product page and review the hero image, price label, and buy button. Report any cropping, overlapping text, or misaligned elements, with a screenshot reference for each issue. Do not edit or publish anything.

Prompt formula: Goal, context, permitted actions, constraints, verification, and completion report.

GPT-6.1 Terra Pricing, Reasoning, and Performance Optimization

OpenAI’s model page lists these standard API rates:

Prompts above 272,000 input tokens cost 2x input and cache rates and 1.5x output for the full request. Batch and Flex processing are 50% lower, and Fast mode is 2x. Computer-use tool calls carry a separate per-call fee, listed on OpenAI’s pricing page. Hosted environments charge separately. Screenshots count as image input.

API billing is separate from ChatGPT Work and Codex usage limits, which depend on your plan.

Start with low or medium reasoning effort and increase it only when accuracy requires it. The most useful metric is cost per successfully completed task, including retries and human review, rather than token price alone.

GPT-6.1 Terra Best Practices, Safety, and Limitations

Protect Credentials and Sensitive Data

Store API keys in a secret manager, not in source code. Use least-privilege access, isolated browser profiles, and dedicated test accounts. Setting store to false does not remove every form of data retention, so review OpenAI’s data controls before processing confidential information.

Prevent Unintended Actions

Require human approval for payments, purchases, deletions, external messages, and any transmission of sensitive data. Block those actions in your driver rather than relying on instructions alone.

Protect Against Prompt Injection

Text on a webpage or inside a document is untrusted input. It cannot override your instructions or grant new permissions. Use fresh browser sessions and limit network access so that malicious page content has less reach.

Know When Direct APIs Are Better

Use a direct API whenever the application offers one. APIs are more predictable and easier to audit. Use computer use for interfaces without a suitable integration.

Press coverage of OpenAI’s announcement reported that, in some simulated tests, Terra used methods it was not authorized to use. Read OpenAI’s system card before deploying the model in a sensitive workflow.

Common Implementation Mistakes

• Giving the model unrestricted access to accounts and networks.
• Allowing long action sequences without checkpoints.
• Acting on stale screenshots.
• Losing browser or desktop state between calls.
• Omitting timeouts and step limits.
• Reporting success without checking the final application state.

Final Verdict

ChatGPT Work and Codex suit people who want guided help with office and computer tasks without writing code. Teams with engineering resources should consider the API, which gives control over permissions, logging, and verification. When a supported application API exists, use it instead.

Start with one low-risk task. Test the full workflow, measure accuracy and completion time against your baseline, and add approval gates before expanding. Automate more only after the results hold up under review.

Frequently Asked Questions

How do I use GPT-6.1 Terra for computer use?

Use it in ChatGPT Work or Codex for guided tasks, or build an API integration with an execution environment. Start with a low-risk task and verify the result.

Is GPT-6.1 Terra available in standard ChatGPT?

Not in standard Chat. The model is offered in ChatGPT Work and Codex, on eligible plans.

Can GPT-6.1 Terra control a browser or desktop?

Not by itself. It proposes actions, and an environment you control must execute them.

How do I access the GPT-6.1 Terra API?

Use the model ID gpt-6.1-terra with an API key that has billing enabled. Tool calling requires the Responses API.

How do I set up GPT-6.1 Terra workflow automation?

Install the SDK and a browser runtime, implement a driver with an allowlist, run the loop with step limits, and verify the output.

Does GPT-6.1 Terra require coding?

ChatGPT Work and Codex do not require coding for basic use. A custom API integration does.

How much does GPT-6.1 Terra cost?

Through the API, the standard rate is $1 per million input tokens and $5 per million output tokens. Computer-use tool calls and hosted environments add charges.

Can GPT-6.1 Terra automate repetitive business tasks?

Yes, for tasks with clear steps, a bounded scope, and verification. Structured integrations are preferable where they exist.

Is GPT-6.1 Terra safe for business automation?

It can be used safely with least-privilege access, isolated environments, approval gates, and independent verification. Read OpenAI’s system card first.

When should I use a direct API instead of computer use?

Use a direct API whenever the application provides one. Computer use is for interfaces that lack a suitable integration.