A AWS deixou agentes construírem um emulador da sua cloud sem revisão humana do código. A revisão passou para os testes

Surya Pratap
By Surya Pratap

13 de novembro de 2026

8 min read

AI & Technology
Diagrama em duas partes intitulado «Ninguém eliminou a revisão. Passou para os testes». À esquerda, sob «Como os agentes construíram o AWS Emulator», quatro passos: os autores de testes gravam cada teste contra a AWS real; os detetores de problemas repetem os testes contra o emulador; os corretores ficam com um problema cada um e alteram o código; e uma porta de fusão verifica compilação, normas, segurança e fidelidade. À direita, sob «O que dizem as pontuações publicadas», uma contagem independente das pontuações no lançamento: 56,5% de 42.937 testes de fidelidade aprovados, 40 serviços com 90% ou mais, 124 serviços abaixo de 50%, e políticas de IAM que não são avaliadas como a AWS as avalia. No rodapé, as fontes: o anúncio da AWS de 11 de novembro de 2026 e uma análise das suas pontuações.Ver o processo e as pontuaçõesHover to explore
Os agentes puderam dispensar o revisor humano porque cada alteração era verificada contra o sistema real.

A 11 de novembro, a AWS lançou o AWS Emulator, um substituto local dos seus serviços que pode correr no seu portátil para construir e testar aplicações sem chamar a cloud. A ferramenta é útil, mas para os fundadores importa mais a afirmação que a acompanhou. Nas palavras de Matthew Goldberg, o engenheiro principal sénior que assinou o anúncio: «O emulador foi escrito inteiramente por agentes autónomos. A nossa equipa não escreveu nem reviu nada do código.» A maioria das startups descobriu este ano que a revisão humana é o passo mais lento numa equipa que trabalha com muitos agentes. A AWS mostrou uma forma de a eliminar, e o que interessa são as condições que o tornaram possível.

Este artigo baseia-se no anúncio da AWS de 11 de novembro de 2026, na notícia da Help Net Security de 12 de novembro e numa análise da i-SCOOP que contou as pontuações de fidelidade publicadas. O artigo da AWS não dá taxas de aprovação, por isso todas as pontuações abaixo são a contagem da i-SCOOP, não números da AWS. A leitura a partir da secção 4 é minha.

1. O que a AWS lançou

A AWS descreve o produto de forma simples: «um emulador local dos serviços da AWS que pode correr na sua máquina para construir e testar as suas aplicações da AWS». A cobertura acrescenta os pormenores:

  • Âmbito. A AWS diz que o projeto partiu de «438 modelos de API da AWS». A i-SCOOP traduz isso em mais de 200 serviços, com pontuações publicadas para 355.
  • Como se executa. A Help Net Security enumera quatro vias: através de um agente de programação com IA, como pacote Linux, em Docker, ou integrado num processo de testes em Rust.
  • Licença. A AWS publicou o código sob Creative Commons CC0, uma dedicação ao domínio público. A i-SCOOP nota que o código de terceiros incluído está sob Apache 2.0.
  • Contribuições. Segundo a i-SCOOP, «o repositório não aceita pull requests, apenas relatórios de erros e de fidelidade». Contribuições externas quebrariam a afirmação de que os agentes escreveram cada linha.

2. Como os agentes o construíram sem um revisor humano

A AWS explica que o emulador «é fundamentalmente construído por três equipas de agentes. Uma equipa gere um conjunto de testes; outra encontra problemas no emulador; e outra corrige esses problemas». Uma quarta etapa decide o que é publicado.

  1. Os autores de testes gravam a verdade. Agentes escrevem testes a partir dos modelos públicos da API da AWS e «verificam cada um contra a AWS real antes de o submeter». Os resultados ficam guardados como testes de fidelidade, já «dezenas de milhares», que «podem ser executados repetidamente sem voltar a chamar a AWS».
  2. Os detetores de problemas repetem os testes. Uma segunda equipa executa os testes de fidelidade contra o emulador, raciocina sobre as falhas e agrupa as que podem ter uma causa comum.
  3. Os corretores ficam com um problema cada um. «Cada problema é atribuído a um agente da terceira equipa, cujo trabalho é corrigir esse único problema.» O agente obtém o código, encontra a causa raiz e edita até o problema ficar resolvido.
  4. Uma porta de fusão decide. A porta «obviamente bloqueia alterações que não compilam. Mas inclui também agentes que revêem segundo as normas de código, verificam que o código é seguro e garantem que a alteração não piorou a fidelidade». As alterações que falham voltam para serem refeitas.

A escala é grande. A AWS diz que «centenas de agentes trabalham em simultâneo no código» e que tem «visto milhares de problemas corrigidos todos os dias». O projeto começou como uma experiência de fim de semana: um servidor web vazio que aceitava pedidos para todos os modelos de API «mas não fazia nada», com o conjunto de testes como especificação.

