Uso de la computadora

El uso de la computadora permite que un modelo maneje interfaces de navegador y de escritorio. Úsalo para completar formularios, probar flujos de usuario o realizar tareas en aplicaciones a través de su interfaz de usuario.

Tú proporcionas el entorno y ejecutas las solicitudes del modelo. El modelo usa capturas de pantalla y otros resultados de herramientas para decidir qué hacer a continuación. Elige cómo conectarlo a tu aplicación:

• Ejecución de código: el modelo escribe código que usa una biblioteca como PyAutoGUI o Playwright para manejar la interfaz. Una sola llamada puede combinar acciones, bucles o lógica condicional.
• La herramienta computer: el modelo devuelve acciones estructuradas de mouse y teclado que tu aplicación convierte en entradas para el navegador o el escritorio.

Si ya expones operaciones de la interfaz de usuario mediante llamada a funciones o herramientas MCP remotas, puedes conservar esa interfaz. Consulta Usa tus propias herramientas de interfaz de usuario para conocer las diferencias en la forma en que esas integraciones ejecutan herramientas y devuelven resultados.

Usa la ejecución de código

Una integración de ejecución de código proporciona al modelo una herramienta de función que acepta un script. Tu aplicación ejecuta el script en un entorno aislado de navegador o de escritorio y devuelve su salida, incluidas las capturas de pantalla. Mantén el entorno disponible entre llamadas para que el modelo pueda continuar a partir del trabajo anterior.

Ejecuta la aplicación de ejemplo

La aplicación de ejemplo de CUA (AUC) incluye implementaciones en JavaScript/Playwright y Python/PyAutoGUI, con tareas locales y una consola compartida:

1. Sigue las instrucciones de configuración de la implementación que elijas en un entorno aislado.
2. Elige un escenario integrado e inicia una ejecución.
3. Inspecciona las acciones, las capturas de pantalla y el estado final para evaluar si la tarea se completó correctamente.

Consulta el README de la aplicación para obtener información sobre la instalación, los permisos de escritorio y los entornos compatibles. Revisa Ejecuta de forma segura antes de adaptarla a sitios o cuentas reales.

Conecta tu propio entorno de ejecución

El siguiente ejemplo muestra el bucle de la API para un entorno de ejecución que tú proporcionas. Python y Ruby envían código Python a un entorno de ejecución de escritorio que usa PyAutoGUI; JavaScript usa Playwright para operar un navegador. Cada cliente expone una herramienta de función estándar y devuelve texto o imágenes con el call_id original.

La función auxiliar execute_in_sandbox o executeInSandbox envía código a tu entorno de ejecución y devuelve sus observaciones. Debe conservar la sesión del navegador o del escritorio, hacer cumplir los límites de ejecución y aplicar tus reglas de permisos. Estos son ejemplos de integración, independientes de la ejecución de la aplicación de ejemplo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72import json
import uuid

from openai import OpenAI
from openai.types.responses import (
    FunctionToolParam,
    ResponseInputParam,
)

