TL;DR;

Construí o Testronaut, um agente autônomo de testes com IA, em apenas algumas semanas.

Ele transforma descrições em linguagem natural como "Faça login no app e verifique a página inicial" em testes web estruturados e automatizados usando o Playwright MCP.

Neste artigo, vou falar um pouco sobre:

  • Por que modelos locais (como Llama3.2 e Qwen2.5) me decepcionaram
  • Como dominar os fundamentos foi melhor que usar frameworks da moda
  • Como o Google ADK me ajudou a criar um sistema de colaboração entre agentes
  • Como o Testronaut planeja, executa e documenta tudo automaticamente

E o mais importante:

O trabalho apenas começou — estou construindo a base para o que pode se tornar a uma plataforma open-source de testes com IA.

🔗 Veja o repositório completo do Testronaut aqui!

Introdução

Nas últimas semanas, a Microsoft lançou o Playwright MCP, uma extensão inovadora do ecossistema Playwright que abriu várias possibilidades para automação.

Ao contrário das ferramentas tradicionais de automação de browser que exigem scripts manuais, o Playwright MCP introduziu o Model Context Protocol — uma forma de agentes de IA e sistemas externos interagirem com o navegador via comandos estruturados, permitindo um novo nível de abstração e controle.

Assim que li sobre isso, uma ideia me veio imediatamente:

"E se eu finalmente pudesse criar um agente que testasse minhas aplicações por mim, sem precisar escrever uma linha de código Selenium ou Playwright?"

Essa ideia marcou o início do Testronaut — um agente de IA autônomo projetado para transformar intenções em linguagem natural em testes web reais e documentados.

Neste artigo, quero compartilhar como construí isso em poucas semanas, as lições aprendidas ao longo do caminho, e por que acredito que estamos entrando em uma nova era para testes de software.

Definindo os Requisitos

Uma das premissas principais do Testronaut era clara desde o início:

Usar ferramentas open-source, manter gratuito e rodar localmente.

Inicialmente, imaginei que poderia lidar com todo o fluxo de automação usando o Ollama e modelos locais na minha máquina.

Parecia perfeito — baixo custo, controle total e nenhuma dependência de APIs na nuvem.

Porém, após vários dias apanhando com modelos como llama3.2:3b, llama3.1 e qwen2.5:14b, a realidade veio à tona:

A maioria dos desafios não era por causa da lógica do agente — mas sim pelas limitações de desempenho dos modelos locais.

Eles simplesmente não conseguiam raciocinar rápido o suficiente, falhavam em seguir planos com vários passos ou consumiam muitos recursos sob carga real.

Explorei alguns frameworks populares:

Cada um oferecia ideias e ferramentas interessantes, mas logo percebi algo essencial:

O maior desafio não é escolher o framework certo. É dominar os fundamentos — entender como agentes pensam, raciocinam e interagem.

(Óbvio? Talvez. Doloroso de aprender na prática? Com certeza.)

Aprendendo da Maneira Difícil (Sem Atalhos)

Assim como fazíamos antes da era do ChatGPT, voltei aos fundamentos:

Abri a documentação do Google ADK — minha escolha final de framework — e decidi realmente entender:

  • Como agentes autônomos funcionam
  • Como o Google ADK pode estruturar uma solução real
  • Como integrar corretamente as ferramentas (ao invés de apenas plugar um modelo e torcer por magia)

Parecia artesanato ancestral — como os astecas construindo algo sólido, pedra por pedra, sem atalhos.

Ler, experimentar e falhar (muito) virou minha rotina.

E aos poucos, a imagem ficou clara:

Construir um agente confiável não era sobre prompts mirabolantes ou modelos gigantes — era sobre desenhar um cérebro que pudesse:

  • Interpretar intenções com clareza
  • Planejar ações com lógica
  • Executar os passos com cuidado
  • Documentar cada movimento com precisão

Em outras palavras, não era "criar um chatbot inteligente", mas sim "construir um agente autônomo sério e disciplinado."

Definindo a Solução

Depois que entendi como construir agentes autônomos, o próximo passo era decidir o que exatamente o Testronaut deveria fazer.

Com um entendimento claro do propósito da plataforma, pude definir suas funcionalidades principais:

1. Criar um Plano de Testes a partir de uma Intenção em Linguagem Natural

O Testronaut nasceu para ajudar times de desenvolvimento a validar fluxos críticos de usuário, jornadas de experiência ou até scripts simples como:

"Acesse https://www.saucedemo.com/ e verifique se a página inicial carrega.

Preencha o formulário de login com standard_user e secret_sauce.

Na página de produtos, tire um snapshot do primeiro produto disponível."

(Nota rápida: SauceDemo é um site público criado especificamente para testes de QA, comumente usado em práticas de automação.)

A capacidade de descrever testes em linguagem natural é poderosa:

Permite que desenvolvedores — mesmo sem experiência em QA — simplesmente expressem o que desejam validar em português ou inglês comum.