Ninguém eliminou a revisão. A AWS passou-a de uma pessoa que lê diffs para um conjunto de testes verificados contra o sistema real.

3. As pontuações são a parte honesta

O artigo da AWS não dá taxas de aprovação; promete um artigo posterior sobre como a fidelidade é medida. A Help Net Security relata que a AWS publica pontuações de fidelidade por serviço em cada versão, e a i-SCOOP contou-as para a versão de lançamento. Os resultados:

  • No total. São aprovados 24.243 de 42.937 testes de fidelidade, ou seja, 56,5%. Ao nível de passos individuais, são aprovados 73,2%.
  • Dispersão. Entre os 342 serviços com pelo menos dez testes, a taxa de aprovação mediana é de 61,3%. 40 serviços obtêm 90% ou mais; 124 ficam abaixo de 50%.
  • Serviços conhecidos. EventBridge 71,5%, DynamoDB 68,1%, SQS 67,8%, S3 62,7%, Lambda 51,9%, EC2 38,8% e CloudFormation 18,9% em 4.206 testes.

Convém ler estes números com a ressalva da própria i-SCOOP: «um teste só é aprovado se o emulador devolver exatamente o que a AWS devolveu», e «um teste falhado significa muitas vezes uma mensagem de erro errada, não um serviço avariado». O resumo da i-SCOOP é justo: um emulador rápido e gratuito «que acerta na maior parte os caminhos comuns dos serviços populares».

As limitações são mais claras do que as pontuações. A Help Net Security relata que o emulador «não avalia o AWS Identity and Access Management (IAM) nem as políticas baseadas em recursos como a AWS faz», guarda tudo em memória e deve ser usado com uma só região e uma só conta. A i-SCOOP acrescenta que um pedido que a AWS recusaria pode ter êxito localmente, e o contrário.

4. Porque funcionou, e se funciona para si

Uma condição fez a maior parte do trabalho: a AWS tinha um oráculo. Para qualquer pedido, a AWS real dá a resposta certa, e essa resposta pode ser gravada uma vez e repetida milhares de vezes de graça. A alteração de um agente não é julgada por um revisor gostar ou não do diff. É julgada por o emulador corresponder agora ao sistema que copia. É uma verificação mais forte do que a maioria das revisões humanas, e nunca se cansa.

A maior parte do código de uma startup não tem um oráculo assim. Ninguém consegue gravar a resposta certa para «este fluxo de onboarding é bom?» ou «esta página de preços está certa?». Mas muitas partes de um produto têm um, e essas partes podem aproximar-se do modelo da AWS:

  • uma integração que tem de se comportar como a API de um terceiro;
  • uma migração ou um pipeline de dados cujo resultado pode ser comparado com o do sistema antigo;
  • um parser, um importador ou um cálculo com resultados corretos conhecidos;
  • a reescrita de um serviço cujo comportamento atual é a especificação.
pythonGrave uma vez contra o sistema real, repita contra o seu
import json, pathlib

CASES = pathlib.Path("fidelity_cases")

def record(name: str, request: dict, call_real) -> None:
    """Run once against the real system and save its answer."""
    response = call_real(request)
    CASES.joinpath(f"{name}.json").write_text(
        json.dumps({"request": request, "expected": response}, indent=2))

def replay(call_ours) -> dict:
    """Run every saved case against our code; no calls to the real system."""
    results = {"pass": 0, "fail": []}
    for path in sorted(CASES.glob("*.json")):
        case = json.loads(path.read_text())
        if call_ours(case["request"]) == case["expected"]:
            results["pass"] += 1
        else:
            results["fail"].append(path.stem)
    return results

def gate(before: dict, after: dict) -> bool:
    """Merge only if nothing that passed before fails now."""
    newly_failing = set(after["fail"]) - set(before["fail"])
    return not newly_failing

Encontre os seus oráculos. Faça a lista das partes do seu código para as quais existe uma resposta certa fora dele: a API de um fornecedor, o sistema antigo, um conjunto de dados de referência. São as partes onde os agentes podem trabalhar com menos revisão humana.

Grave antes de delegar. Capture primeiro as respostas do sistema real, como fizeram os autores de testes da AWS, e verifique cada uma contra a fonte. Um teste que um agente escreve sem o verificar contra o sistema real só confirma o que o agente já acredita.

Filtre por regressões, não por gosto. Funda apenas quando a compilação passa, as verificações de normas e de segurança passam e nada do que passava antes falha agora. É uma regra barata de executar e difícil de contestar.

Publique a sua própria pontuação. Acompanhe a taxa de aprovação por área e mostre-a à equipa. Um número que admite 56,5% é mais útil do que uma promessa de completude, porque as pessoas veem onde podem confiar no código.