def run_computer_use(endpoint, prompt, model="gpt-6-astra"):
    client = OpenAI()
    session_id = str(uuid.uuid4())
    tools: list[FunctionToolParam] = [
        {
            "type": "function",
            "name": "exec_py",
            "description": (
                "Run Python in a persistent desktop. Variables persist across calls. "
                "PyAutoGUI operations are synchronous. Available: pyautogui, time, "
                "log(value), and display(PIL_image). Inspect the screen with "
                "display(pyautogui.screenshot()) before acting. Use screenshot "
                "coordinates and check the screen after a short group of actions. "
                "Keep screenshots in memory and PyAutoGUI's fail-safe enabled."
            ),
            "parameters": {
                "type": "object",
                "properties": {"code": {"type": "string"}},
                "required": ["code"],
                "additionalProperties": False,
            },
            "strict": True,
        }
    ]
    next_input: ResponseInputParam = [{"role": "user", "content": prompt}]
    previous_response_id = None

    for turn in range(20):
        response = client.responses.create(
            model=model,
            tools=tools,
            input=next_input,
            previous_response_id=previous_response_id,
        )
        if response.status != "completed":
            raise RuntimeError(f"Response stopped with status: {response.status}")

        calls = [item for item in response.output if item.type == "function_call"]
        if not calls and any(
            item.type == "message" and item.phase != "commentary"
            for item in response.output
        ):
            print(response.output_text)
            return
        if turn == 19:
            raise RuntimeError(
                "The task reached the 20-response limit. Inspect the last result."
            )

        next_input = []
        for call in calls:
            if call.name != "exec_py":
                raise ValueError(f"Unexpected tool: {call.name}")
            code = json.loads(call.arguments)["code"]
            output = execute_in_sandbox(code, session_id, endpoint)
            next_input.append(
                {
                    "type": "function_call_output",
                    "call_id": call.call_id,
                    "output": output,
                }
            )
        previous_response_id = response.id

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74import { randomUUID } from "node:crypto";
import OpenAI from "openai";