O Testronaut transforma essa narrativa informal em um Plano de Teste estruturado, definindo explicitamente os resultados esperados de cada etapa.

Por exemplo, a narrativa acima se transforma em:

{
  "test_plan": {
    "name": "Teste de Carregamento da Homepage e Snapshot do Produto",
    "description": "Verificar o carregamento da homepage, login com credenciais padrão e captura de snapshot do primeiro produto na página de produtos.",
    "steps": [
      {
        "step": 1,
        "action": "Navegar para https://www.saucedemo.com/",
        "expected_result": "Homepage carregada com sucesso e visível."
      },
      {
        "step": 2,
        "action": "Verificar se o conteúdo da homepage está correto.",
        "expected_result": "Conteúdo da homepage visível e correto."
      },
      {
        "step": 3,
        "action": "Preencher o formulário de login com usuário 'standard_user' e senha 'secret_sauce' e submeter.",
        "expected_result": "Login realizado com sucesso e redirecionamento para a página de produtos."
      },
      {
        "step": 4,
        "action": "Na página de produtos, localizar o primeiro produto disponível.",
        "expected_result": "Primeiro produto localizado e visível."
      },
      {
        "step": 5,
        "action": "Tirar um snapshot do primeiro produto.",
        "expected_result": "Snapshot do primeiro produto salvo com sucesso."
      }
    ]
  }
}

Ao estruturar a intenção em JSON, o Testronaut consegue planejar, executar e documentar cada passo sistematicamente.

2. O Agente Executor

Com o Plano de Testes criado, o próximo passo natural era executá-lo.
Para isso, eu precisava de um segundo agente: um que fosse capaz de ler o Plano de Testes e realizar as ações correspondentes no navegador usando o Playwright MCP.

Felizmente, o Google ADK torna extremamente simples a integração com servidores MCP externos.

Veja como conectei o agente ao servidor Playwright MCP:

async def get_playwright_mcp_toolset():
    """Cria e configura o conjunto de ferramentas MCP.

    Retorna:
        Tuple[MCPToolset, AsyncExitStack]: O conjunto de ferramentas configurado e seu exit stack.
    """
    print("Tentando conectar ao servidor MCP Playwright...")
    tools, exit_stack = await MCPToolset.from_server(
        connection_params=StdioServerParameters(
            command='npx',
            args=["@playwright/mcp@latest", "--headless"],
        )
    )
    return tools, exit_stack

E dentro da definição do agente:

async def get_test_executor_agent():
    tools, exit_stack = await get_playwright_mcp_toolset()
    test_executor_agent = Agent(
        model=LiteLlm(
            model=constants.MODEL
        ),
        name="testronaut_test_executor",
        description="Um assistente inteligente para execução de testes.",
        instruction=prompt.TEST_EXECUTOR_PROMPT,
        output_key="STATE_TEST_EXECUTOR",
        tools=[get_test_plan, *tools]
    )
    return test_executor_agent, exit_stack

Dessa forma, o Agente Executor é capaz de:

  • Recuperar o Plano de Testes completo do estado da sessão;
  • Iterar passo a passo;
  • Executar ações precisas no navegador via MCP;
  • Analisar o estado atualizado da interface após cada ação;
  • Avançar para o próximo passo de forma inteligente.

Tudo que faltava era habilitar a colaboração entre os agentes...

3. Montando o Megazord Testronaut

O Google ADK fornece agentes especializados para coordenar a execução de múltiplos sub-agentes.
Eles são chamados de Workflow Agents.

Para o Testronaut, usei o mais simples e eficaz:
o Sequential Agent, que conecta os dois agentes que eu havia desenvolvido (o Planner e o Executor).

Veja como a conexão final ficou:

sequential_agent = SequentialAgent(
    name="TestronautEntrypointAgent",
    sub_agents=[test_planner_agent, test_executor_agent],
)

Simples assim!

Agora, os dois agentes colaboram perfeitamente:

  • O Test Planner cria um plano de testes estruturado a partir de uma entrada em linguagem natural;
  • O Test Executor interpreta esse plano e o executa passo a passo em um navegador real;

Essa colaboração forma o núcleo do que chamo de Testronaut — um agente autônomo capaz de entender intenções, executá-las com precisão e documentar cada etapa do caminho.

Conclusão: O Trabalho Apenas Começou!

Desenvolver o Testronaut me ajudou a entender os verdadeiros fundamentos por trás da construção de sistemas de colaboração entre agentes.

Não se tratava apenas de programar — era sobre aprender como agentes inteligentes podem planejar, executar e trabalhar juntos em direção a um objetivo comum.

O Testronaut ainda está dando seus primeiros passos.
Mas a visão para sua evolução já está bem definida e publicada abertamente em seu Manifesto.

Os próximos marcos serão compartilhados com todos vocês — e quem sabe, talvez uma comunidade surja para transformar o Testronaut em...

"A aplicação definitiva para testes comportamentais."

Obrigado por ler! 🚀
Fique ligado — a jornada está apenas começando.