Mantenha pessoas onde não há oráculo: o critério de produto, as fronteiras de segurança e tudo o que envolva permissões. O próprio resultado da AWS aponta no mesmo sentido. A única área que o emulador não tenta igualar, o controlo de acesso, é precisamente aquela em que uma resposta errada é mais perigosa. Em julho defendemos que uma startup deve contratar o revisor antes do programador. O AWS Emulator afina esse conselho: contrate o revisor para as partes sem oráculo e dedique o resto do esforço a construir um. Para as partes de um produto de IA em que pode definir o comportamento correto, comece por um conjunto de avaliação com tarefas reais de utilizadores.

Se tenciona usar o AWS Emulator

Trate-o como um ciclo local rápido, não como prova de que o seu código funciona na AWS. Não o use para testar o controlo de acesso, porque as políticas de IAM e de recursos não são avaliadas como a AWS as avalia. Use uma só região e uma só conta, conte com o desaparecimento do estado quando o emulador para e consulte a pontuação por serviço dos serviços de que depende. A i-SCOOP avisa ainda que, se o seu SDK não apontar para o emulador, «chama discretamente a AWS real com as credenciais que encontrar». Faça as verificações finais na AWS real.

5. O que eu não afirmaria

Que nenhum humano esteve envolvido. Segundo a AWS, nenhum humano escreveu ou reviu o código. Mas foram pessoas que escolheram o oráculo, desenharam as três equipas, definiram as normas de código e construíram a porta de fusão. A AWS atribui-o às «salvaguardas que pusemos em prática». O trabalho humano passou para uma fase anterior do processo; não desapareceu.

Que 56,5% significa que metade do emulador está avariada. Os testes exigem correspondências exatas, incluindo mensagens de erro. Os caminhos comuns dos serviços populares pontuam muito acima da cauda longa.

Que o seu produto pode fazer o mesmo. A AWS tinha um sistema de referência perfeito e barato de consultar, e orçamento para correr centenas de agentes. A maioria das startups não tem nenhuma das duas coisas para a maior parte do seu código. Copie o método onde tiver um oráculo, não em todo o lado.

Que os números estão fechados. O anúncio da AWS fala tanto em «milhares» como em «centenas» de agentes, e as taxas de aprovação vêm de uma contagem externa de uma única versão, não da AWS. Conte que ambos mudem à medida que a AWS publicar mais.

O resumo honesto

A 11 de novembro de 2026, a AWS lançou o AWS Emulator, um emulador local e gratuito dos seus serviços, e afirmou que ninguém da equipa tinha escrito ou revisto o código. Agentes escreveram testes verificados contra a AWS real, outros repetiram-nos para encontrar divergências, um terceiro grupo corrigiu cada problema e uma porta de fusão verificou compilação, normas, segurança e fidelidade. Uma contagem independente das pontuações no lançamento encontrou 56,5% de 42.937 testes de fidelidade aprovados, com grandes diferenças entre serviços e sem avaliação das políticas de IAM.

Para os fundadores, a lição não é que a revisão esteja obsoleta. É que a revisão pode passar para os testes quando há uma fonte fiável de respostas certas, e deve ficar com pessoas quando não há.

Esta semana, escolha uma parte do seu código que tenha um oráculo, grave vinte respostas reais dele e transforme «nada do que passava falha agora» numa regra de fusão para as alterações dos agentes nessa parte.

Fontes: Matthew Goldberg, AWS, AWS Emulator: a local emulator built 100% by autonomous AI agents (11 de novembro de 2026) — a descrição do produto, os 438 modelos de API, a licença CC0, as três equipas de agentes, a porta de fusão, o número de agentes e de problemas, e a afirmação de que a equipa não tinha escrito nem revisto o código; Anamarija Pogorelec, Help Net Security, AWS Emulator: Open-source tool for testing AWS apps locally, built by autonomous AI agents (12 de novembro de 2026) — as quatro formas de o executar, as pontuações por serviço publicadas em cada versão, e as limitações de IAM, região, conta e memória; Tom Cuylaerts, i-SCOOP, AWS Emulator was built by AI agents nobody reviewed, and its own test scores show where to trust it (12 de novembro de 2026) — a contagem das pontuações no lançamento, os números por serviço, as ressalvas sobre correspondências exatas, a nota sobre pull requests e código de terceiros com licença Apache, e o aviso sobre os endpoints do SDK. O código da secção 4 é uma ilustração minha, e a leitura das secções 4 e 5 é minha.

IdeaToMVP Academy

Want to build with AI — not just read about it?

4-week live cohort for founders. Learn to ship AI agents, scope MVPs, and automate your business — taught by the same team that writes these guides.

Explore the Academy →
Share this post :