async function runComputerUse(endpoint, prompt, model = "gpt-6-astra") {
  const client = new OpenAI();
  const sessionId = randomUUID();

  const tools = [
    {
      type: "function",
      name: "exec_js",
      description: `Run JavaScript in a persistent browser. Available: Playwright's
browser, context, and page objects; console.log(value); and display(base64Image).
Save reusable variables on globalThis. Inspect a screenshot before acting and
check the screen after a short group of actions. Keep screenshots in memory.
Use top-level await for async operations. Return images with display() and concise
text with console.log(). The context viewport is 1440x900.`,
      parameters: {
        type: "object",
        properties: { code: { type: "string" } },
        required: ["code"],
        additionalProperties: false,
      },
      strict: true,
    },
  ];

  let nextInput = [{ role: "user", content: prompt }];
  let previousResponseId;

  for (let turn = 0; turn < 20; turn++) {
    const response = await client.responses.create({
      model,
      tools,
      input: nextInput,
      previous_response_id: previousResponseId,
      reasoning: { effort: "low" },
    });
    if (response.status !== "completed") {
      throw new Error(`Response stopped with status: ${response.status}`);
    }
    const calls = response.output.filter(
      (item) => item.type === "function_call"
    );
    if (
      calls.length === 0 &&
      response.output.some(
        (item) => item.type === "message" && item.phase !== "commentary"
      )
    ) {
      console.log(response.output_text);
      return;
    }
    if (turn === 19) {
      throw new Error(
        "The task reached the 20-response limit. Inspect the last result."
      );
    }

    nextInput = [];
    for (const call of calls) {
      if (call.name !== "exec_js")
        throw new Error(`Unexpected tool: ${call.name}`);
      const { code } = JSON.parse(call.arguments);
      const output = await executeInSandbox(code, sessionId, endpoint);
      nextInput.push({
        type: "function_call_output",
        call_id: call.call_id,
        output,
      });
    }
    previousResponseId = response.id;
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57require "json"
require "openai"
require "securerandom"

def run_computer_use(endpoint, prompt)
  client = OpenAI::Client.new
  session_id = SecureRandom.uuid
  tools = [
    {
      type: :function,
      name: "exec_py",
      description: "Run Python in a persistent desktop. Variables persist across calls. PyAutoGUI operations are synchronous. Available: pyautogui, time, log(value), and display(PIL_image). Inspect the screen with display(pyautogui.screenshot()) before acting. Use screenshot coordinates and check the screen after a short group of actions. Keep screenshots in memory and PyAutoGUI's fail-safe enabled.",
      parameters: {
        type: :object,
        properties: { code: { type: :string } },
        required: ["code"],
        additionalProperties: false
      },
      strict: true
    }
  ]
  next_input = []
  next_input << {
    role: :user,
    content: prompt
  }
  history = {}
  20.times do |turn|
    response = client.responses.create(
      model: "gpt-6-astra", tools: tools, input: next_input, previous_response_id: history[:id]
    )
    raise "Response stopped with status: #{response.status}" unless response.status == OpenAI::Responses::ResponseStatus::COMPLETED

    calls = response.output.grep(OpenAI::Responses::ResponseFunctionToolCall)
    if calls.empty? && response.output.any? { |item| item.is_a?(OpenAI::Responses::ResponseOutputMessage) && item.phase != :commentary }
      puts(response.output_text)
      return response
    end
    raise "The task reached the 20-response limit" if turn == 19

    next_input.clear
    calls.each do |call|
      raise "Unexpected tool: #{call.name}" unless call.name == "exec_py"

      code = JSON.parse(call.arguments).fetch("code")
      raise "Expected Python source text" unless code.is_a?(String)

      output = execute_in_sandbox(code, session_id, endpoint)
      next_input << {
        type: :function_call_output,
        call_id: call.call_id,
        output: output
      }
    end
    history[:id] = response.id
  end
end

Para ver un adaptador de cliente completo y la estructura esperada de la salida de texto e imágenes, consulta Conéctate a tu servicio de ejecución. La interfaz del servicio en esos ejemplos pertenece a tu aplicación; no es un punto de acceso alojado por OpenAI.

Conserva el estado y devuelve observaciones

Mantén activa la sesión del navegador o del escritorio entre llamadas. Un espacio de nombres persistente de Python o JavaScript también puede conservar variables. Describe los objetos y las funciones auxiliares disponibles en la definición de la herramienta para que el modelo sepa qué puede usar.

Proporciona al modelo una captura de pantalla actual cuando se desconozca el estado de la interfaz de usuario. Después de un grupo breve de acciones, devuelve otra captura de pantalla para que pueda comprobar el resultado. Mantén las imágenes en memoria y usa detail: "original" para conservar la resolución. Si reduces la resolución de una captura de pantalla, convierte las coordenadas del modelo al sistema de coordenadas del entorno antes de ejecutar las acciones. Consulta Capturas de pantalla y resolución.

La conversación de la API y el entorno de ejecución tienen estados independientes. Conserva las llamadas a herramientas y sus salidas en la conversación y mantén disponible el entorno correspondiente en tu aplicación. Continuar una respuesta no restaura una sesión del navegador, el estado de inicio de sesión ni las variables del entorno de ejecución.

Usa la herramienta computer

Usa esta alternativa cuando tu integración espere acciones estructuradas en lugar de código generado. Para seguir el enfoque recomendado, comienza con la ejecución de código.

Para probar esta opción, sigue los mismos pasos de configuración de la aplicación de ejemplo, selecciona el modo Nativo y ejecuta un escenario integrado. Usa un modelo compatible con la herramienta computer.

El intercambio con la API consta de tres pasos: enviar una tarea, ejecutar las acciones devueltas y devolver una captura de pantalla. Los fragmentos de código que se muestran aquí usan una página con un control Mostrar filtros y un campo de búsqueda. Adapta esa tarea a tu propia interfaz al integrar la herramienta.

Para configurar el entorno y los manejadores de acciones, usa las recetas de integración.

Envía la tarea

Habilita computer en el arreglo tools y describe el resultado que quieres:

1
2
3
4
5
6
7
8
9
10
11
12import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5.6-sol",
  tools: [{ type: "computer" }],
  input:
    "Check whether the Filters panel is open. If it is not open, click Show filters. Then type penguin in the search box. Use the computer tool for UI interaction.",
});

console.log(JSON.stringify(response.output, null, 2));

1
2
3
4
5
6
7
8
9
10
11from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5.6-sol",
    tools=[{"type": "computer"}],
    input="Check whether the Filters panel is open. If it is not open, click Show filters. Then type penguin in the search box. Use the computer tool for UI interaction.",
)

