Arquitetura: Capturas de ecrã, ações e o ciclo de interação
Nesta página
Lição reescrita a 3 de novembro de 2026 com base no guia Computer use da OpenAI e nas receitas de integração do Computer use: Este curso baseava-se anteriormente na API da Anthropic (
import anthropic, ferramentacomputer_20241022). Utiliza agora a ferramentacomputerda API Responses da OpenAI, com ações agrupadas numcomputer_calle capturas de ecrã devolvidas viacomputer_call_output. Removemos as contagens de tokens e estimativas de duração sem fontes da versão anterior. Fontes: Computer use · Receitas de integração.
O ciclo perceção-ação
Toda a arquitetura do Computer Use resume-se a um único ciclo: observar → decidir → agir → observar. Enquanto este ciclo não estiver claro na sua mente, as suas automações permanecerão erráticas; assim que o compreender, o resto será apenas infraestrutura.
A diferença face a um script Selenium reside no local onde reside o conhecimento. O Selenium executa cegamente uma sequência pré-determinada: clique aqui, depois ali, depois escreva isto. O Computer Use escolhe o próximo passo apenas depois de ver o resultado do anterior. Aparece um pop-up, uma página demora mais a carregar ou o rótulo de um botão muda da noite para o dia: em todos os três casos, o modelo vê a situação real e ajusta-se, enquanto o script continua a recitar no vazio.
Com a ferramenta computer da OpenAI, a troca ocorre em três passos: envia a tarefa, executa as ações que o modelo devolve e, em seguida, reenvia uma captura de ecrã. A sua aplicação controla o rato e o teclado; o modelo apenas toma as decisões.
O ponto de partida: a captura de ecrã
Cada turno baseia-se numa imagem do estado atual do ecrã. Esta captura de ecrã provém de um navegador controlado pelo Playwright — o caso mais comum para automação web —, de um ambiente de trabalho virtual ao automatizar uma aplicação de desktop ou de um contentor Docker que isola o agente. A OpenAI recomenda a utilização de um navegador isolado ou de uma máquina virtual em todos os casos.
import base64
def capture_screen(page) -> str:
"""Capture the screen with Playwright and return the PNG image as base64."""
return base64.b64encode(page.screenshot()).decode("utf-8")
A captura de ecrã é devolvida ao modelo como um URL de dados PNG. Conta como uma entrada de imagem, pelo que afeta o custo de cada turno: o tamanho da janela que captura é um parâmetro de design real.
Análise e decisão
O modelo recebe a tarefa, o histórico da conversa e a captura de ecrã mais recente. A sua resposta não é uma frase, mas um item computer_call, que transporta uma lista ordenada de ações a executar. Eis um exemplo da documentação da OpenAI que seleciona um campo de pesquisa e depois escreve uma palavra:
{
"type": "computer_call",
"call_id": "call_002",
"actions": [
{ "type": "click", "button": "left", "x": 405, "y": 157 },
{ "type": "type", "text": "penguin" }
],
"status": "completed"
}
Dois detalhes são importantes. A primeira chamada pode conter apenas uma ação screenshot: o modelo está a pedir para ver o ecrã antes de agir, e deve devolver uma captura de ecrã sem alterar nada. Além disso, status: "completed" significa que o modelo terminou de gerar a chamada, não que as ações foram executadas: cabe-lhe a si executá-las.
O repertório de ações
O vocabulário disponível para o modelo é intencionalmente limitado; combinados, estes primitivos cobrem a maior parte do que um humano faz com um rato e um teclado.
| Ação | Descrição | Campos |
|---|---|---|
click | Clicar numa posição | x, y, button (left, right, wheel, back, forward) |
double_click | Duplo clique | x, y |
drag | Arrastar ao longo de um caminho | path (lista de pontos) |
move | Mover o ponteiro | x, y |
scroll | Deslocar a vista | x, y, scroll_x, scroll_y |
keypress | Tecla ou combinação | keys (ex.: ["CTRL", "A"]) |
type | Escrever texto | text |
wait | Aguardar o carregamento da página | — |
screenshot | Solicitar uma nova captura de ecrã | — |
O fluxo completo
Reunidos, estes elementos criam o seguinte ciclo, modelado na documentação da OpenAI. Enquanto a resposta contiver um computer_call, executa as suas ações, captura o ecrã e devolve a captura de ecrã num computer_call_output que reutiliza o mesmo call_id; o previous_response_id liga cada turno ao anterior.
from openai import OpenAI
client = OpenAI()
def computer_use_loop(page, task: str):
"""Computer Use loop with the computer tool from the Responses API."""
response = client.responses.create(
model="gpt-6.1-sol",
tools=[{"type": "computer"}],
input=task,
)
while True:
call = next(
(item for item in response.output if item.type == "computer_call"),
None,
)
if call is None:
return response.output_text # no more actions requested: task is done
execute_actions(page, call.actions) # your action handler (Lesson 4)
screenshot = capture_screen(page)
response = client.responses.create(
model="gpt-6.1-sol",
tools=[{"type": "computer"}],
previous_response_id=response.id,
input=[{
"type": "computer_call_output",
"call_id": call.call_id,
"output": {
"type": "computer_screenshot",
"image_url": f"data:image/png;base64,{screenshot}",
"detail": "original",
},
}],
)
Este ciclo ainda não tem salvaguardas: em produção, limite o número de turnos, a duração e o custo; pare se uma chamada incluir verificações de segurança pendentes (pending_safety_checks); e verifique o resultado real em vez de confiar apenas na mensagem final do modelo. Estas são as diretrizes de segurança da OpenAI, abordadas na Lição 12.
O custo de um turno do ciclo
Cada pedido à API Responses cobra tokens de entrada e de saída, e cada captura de ecrã conta como uma entrada de imagem; um ambiente alojado pode ser faturado separadamente. O custo de uma tarefa depende, portanto, do número de turnos, do tamanho da captura de ecrã e do modelo — e cresce mais rapidamente do que o número de turnos, porque mesmo com previous_response_id, todos os tokens de entrada das respostas anteriores na cadeia são novamente cobrados como entrada em cada pedido. A OpenAI disponibiliza uma calculadora de custos de imagem e expõe a utilização de cada pedido: meça nos seus próprios fluxos de trabalho antes de definir um orçamento. Um script Selenium fará sempre a mesma coisa de forma mais rápida e barata — mas terá de o reescrever da próxima vez que o formulário mudar, o que o agente não exige.
Pontos-chave
- O ciclo tarefa → ações → captura de ecrã é o coração do Computer Use; a sua aplicação executa as ações
- Com a OpenAI, declare a ferramenta com
tools=[{"type": "computer"}]na API Responses - Um
computer_calltransporta uma lista ordenada de ações (click,type,scroll,keypress, etc.) a executar em sequência - A captura de ecrã é devolvida ao modelo num
computer_call_outputcom o mesmocall_id, encadeado porprevious_response_id - Cada turno custa tokens e uma imagem: limite os turnos e meça antes de definir um orçamento