O Google acaba de lançar seu novo navegador baseado em agente do Google DeepMind, desenvolvido com Gemini 2.5 Professional. Construído na API Gemini, ele pode “ver” e interagir com interfaces da internet e de aplicativos: clicando, digitando e rolando como um ser humano. Este novo modelo de automação internet de IA preenche a lacuna entre compreensão e ação. Neste artigo, exploraremos os principais recursos do Gemini Laptop Use, seus recursos e como integrá-lo ao seu fluxos de trabalho de IA agente.
O que é o uso do computador Gemini 2.5?
Gemini 2.5 Laptop Use é um assistente de IA que pode controlar um navegador usando linguagem pure. Você descreve uma meta e ela executa as etapas necessárias para concluí-la. Baseado na nova ferramenta computer_use da API Gemini, ele analisa capturas de tela de uma página da internet ou aplicativo e, em seguida, gera ações como “clicar”, “digitar” ou “rolar”. Um cliente como o Playwright executa essas ações e retorna a próxima tela até que a tarefa seja concluída.
O modelo interpreta botões, campos de texto e outros elementos da interface para decidir como agir. Como parte de Gêmeos 2.5 Próele herda um forte raciocínio visible, permitindo-lhe concluir tarefas complexas na tela com o mínimo de intervenção humana. Atualmente, ele está focado em ambientes de navegador e não controla aplicativos de desktop fora do navegador.
Principais capacidades
- Automatize a entrada de dados e o preenchimento de formulários em websites. O agente será capaz de encontrar campos, inserir texto e enviar formulários quando apropriado.
- Understand testes de aplicativos da internet e fluxos de usuários, clicando em páginas, acionando eventos e garantindo que os elementos apareçam com precisão.
- Faça pesquisas em vários websites. Por exemplo, pode coletar informações sobre produtos, preços ou avaliações em várias páginas de comércio eletrônico e resumir os resultados.
Como acessar o uso do computador Gemini 2.5?
Os recursos experimentais do Gemini 2.5 Laptop Use agora estão disponíveis publicamente para qualquer desenvolvedor usar. Os desenvolvedores só precisam se inscrever na API Gemini by way of Estúdio de IA ou Vertex AI e, em seguida, solicitar acesso ao modelo de uso do computador. O Google fornece documentação, exemplos de código executável e implementação de referência que você pode experimentar. Por exemplo, a documentação da API Gemini fornece um exemplo do loop do agente de quatro etapas, completo com exemplos em Python usando o SDK GenAI do Google Cloud e dramaturgo.
Você configuraria um ambiente de automação de navegador, como o Playwright, para isso siga estas etapas:
- Inscreva-se na API Gemini por meio do AI Studio ou Vertex AI.
- Solicite acesso ao modelo de uso de computador.
- Revise a documentação do Google, exemplos de código executável e implementações de referência.
Por exemplo, há um exemplo de loop de agente usando quatro etapas em Python fornecido pelo Google com o GenAI SDK e Playwright para automatizar o navegador.
Leia também: Como acessar e usar a API Gemini?
Configurando o Ambiente
Aqui está o exemplo geral de como é a configuração com seu código:
Configuração inicial e cliente Gemini
# Load atmosphere variables
from dotenv import load_dotenv
load_dotenv()
# Initialize Gemini API shopper
from google import genai
shopper = genai.Shopper()
# Set display screen dimensions (really helpful by Google)
SCREEN_WIDTH = 1440
SCREEN_HEIGHT = 900 Começaremos configurando as variáveis de ambiente que serão carregadas para as credenciais da API e o cliente Gemini será inicializado. As dimensões de tela recomendadas pelo Google são definidas e posteriormente usadas para converter coordenadas normalizadas nos valores reais de pixel necessários para ações na IU.
Automação do navegador com Playwright
A seguir, o código configura o Playwright para automação do navegador:
from playwright.sync_api import sync_playwright
playwright = sync_playwright().begin()
browser = playwright.chromium.launch(
headless=False,
args=(
'--disable-blink-features=AutomationControlled',
'--disable-dev-shm-usage',
'--no-sandbox',
)
)
context = browser.new_context(
viewport={"width": SCREEN_WIDTH, "top": SCREEN_HEIGHT},
user_agent="Mozilla/5.0 (Home windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/131.0.0.0 Safari/537.36",
)
web page = context.new_page() Aqui estamos lançando um navegador Chromium, utilizando sinalizadores antidetecção para evitar que as páginas da internet reconheçam a automação. Em seguida, definimos uma janela de visualização e um agente de usuário realistas para emular um usuário regular e criar uma nova página para navegar e automatizar a interação.
Definindo a configuração da tarefa e do modelo
Depois que o navegador estiver configurado e pronto para uso, o modelo é fornecido com o objetivo do usuário e a captura de tela inicial:
from google.genai.varieties import Content material, Half
USER_PROMPT = "Go to BBC Information and discover as we speak's prime know-how headlines"
initial_screenshot = web page.screenshot(kind="png")
contents = (
Content material(position="consumer", elements=(
Half(textual content=USER_PROMPT),
Half.from_bytes(information=initial_screenshot, mime_type="picture/png")
))
) O USER_PROMPT outline qual tarefa de linguagem pure o agente realizará. Ele captura uma captura de tela inicial do estado da página do navegador, que será enviada junto com o immediate ao modelo. Eles são encapsulados com o objeto Content material que posteriormente também será passado para o modelo Gemini.
Por fim, o loop do agente é executado enviando o standing ao modelo e executando as ações que ele retorna:
A ferramenta computer_use solicita que o modelo crie chamadas de função, que são então executadas no ambiente do navegador. thinking_config contém as etapas intermediárias de raciocínio para fornecer transparência ao usuário, o que pode ser útil para posterior depuração ou compreensão do processo de tomada de decisão do agente.
from google.genai.varieties import varieties
config = varieties.GenerateContentConfig(
instruments=(varieties.Device(
computer_use=varieties.ComputerUse(
atmosphere=varieties.Atmosphere.ENVIRONMENT_BROWSER
)
)),
thinking_config=varieties.ThinkingConfig(include_thoughts=True),
)Como funciona?
Gemini 2.5 Laptop Use é executado como um agente de circuito fechado. Você atribui uma meta e uma captura de tela, ele prevê a próxima ação, executa-a por meio do cliente e, em seguida, analisa a tela atualizada para decidir o que fazer a seguir. Esse ciclo de suggestions permite que Gêmeos veja, raciocine e aja como um ser humano navegando em um navegador. Todo o processo é alimentado pelo computer_use ferramenta na API Gemini.
O Ciclo de Suggestions Central
O agente opera em um ciclo contínuo até que a tarefa seja concluída:
- Meta de entrada e captura de tela: o modelo recebe as instruções do usuário (por exemplo, “encontre as principais manchetes tecnológicas”) e a captura de tela do estado atual do navegador.
- Gerar ações: o modelo sugere uma ou mais chamadas de função que correspondem a ações de UI usando a ferramenta computer_use.
- Executar ações: o programa cliente realiza essas chamadas de função no navegador.
- Capturar suggestions: uma nova captura de tela e URL são capturados e enviados de volta ao modelo.
O que o modelo vê em cada iteração
A cada iteração, o modelo recebe três informações principais:
- Solicitação do usuário: O objetivo ou instrução em linguagem pure (exemplo: “encontre as principais manchetes”)
- Captura de tela atual: uma imagem da janela do seu navegador ou aplicativo e seu estado atual
- Histórico de ação: Um registro das ações recentes realizadas até o momento (para contextualizar)
O modelo analisa a captura de tela e o objetivo do usuário e gera um ou mais chamadas de função—cada um representando uma ação da UI. Por exemplo:
{"title": "click_at", "args": {"x": 400, "y": 600}}Isso instruiria o agente a clicar nessas coordenadas.
Executando ações no navegador
O programa cliente (usando APIs de mouse e teclado do Playwright) executa essas ações no navegador. Aqui está um exemplo de como as chamadas de função são executadas:
def execute_function_calls(candidate, web page, screen_width, screen_height):
for half in candidate.content material.elements:
if half.function_call:
fname = half.function_call.title
args = half.function_call.args
if fname == "click_at":
actual_x = int(args("x") / 1000 * screen_width)
actual_y = int(args("y") / 1000 * screen_height)
web page.mouse.click on(actual_x, actual_y)
elif fname == "type_text_at":
actual_x = int(args("x") / 1000 * screen_width)
actual_y = int(args("y") / 1000 * screen_height)
web page.mouse.click on(actual_x, actual_y)
web page.keyboard.kind(args("textual content"))
# ...different supported actions...A função analisa o FunctionCall entradas retornadas pelo modelo e executa cada ação no navegador. Ele converte coordenadas normalizadas (0–1000) em valores reais de pixel com base no tamanho da tela.
Capturando Suggestions para o Próximo Ciclo
Após executar as ações, o sistema captura o novo estado e o envia de volta ao modelo:
def get_function_responses(web page, outcomes):
screenshot_bytes = web page.screenshot(kind="png")
current_url = web page.url
function_responses = ()
for title, consequence, extra_fields in outcomes:
response_data = {"url": current_url}
response_data.replace(consequence)
response_data.replace(extra_fields)
function_responses.append(
varieties.FunctionResponse(
title=title,
response=response_data,
elements=(varieties.FunctionResponsePart(
inline_data=varieties.FunctionResponseBlob(
mime_type="picture/png",
information=screenshot_bytes
)
))
)
)
return function_responsesO novo estado do navegador está envolto em FunctionResponse objetos, que o modelo usa para raciocinar sobre o que fazer a seguir. O loop continua até que o modelo não retorne mais nenhuma chamada de função ou até que a tarefa seja concluída.
Leia também: Os 7 principais agentes de uso de computador
Etapas do Loop do Agente
Depois de carregar a ferramenta computer_use, um loop de agente típico segue estas etapas:
- Envie uma solicitação ao modelo: Inclua o objetivo do usuário e uma captura de tela do estado atual do navegador na chamada da API
- Receba resposta do modelo: O modelo retorna uma resposta contendo texto e/ou uma ou mais entradas FunctionCall.
- Execute as ações: O código do cliente analisa cada chamada de função e executa a ação no navegador.
- Seize e envie suggestions: Após a execução, o cliente faz uma nova captura de tela e anota a URL atual. Ele os envolve em um FunctionResponse e os envia de volta ao modelo como a próxima mensagem do usuário. Isso informa ao modelo o resultado de sua ação para que ele possa planejar o próximo passo.
Este processo é executado automaticamente em um loop. Quando o modelo para de gerar novas chamadas de função, ele sinaliza que a tarefa foi concluída. Nesse ponto, ele retorna qualquer saída de texto last, como um resumo do que foi realizado. Na maioria dos casos, o agente passará por vários ciclos antes de completar a meta ou atingir o limite de turno definido.
Mais ações suportadas
A ferramenta Laptop Use do Gemini possui dezenas de ações de UI integradas. O conjunto básico inclui ações típicas de aplicativos baseados na Net, incluindo:
- open_web_browser: Inicializa o navegador antes do início do loop do agente (normalmente gerenciado pelo cliente).
- clique_em: Clica em uma coordenada específica (x, y) na página.
- type_text_at: Clica em um ponto e digita uma determinada string, opcionalmente pressionando Enter.
- navegar: Abre um novo URL no navegador.
- go_back / go_forward: Retrocede ou avança no histórico do navegador.
- pairar_em: Transfer o mouse para um ponto específico para acionar efeitos de foco.
- scroll_document / scroll_at: Rola a página inteira ou uma seção específica.
- combinação_chave: Simula o pressionamento de atalhos de teclado.
- espere_5_segundos: Pausa a execução, útil para aguardar animações ou carregamentos de páginas.
- arrastar e soltar: Clica e arrasta um elemento para outro native na página.
A documentação do Google menciona que o exemplo de implementação inclui as três ações mais comuns: open_web_browser, click_at e type_text_at. Você pode estender isso adicionando quaisquer outras ações necessárias ou excluindo aquelas que não são relevantes para o seu fluxo de trabalho.
Desempenho e benchmarks
Gemini 2.5 Laptop Use tem um excelente desempenho em tarefas de controle de UI. Nos testes do Google, alcançou mais de 70% de precisão com latência de cerca de 225 ms, superando outros modelos em benchmarks internet e móveis, como navegação em websites e conclusão de fluxos de trabalho de aplicativos.
Na prática, o agente pode lidar com tarefas como preenchimento de formulários e recuperação de dados de maneira confiável. Benchmarks independentes o classificam como o modelo público de IA mais preciso e rápido para automação simples de navegador. Seu forte desempenho vem do raciocínio visible do Gemini 2.5 Professional e de um pipeline de API otimizado. Como ainda está em pré-visualização, você deve monitorar suas ações, pois erros ocasionais podem ocorrer.
Leia também:
Conclusão
O Gemini 2.5 Laptop Use é um desenvolvimento significativo na automação suportada por IA, permitindo que os agentes interajam de forma eficaz e eficiente com interfaces reais. Com ele, os desenvolvedores podem automatizar tarefas como navegação na internet, entrada ou extração de dados com grande precisão e velocidade.
Em seu estado disponível publicamente, podemos oferecer aos desenvolvedores uma maneira de experimentar com segurança os recursos do Gemini 2.5 Laptop Use, adaptando-os aos seus próprios fluxos de trabalho. No geral, representa uma estrutura flexível através da qual é possível construir assistentes inteligentes de próxima geração ou fluxos de trabalho de automação poderosos para uma variedade de usos e domínios.
Olá! Sou Vipin, um entusiasta apaixonado por ciência de dados e aprendizado de máquina, com uma sólida base em análise de dados, algoritmos de aprendizado de máquina e programação. Tenho experiência prática na construção de modelos, gerenciamento de dados confusos e solução de problemas do mundo actual. Meu objetivo é aplicar insights baseados em dados para criar soluções práticas que gerem resultados. Estou ansioso para contribuir com minhas habilidades em um ambiente colaborativo enquanto continuo aprendendo e crescendo nas áreas de Ciência de Dados, Aprendizado de Máquina e PNL.
Faça login para continuar lendo e desfrutar de conteúdo com curadoria de especialistas.