print(response.output)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-5.6-sol",
		Tools: []responses.ToolUnionParam{{OfComputer: &responses.ComputerToolParam{}}},
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("Check whether the Filters panel is open. If it is not open, click Show filters. Then type penguin in the search box. Use the computer tool for UI interaction.")},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(response.Output)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.responses.ResponseCreateParams;
import java.util.List;
import java.util.Map;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-5.6-sol")
        .input(
            "Open the Filters panel if needed, then search for penguin. Use the computer tool for UI interaction.")
        .putAdditionalBodyProperty("tools", JsonValue.from(List.of(Map.of("type", "computer"))))
        .build();

client.responses().create(params).output().forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-5.6-sol",
  input: "Open the Filters panel if needed, then search for penguin. Use the computer tool for UI interaction.",
  tools: [{ type: :computer }]
)

puts(response.output)

Ejecuta las acciones solicitadas

Una llamada computer_call contiene un arreglo ordenado actions. Por ejemplo, esta llamada selecciona el campo de búsqueda y escribe penguin:

1
2
3
4
5
6
7
8
9
10
11
12
13{
  "output": [
    {
      "type": "computer_call",
      "call_id": "call_002",
      "actions": [
        { "type": "click", "button": "left", "x": 405, "y": 157 },
        { "type": "type", "text": "penguin" }
      ],
      "status": "completed"
    }
  ]
}

Tu manejador de acciones convierte estas solicitudes en entradas para el navegador o el sistema operativo. Ejecuta las acciones permitidas en orden y luego captura la pantalla actualizada. El modelo puede solicitar click, double_click, drag, move, scroll, keypress, type, wait o screenshot.

La primera llamada puede contener únicamente una acción screenshot. En ese caso, captura la pantalla actual y devuélvela sin cambiar la interfaz de usuario. El valor status: "completed" de una llamada significa que el modelo terminó de generar esa llamada; tu aplicación aún debe ejecutarla.

Usa los ejemplos de manejadores de acciones para las asignaciones de teclas, las trayectorias de arrastre y las teclas modificadoras.

Devuelve la captura de pantalla

Devuelve un computer_call_output cuyo call_id coincida con el de la llamada que procesaste. Usa previous_response_id para continuar la conversación con el modelo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import OpenAI from "openai";

const client = new OpenAI();

async function sendComputerScreenshot(response, callId, screenshotBase64) {
  const output = {
    type: "computer_screenshot",
    image_url: `data:image/png;base64,${screenshotBase64}`,
    detail: "original",
  };

  return await client.responses.create({
    model: "gpt-5.6-sol",
    tools: [{ type: "computer" }],
    previous_response_id: response.id,
    input: [
      {
        type: "computer_call_output",
        call_id: callId,
        output,
      },
    ],
  });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22from openai import OpenAI

client = OpenAI()


def send_computer_screenshot(response, call_id, screenshot_base64):
    return client.responses.create(
        model="gpt-5.6-sol",
        tools=[{"type": "computer"}],
        previous_response_id=response.id,
        input=[
            {
                "type": "computer_call_output",
                "call_id": call_id,
                "output": {
                    "type": "computer_screenshot",
                    "image_url": f"data:image/png;base64,{screenshot_base64}",
                    "detail": "original",
                },
            }
        ],
    )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/responses"
)

func main() {
	client := openai.NewClient()
	response, err := sendComputerScreenshot(client, "resp_abc123", "call_abc123", "<base64 bytes here>")
	if err != nil {
		panic(err)
	}
	fmt.Println(response.Output)
}

func sendComputerScreenshot(client openai.Client, responseID string, callID string, screenshotBase64 string) (*responses.Response, error) {
	screenshot := responses.ResponseComputerToolCallOutputScreenshotParam{
		ImageURL: openai.String("data:image/png;base64," + screenshotBase64),
	}
	screenshot.SetExtraFields(map[string]any{"detail": "original"})
	return client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model:              "gpt-5.6-sol",
		Tools:              []responses.ToolUnionParam{{OfComputer: &responses.ComputerToolParam{}}},
		PreviousResponseID: openai.String(responseID),
		Input: responses.ResponseNewParamsInputUnion{OfInputItemList: responses.ResponseInputParam{
			responses.ResponseInputItemParamOfComputerCallOutput(callID, screenshot),
		}},
	})
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.core.JsonValue;
import com.openai.models.responses.ResponseComputerToolCallOutputScreenshot;
import com.openai.models.responses.ResponseCreateParams;
import com.openai.models.responses.ResponseInputItem;
import java.util.List;
import java.util.Map;

