Um agente que abre janelas e digita por você depende de uma premissa frágil: a de que a janela certa está na frente e recebendo teclado. Quando outra janela rouba o foco, quando o sistema abre um diálogo ou quando o aplicativo troca de tela no meio da tarefa, o texto pode cair no campo errado, em outro documento ou em outro programa.
O problema quase nunca está no modelo de linguagem. Está na camada de controle entre a decisão e a execução. Quem clica, foca e digita precisa confirmar, a cada passo, qual janela está ativa e qual elemento vai receber o texto.
Resumo rápido
- Janela ativa, visível e em primeiro plano são estados distintos, e o agente pode confundir os três.
- Handle, título e processo são mais confiáveis do que coordenadas de tela.
- Atalhos globais vão para quem tem o foco do sistema, não para a janela que o agente supõe usar.
- Toda ação destrutiva deve revalidar app dono, título e campo antes de digitar.
- Quando a validação falha, o correto é parar e registrar, não tentar de novo no escuro.
Por que o agente escreve no lugar errado
Um agente autônomo observa o estado, decide o próximo passo, age e observa de novo. Em desktop, a observação costuma ser uma captura de tela ou uma lista de janelas. A ação pode ser um clique em coordenada, um envio de teclas ou uma chamada de API do aplicativo.
O erro aparece quando observação e ação acontecem em momentos diferentes e o estado muda no intervalo. O agente lê que o editor está em primeiro plano, leva algumas centenas de milissegundos para montar a frase e envia as teclas. Nesse intervalo, uma notificação subiu ou o navegador abriu uma aba. As teclas vão para o novo dono do foco.
São três famílias de causa. A perda de foco, quando outra janela passa a receber entrada. A sobreposição, quando a janela continua ativa mas está atrás de outra, e o agente clica no que vê na captura antiga. E a mudança interna, quando um diálogo modal, uma tela de login ou um aviso de permissão interrompe o fluxo.
Nenhuma delas é resolvida por um modelo mais capaz. Todas são resolvidas por verificação de estado antes da ação. Por isso a confiabilidade de agentes passa tanto por engenharia de integração, tema de o que são agentes autônomos de IA, e tão pouco por qualidade de prompt.
Como o agente enxerga janelas
Há duas formas de perceber a interface. A visual recebe uma imagem da tela e infere onde estão botões e campos. A estrutural consulta a árvore de acessibilidade, o DOM da página ou a lista de janelas do sistema. Combinar as duas é o caminho mais seguro.
Na via estrutural, três identificadores importam. O título é legível, mas muda com frequência: inclui nome do arquivo, nome do cliente, indicador de alterações não salvas. O handle, identificador interno da janela, é estável enquanto ela existir, mas não sobrevive ao fechamento e reabertura. O identificador do processo diz qual aplicativo é o dono, o que separa duas instâncias do mesmo programa.
Em navegadores, o equivalente é a aba, com identificador, título e URL próprios. Ferramentas de automação tratam cada aba como página independente e permitem listar as páginas abertas em um contexto, como documenta a página de Pages do Playwright. O agente de navegador não precisa adivinhar qual aba está na frente: escolhe pelo identificador e age nela.
O agente de desktop depende da camada do sistema operacional. Ele pede a lista de janelas, descobre qual está em primeiro plano e, se for o caso, solicita ativação. É aí que aparecem diferenças entre plataformas e limites de permissão: um processo pode não conseguir trazer outra janela para a frente sem autorização do usuário.
Uma captura é uma fotografia com data e hora. Usá-la como verdade por vários segundos é agir sobre o passado. A lista de janelas consultada no instante da ação é mais confiável, desde que consulta e envio fiquem próximos.
Focar não é o mesmo que estar visível
Uma janela pode estar visível e não ter foco. Pode ter foco e estar minimizada. Pode estar em primeiro plano e não aceitar entrada, porque um modal do sistema bloqueia a aplicação. São estados independentes.
Ter foco significa receber teclado. Estar visível significa ser desenhada na tela. Estar em primeiro plano significa ocupar a camada superior da pilha. O agente precisa das três condições e deve confirmar cada uma separadamente.
No navegador, a API Document.hasFocus() informa se o documento, ou algum elemento dentro dele, está com foco. A documentação da Mozilla faz uma observação importante: um elemento pode ser o ativo do documento sem ter foco. Um campo dentro de uma janela que não está em primeiro plano é o elemento ativo daquele documento, mas não recebe teclado.
Atalhos globais seguem o foco do sistema
Atalhos globais não vão para o aplicativo que o agente imagina usar. Vão para quem tem o foco no sistema naquele instante. Se o agente envia uma combinação destinada ao editor e o foco está no navegador, ela pode fechar uma aba. Sequências que dependem de contexto interno também falham: um atalho de renomear camada só existe em um estado específico.
Campos que mantêm foco entre janelas
Alguns aplicativos preservam o último campo focado quando a janela perde e recupera o foco. Isso cria um risco silencioso: o agente reativa a janela e supõe que o cursor está onde deixou. Se o usuário clicou em outro campo nesse meio tempo, ou se a aplicação moveu o foco após um recarregamento, o texto vai para outro lugar.
A verificação correta não é lembrar onde o cursor estava, e sim perguntar qual elemento tem foco agora. Em páginas web, isso é o elemento ativo. Em desktop, depende da árvore de acessibilidade. Quando a aplicação não expõe essa informação, trate a digitação como operação de risco e peça confirmação humana.
Diálogos do sistema interrompem o fluxo
Diálogos de permissão, atualização e segurança aparecem por cima de tudo e capturam o teclado. Se o agente não os detecta, digita no diálogo ou tenta clicar no que está atrás dele. Um diálogo com botão padrão pode confirmar uma ação indesejada ao receber Enter. Se houver modal ativo, pare, registre o texto e devolva a decisão para um humano.
Padrões de projeto para confirmar o alvo
Os padrões abaixo são cumulativos. Nenhum resolve o problema sozinho, e a combinação é o que torna a automação previsível.
Confirme o identificador antes de cada ação destrutiva
Defina o que é destrutivo no seu contexto: enviar mensagem, apagar registro, confirmar pagamento, assinar documento, publicar conteúdo. Para essas ações, não confie em estado carregado no início da tarefa. Reconfirme identificador da janela, aplicativo dono e título imediatamente antes do envio. Custa uma consulta extra e transforma um erro silencioso em falha detectável.
Revalide título e aplicativo dono
Compare o título com tolerância. Nomes de arquivo mudam, contadores de mensagens aparecem e desaparecem, indicadores de alteração são acrescentados. Uma comparação por trecho normalizado, sem diferenciar maiúsculas, costuma ser mais útil do que igualdade exata.
O aplicativo dono, por outro lado, exige rigor. Duas instâncias do mesmo programa podem ter títulos parecidos e conteúdos diferentes. Se o agente precisa agir na instância de produção e encontra a de testes, o título pode não revelar. O identificador do processo revela.
Use pausa explícita e verificação de estado
Pausas fixas são frágeis. Dois segundos podem ser longos em uma máquina rápida e curtos em uma máquina sob carga. Prefira esperar por condição: janela visível, elemento presente, campo editável, foco confirmado. Defina limite de tempo e trate o estouro como falha, não como motivo para continuar.
Evite encadear ações sem observar o resultado intermediário. Cada ação relevante deve produzir evidência de que ocorreu. Se o agente clicou em um botão, confirme que a tela mudou como esperado antes de digitar no próximo campo.
Prefira APIs e seletores estáveis a coordenadas
Coordenadas envelhecem com layout, escala, resolução ou tema. Seletores semânticos, como papel do elemento, rótulo acessível ou identificador estável, sobrevivem melhor. Quando o aplicativo oferece API própria, ela é mais confiável porque não depende da camada visual.
Boas práticas de acessibilidade ajudam aqui. Interfaces com rótulos claros e ordem de foco previsível, como recomendado pelo W3C Web Accessibility Initiative, são mais fáceis de automatizar com segurança, inclusive em sites de terceiros.
Trate múltiplas instâncias do mesmo aplicativo
Com duas planilhas ou duas contas no mesmo serviço, o título não basta. Mantenha um mapa entre o alvo lógico da tarefa e o identificador físico da janela, atualizado a cada ciclo. Se o mapa aponta para uma janela que não existe mais, a tarefa para e pede nova resolução do alvo. Ao reabrir um aplicativo, o identificador muda: reencontre o alvo por conteúdo, não por suposição.
Função ensure_focus
O pseudocódigo abaixo concentra as verificações em um único ponto. A ideia é que nenhuma digitação aconteça sem passar por essa função, e que qualquer divergência resulte em falha segura.
funcao ensure_focus(alvo):
# alvo = { app, titulo_esperado, janela_id, campo, texto }
para tentativa de 1 ate 3:
janela = buscar_janela(janela_id = alvo.janela_id)
se janela for nula:
esperar_condicao(janela_existe(alvo.janela_id), limite = 2s)
continuar
se janela.processo != alvo.app:
registrar("app dono divergente", janela.processo)
retornar FALHA_SEGURA
se normalizar(janela.titulo) nao contem normalizar(alvo.titulo_esperado):
registrar("titulo divergente", janela.titulo)
retornar FALHA_SEGURA
se janela.minimizada ou nao janela.visivel:
restaurar(janela)
esperar_condicao(janela.visivel, limite = 2s)
focar(janela)
esperar_condicao(foco_confirmado(janela), limite = 2s)
se nao foco_confirmado(janela):
continuar
se dialogo_ativo(janela) existe:
registrar("dialogo de sistema", dialogo_ativo(janela).titulo)
retornar FALHA_SEGURA
campo = localizar_campo(janela, alvo.campo)
se campo for nulo ou nao campo.editavel:
registrar("campo ausente ou somente leitura")
retornar FALHA_SEGURA
focar(campo)
se elemento_ativo(janela) != campo:
registrar("campo nao recebeu foco")
retornar FALHA_SEGURA
digitar(campo, alvo.texto)
verificar_valor(campo, alvo.texto)
retornar SUCESSO
registrar("limite de tentativas atingido", alvo.janela_id)
retornar FALHA_SEGURATrês detalhes fazem diferença. O limite de tentativas evita laço infinito. A verificação do valor depois da digitação pega texto que entrou parcialmente. E a falha segura devolve controle em vez de improvisar uma alternativa.
Comparação de três estratégias de mira
| Estratégia | Como funciona | Resiste a mudança de foco | Manutenção | Quando usar |
|---|---|---|---|---|
| Coordenadas de tela | Clique em posição fixa calculada sobre a captura | Baixa: sobreposição ou rolagem muda o alvo | Alta: quebra com layout, zoom e resolução | Último recurso, interfaces sem estrutura exposta |
| Seletor de janela por handle | Localiza a janela pelo identificador e age nos elementos dela | Média: independe da posição, exige revalidar título e processo | Média: sobrevive a mudanças visuais, quebra ao reabrir | Desktop com várias janelas do mesmo app |
| API do aplicativo | Usa a interface oficial do programa ou serviço | Alta: não depende de foco nem de camada visual | Baixa: contrato estável | Sempre que existir e cobrir a operação |
A ordem de preferência é clara: API primeiro, seletor estrutural depois, coordenada por último. O ganho de usar API não é só confiabilidade. É auditoria, porque a ação fica registrada como chamada, não como sequência de cliques.
Exemplo: portal de guias em um escritório de contabilidade em Curitiba
Um escritório em Curitiba automatiza o envio mensal de guias. O fluxo baixa o arquivo no portal do órgão e envia a guia pelo atendimento web, com mensagem padronizada. Em dias de fechamento, o analista mantém várias abas abertas, além do sistema interno e do mensageiro.
Na primeira versão, o agente usava coordenadas. Funcionava de manhã, com a tela limpa. No fim do dia, com notificações e janelas sobrepostas, o texto da mensagem apareceu em um campo de busca do portal e a guia de um cliente ficou sem envio, sem erro visível.
A correção não trocou o modelo. O agente passou a operar o portal pela API do sistema de gestão, quando disponível. Nas etapas que exigiam navegador, identificava a aba pelo identificador e confirmava o nome do cliente no cabeçalho antes de anexar o arquivo. A mensagem final só sai depois de verificar que o anexo aparece na conversa certa.
O ganho foi de previsibilidade. O processo ficou mais lento em segundos e mais barato em retrabalho. O escritório passou a registrar cada envio com identificador da janela, título e horário, o que permite investigar divergências sem depender da memória de quem operou.
Erros comuns
- Assumir que a última janela aberta é a ativa. Abrir não garante foco, e o sistema pode reordenar a pilha.
- Digitar sem confirmar o campo. A janela é reativada e o texto vai para o último campo focado, que pode ter mudado.
- Usar Alt+Tab às cegas. A ordem de alternância depende do histórico do sistema, não da lógica da tarefa.
- Ignorar diálogos do sistema. Um modal captura o teclado e pode confirmar ações por engano.
- Confiar em captura de tela antiga. A imagem pode ter segundos de idade e o clique cai no que já não está lá.
- Não registrar a janela usada. Sem handle, título e processo, é impossível saber onde o texto foi parar.
- Repetir a ação após falha sem investigar. Repetir às cegas costuma duplicar o efeito do erro.
Perguntas frequentes
O agente consegue saber qual janela está em foco sem captura de tela?
Sim, na maioria dos casos. Em navegador há APIs de foco e elemento ativo. Em desktop, depende da camada de acessibilidade ou da API de janelas do sistema. Sem essas vias, trate a digitação como incerta.
Por que uma janela visível não recebe o texto?
Porque visibilidade e foco são estados diferentes. A janela pode estar desenhada na tela sem receber teclado, especialmente se outra está em primeiro plano ou se um modal está ativo.
Coordenadas de tela nunca devem ser usadas?
Devem ser o último recurso. São aceitáveis em protótipos ou sistemas legados sem estrutura exposta, desde que haja confirmação visual após o clique e plano para substituí-las.
Como lidar com duas instâncias do mesmo programa?
Use o identificador do processo, não o título. Mantenha um mapa entre o alvo lógico da tarefa e o identificador físico da janela, atualizado a cada ciclo.
O que fazer quando a validação falha?
Parar, registrar o estado encontrado e devolver a decisão para um humano ou para uma política explícita. Continuar sem validação transforma uma falha detectável em erro silencioso.
Fontes e leitura recomendada
- MDN: Document.hasFocus(), sobre elemento ativo e documento com foco.
- Playwright: Pages, sobre abas, pop-ups e páginas em automação de navegador.
- W3C Web Accessibility Initiative, referência sobre foco, rótulos e estrutura acessível.
- Model Context Protocol, padrão aberto para conectar agentes a ferramentas e sistemas.
Para seguir o tema, leia o guia de Model Context Protocol (MCP), sobre conexão padronizada entre agentes e ferramentas, e a página sobre plugins do ChatGPT, sobre como capacidades externas são acopladas ao assistente.