String responseId = "resp_abc123";

String computerCallId = "call_abc123";

String screenshotBase64 = "<base64 bytes here>";

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-5.6-sol")
        .input(
            ResponseCreateParams.Input.ofResponse(
                List.of(
                    ResponseInputItem.ofComputerCallOutput(
                        ResponseInputItem.ComputerCallOutput.builder()
                            .callId(computerCallId)
                            .output(
                                ResponseComputerToolCallOutputScreenshot.builder()
                                    .imageUrl("data:image/png;base64," + screenshotBase64)
                                    .putAdditionalProperty("detail", JsonValue.from("original"))
                                    .build())
                            .build()))))
        .previousResponseId(responseId)
        .putAdditionalBodyProperty("tools", JsonValue.from(List.of(Map.of("type", "computer"))))
        .build();

client.responses().create(params).output().forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21require "openai"

client = OpenAI::Client.new
response = client.responses.create(
  model: "gpt-5.6-sol",
  previous_response_id: "resp_abc123",
  input: [
    {
      type: :computer_call_output,
      call_id: "call_abc123",
      output: {
        type: :computer_screenshot,
        image_url: "data:image/png;base64,<base64 bytes here>",
        detail: :original
      }
    }
  ],
  tools: [{ type: :computer }]
)

puts(response.output)

Las mismas indicaciones sobre capturas de pantalla y estado se aplican a este bucle. Mantén el entorno disponible mientras previous_response_id continúa la conversación con el modelo.

Continúa hasta que el modelo deje de devolver elementos computer_call. Inspecciona el resto de la salida para identificar una respuesta, una solicitud de ayuda u otra llamada a una herramienta, y verifica el resultado en la aplicación. En este ejemplo, el panel Filtros debería estar abierto y el campo de búsqueda debería contener penguin.

Consulta Repite el bucle de uso de la computadora para ver la estructura básica del bucle, incluidas las funciones auxiliares necesarias para las acciones y las capturas de pantalla.

Ejecuta de forma segura

El uso de la computadora puede afectar cuentas y datos reales. Aplica estos controles tanto en tu aplicación y tu entorno de ejecución como en las instrucciones del modelo:

• Restringe el entorno. Usa un navegador aislado o una máquina virtual y una lista de sitios y acciones permitidos. Limita el acceso a lo que requiera la tarea.
• Trata el contenido de la pantalla como no confiable. El texto de una página, un documento o el resultado de una herramienta no puede otorgar permisos ni anular las instrucciones del usuario.
• Confirma las acciones con consecuencias importantes. Asegúrate de que los usuarios mantengan el control sobre las compras, la transmisión de datos, los cambios destructivos y otras acciones difíciles de revertir. Escribir información sensible en un formulario cuenta como transmisión.
• Limita y verifica la ejecución. Establece límites de pasos, tiempo o costo, permite cancelar la ejecución y comprueba el resultado real en lugar de basarte únicamente en la respuesta final del modelo.

Consulta la guía sobre confirmación y consentimiento para conocer los requisitos específicos de aprobación, cómo ceder el control a una persona y ejemplos de prompts.

Próximos pasos

• Usa las recetas de integración para configurar el entorno, implementar manejadores de acciones, capturar pantallas y crear adaptadores para servicios de ejecución.
• Sigue la guía de migración desde computer-use-preview al actualizar una integración anterior.
• Explora la aplicación de ejemplo de CUA (AUC) para ver flujos de trabajo completos en el navegador y el escritorio.