Phase 19 - Lesson 05

Capstone 05 — Agente de Pesquisa Autônomo (Classe AI-Scientist)

O AI-Scientist-v2 da Sakana publicou artigos completos. O Agent Laboratory executou os experimentos. O Allen AI compartilhou os traces. O formato de 2026 é uma busca em árvore planejar-executar-verificar sobre experimentos, custo orçado, execução de código em sandbox, um escritor LaTeX com feedback de visão e um ensemble de revisores automatizado no estilo NeurIPS. O capstone consiste em construir um, executá-lo de ponta a ponta com menos de $30 por artigo e sobreviver ao red team de escape de sandbox que a Sakana documentou.

Tipo: Capstone Linguagens: Python (agente + sandbox), LaTeX (saída) Pré-requisitos: Fase 2 (ML), Fase 3 (aprendizado profundo), Fase 7 (transformers), Fase 10 (LLMs do zero), Fase 14 (agentes), Fase 15 (autônomos), Fase 16 (multiagentes), Fase 18 (segurança) Fases exercitadas: P0 · P2 · P3 · P7 · P10 · P14 · P15 · P16 · P18 Tempo: 40 horas

Problema

Os agentes de pesquisa autônomos ultrapassaram um limite em 2026. O AI-Scientist-v2 da Sakana AI foi publicado na Nature com artigos gerados que passaram pela revisão por pares de workshops. O ShinkaEvolve (ICLR 2026) estendeu essa linha para a evolução de hipóteses. O Agent Laboratory da AMD disponibilizou traces reproduzíveis. Os agentes não são mágicos — eles são um loop de planejar-executar-verificar executado sobre uma árvore de experimentos candidatos, com limites de custo, sandboxes vinculadas a sementes (seeds) e revisão automatizada. A arte está no loop, no orçamento e na história de segurança.

Você aprenderá o loop implementando um contra uma ideia semente em um domínio estreito (por exemplo, ablações de esparsidade de atenção em um transformer de 100 milhões de parâmetros). O valor não está em descobrir algo novo logo na primeira execução. O valor está na infraestrutura: a busca em árvore, a sandbox de experimentos, o loop escritor-revisor e o relatório do red team. A equipe da Sakana documentou falhas de escape de sandbox; seu agente deve passar pelo mesmo red team.

Concept

O agente é uma busca em árvore best-first (melhor escolha). Os nós são especificações de experimentos: (hipótese, configuração, código, resultado esperado). Uma etapa de expansão propõe nós filhos com pequenas edições (trocar otimizador, alterar tamanho do lote, ablatar um componente). Cada nó filho roda em uma sandbox limpa com um limite rígido de recursos. Os resultados alimentam de volta uma função de pontuação que classifica os nós por (novidade × qualidade × orçamento restante). A árvore cresce até que o orçamento se esgote e, em seguida, o melhor ramo é redigido.

O escritor é multimodal. Ele gera um rascunho em LaTeX, o compila, renderiza figuras e alimenta o PDF renderizado de volta no modo de visão do Claude Opus 4.7 para crítica sobre o layout, legibilidade das figuras e alinhamento de alegação-evidência. Um ensemble de revisores composto por cinco juízes baseados em LLM emite pontuações no estilo NeurIPS (novidade, rigor, clareza, reprodutibilidade, impacto); se a média cair abaixo do limite, o artigo retorna ao escritor com a crítica.

A segurança é fundamental. Cada experimento é executado em uma sandbox E2B ou Daytona sem saída de rede, tempo de execução delimitado e limites rígidos de recursos. A etapa de geração de código do agente passa por uma camada de política que bloqueia chamadas de sistema (syscalls) que tentam escapar da sandbox. O relatório do red team reproduz a superfície de ataque documentada pela Sakana (fork bombs, escapes de sistema de arquivos, chamadas de rede escritas por LLM).

Architecture

seed idea + domain
      |
      v
  literature search (Semantic Scholar + OpenAlex + FAISS cache)
      |
      v
  LangGraph plan-execute-verify tree
      |
      v
  +--- expand node ----+      per-node sandbox
  |                    |      (E2B / Daytona)
  v                    v      resource caps
  child_1           child_k   no network egress
  |                    |      deterministic seeds
  v                    v
  run experiment       run experiment
  |                    |
  v                    v
  score nodes by (novelty, quality, budget)
      |
      v
  best branch -> LaTeX writer
      |
      v
  compile + vision critique (Opus 4.7 vision)
      |
      v
  reviewer ensemble (5 LLM judges, NeurIPS rubric)
      |
      v
  paper.pdf + review.md + trace.json

Stack

  • Orquestração: LangGraph com checkpointing e portões de aprovação humana
  • Busca em árvore: best-first personalizada sobre nós de experimento (estilo AB-MCTS do Sakana v2)
  • Sandbox: E2B por experimento, fallback de Docker-in-Docker; limites de recursos via cgroups
  • Literatura: Semantic Scholar Graph API + OpenAlex + cache local de resumos em FAISS
  • Escritor: modelo LaTeX + Claude Opus 4.7 (modo de visão) para crítica de figuras e layout
  • Revisor: ensemble de 5 juízes (Opus 4.7, GPT-5.4, Gemini 3 Pro, DeepSeek R1, Qwen3-Max) com agregação ponderada
  • Framework de experimentos: PyTorch 2.5 para os experimentos físicos, W&B para registro de logs
  • Observabilidade: Langfuse para traces do agente, orçamento rígido de $30 por artigo

Build It

  1. Definição de escopo de semente e domínio. Pegue uma ideia semente (por exemplo, "investigar padrões de esparsidade em mapas de atenção de transformers menores que 1B de parâmetros"). Defina o espaço de busca: modelos, conjuntos de dados, orçamento de computação.

  2. Etapa de literatura. Consulte o Semantic Scholar + OpenAlex para encontrar os 50 artigos relevantes mais citados; armazene os resumos localmente no cache; gere um resumo do domínio de 1 página.

  3. Estrutura da árvore. Inicialize a raiz com a hipótese semente. Implemente expand(node) -> children com propostas de pequenas edições (uma alteração de configuração por nó filho). Implemente score(node) como um termo ponderado de novidade × qualidade × orçamento.

  4. Isolamento em sandbox. Cada experimento executa docker run --network=none --memory=8g --cpus=2 --pids-limit=256 --read-only (ou a política E2B equivalente). As sementes (seeds) são gravadas na sandbox; as saídas são montadas de volta como somente leitura.

  5. Loop de planejar-executar-verificar. plan propõe nós filhos. execute executa a sandbox, captura logs e métricas. verify executa testes unitários nas métricas (a perda diminuiu? a ablação isolou o efeito?). Nós que falharem têm o motivo da falha armazenado na árvore.

  6. Escritor. Após esgotar o orçamento, selecione o melhor ramo. Renderize figuras com matplotlib. Gere um rascunho em LaTeX via Claude Opus 4.7 com o trace do ramo no contexto. Compile. Alimente o PDF compilado de volta ao Opus 4.7 visão para crítica. Itere.

  7. Ensemble de revisores. Cinco juízes pontuam o rascunho em (novidade, rigor, clareza, reprodutibilidade, impacto) usando rubricas no estilo NeurIPS. Se a média for menor que 4.0/5, retorne ao escritor com a crítica. Parada obrigatória após 3 reescritas.

  8. Red team. Construa ou integre um conjunto de tarefas adversárias direcionadas à sandbox: fork bombs, tentativas de infiltração de rede, escapes de sistema de arquivos, metacaracteres de shell escritos por LLM. Confirme que todos estão bloqueados. Escreva as descobertas.

  9. Reproducibilidade. Cada artigo é enviado com o seu JSON de trace da busca em árvore, sementes (seeds), links de execução do W&B, configurações de sandbox e um README para reproduzi-lo de ponta a ponta.

Use It

$ ai-scientist run --seed "attention sparsity in sub-1B transformers" --budget 30
[lit]    50 papers, digest in 12s
[tree]   expanded 8 nodes, budget 12/30
[exec]   node #3 sparsity=top-8, loss=2.83 (best so far)
[exec]   node #6 sparsity=top-4, loss=3.12 (worse)
[exec]   ...
[tree]   chose branch rooted at node #3 (novelty 0.62, quality 0.81)
[write]  LaTeX draft v1 complete
[vision] critique: figure 2 legend too small, claim-evidence ok
[write]  draft v2 after 3 edits
[review] mean 4.2/5 (novelty 3.9, rigor 4.3, clarity 4.1, repro 4.5, impact 4.2)
[done]   paper.pdf + review.md + trace.json
8.40 spent

Ship It

outputs/skill-ai-scientist.md é o entregável. Dada uma ideia semente + um domínio + um orçamento de $30, ele executa o pipeline completo e emite um artigo revisável além de um pacote de reprodutibilidade.

Peso Critério Como é medido
25 Qualidade do artigo Revisão cega por rubrica em comparação com artigos de workshops publicados
20 Rigor experimental Linhas de base (baselines), sementes (seeds), ablações; cada alegação apoiada por uma célula na tabela de resultados
20 Disciplina de custo e computação Teto de $30/artigo aplicado, rastreado via Langfuse
20 Segurança Testes do red team na sandbox aprovados; política de rede e kill-switch verificados
15 Reproducibilidade Execução com um único comando com sementes idênticas reproduz o artigo
100

Exercises

  1. Execute o pipeline contra três ideias sementes diferentes no mesmo domínio. Compare quais partes da busca em árvore se sobrepõem. Identifique computação duplicada desperdiçada.

  2. Adicione uma etapa de aprovação humana (human-in-the-loop) antes da execução do experimento para nós com custo estimado acima de $5. Meça o quanto o custo total diminui.

  3. Substitua o ensemble de revisores por um único juiz. Meça a taxa de aceitação falsa em um conjunto reservado de artigos conhecidamente ruins.

  4. Introduza um teste de red team de exfiltração de rede: o agente escreve um código que tenta fazer um curl para um endereço externo. Confirme se a política --network=none o bloqueia. Registre a tentativa.

  5. Compare sua busca em árvore com uma linha de base aleatória simples (mesmo orçamento, sem estratégia de expansão). Relate o ganho de novidade × qualidade.

Key Terms

Termo O que as pessoas dizem O que realmente significa
Busca em árvore "AB-MCTS-style expansion" Exploração best-first sobre nós de experimento com uma pontuação de novidade×qualidade×orçamento
Sandbox "Isolamento de experimento" Contêiner sem rede, CPU/memória limitada, sementes fixadas, entradas apenas para leitura
Crítica de visão "Render-then-read" Compilar o artigo em PDF, enviar o PDF de volta a um VLM para crítica de layout e alegação-evidência
Ensemble de revisores "Revisão por pares automatizada" Vários juízes de LLM pontuando o artigo com uma rubrica NeurIPS; a agregação ponderada controla o pipeline
Pontuação de novidade "Isso é novo?" Heurística que penaliza a proximidade com o cache de literatura de 50 artigos
Teto de custo "Orçamento em

AI Engineering from Scratch

Build transformers, LLMs, and AI agents from first principles - verified by graded code, running entirely in your browser.

$20 lifetime access to graded exercises, an AI tutor, and a verified certificate. The curriculum itself is free, based on the open MIT course by Rohit Ghumare.

Why this course is different

  • Build, don't just watch. Every lesson has a graded in-browser coding exercise. Your code runs against real automated tests inside the browser via Pyodide (Python-in-WASM) - no installs, no cloud account.
  • Verified by machine, not vibes. The certificate is earned by passing autograded tests, not clicking through slides. Employers can trust it.
  • From first principles. You implement transformers, attention mechanisms, backpropagation, and LLM inference from scratch - in Python, in your browser.
  • AI tutor included. Bring your own API key (Anthropic, OpenAI, or Gemini) and get a context-aware tutor that knows exactly what lesson you are on and never gives away the solution.
  • No GPU needed. All 20 phases run on browser WASM. Deep-learning phases use numpy-level implementations so any laptop works.
  • $20 once, lifetime access. No subscription, no per-lesson fees.

20-Phase Curriculum (260+ lessons)

Each phase contains multiple lessons. All reading is free. Graded coding exercises unlock with the $20 one-time payment.

  1. Phase 0 - Setup and Tooling: Environment setup, Python fundamentals, toolchain for AI engineering.
  2. Phase 1 - Math Foundations: Linear algebra, calculus, probability, statistics, information theory, and norms - all implemented from scratch.
  3. Phase 2 - ML Fundamentals: Supervised and unsupervised learning, gradient descent, decision trees, SVMs, clustering built from first principles.
  4. Phase 3 - Deep Learning Core: Backpropagation, neural networks, activation functions, batch normalization, dropout - implemented in pure numpy.
  5. Phase 4 - Computer Vision: Convolutions, CNNs, image classification, object detection architectures built from scratch.
  6. Phase 5 - NLP Foundations to Advanced: Tokenization, embeddings, word2vec, sequence models, attention mechanisms.
  7. Phase 6 - Speech and Audio: Audio processing, spectrograms, speech recognition fundamentals.
  8. Phase 7 - Transformers Deep Dive: Multi-head attention, positional encoding, encoder-decoder, the full transformer architecture - built from scratch.
  9. Phase 8 - Generative AI: VAEs, GANs, diffusion models, generative techniques from first principles.
  10. Phase 9 - Reinforcement Learning: MDPs, Q-learning, policy gradients, RLHF fundamentals.
  11. Phase 10 - LLMs from Scratch: Pre-training, tokenization (BPE), causal attention, GPT-style language model implementation.
  12. Phase 11 - LLM Engineering: Fine-tuning, RLHF, inference optimization, quantization, serving LLMs in production.
  13. Phase 12 - Multimodal AI: Vision-language models, cross-modal attention, multimodal embeddings.
  14. Phase 13 - Tools and Protocols: Function calling, tool use, MCP (Model Context Protocol), structured outputs.
  15. Phase 14 - Agent Engineering: ReAct agents, planning, memory, tool-using agents built from scratch.
  16. Phase 15 - Autonomous Systems: Agentic loops, long-horizon planning, autonomous decision-making systems.
  17. Phase 16 - Multi-Agent Systems and Swarms: Multi-agent coordination, swarm intelligence, agent communication protocols.
  18. Phase 17 - Infrastructure and Production: MLOps, model deployment, monitoring, scaling AI systems.
  19. Phase 18 - Ethics, Safety, and Alignment: AI safety fundamentals, alignment techniques, responsible AI engineering.
  20. Phase 19 - Capstone Projects: End-to-end AI engineering projects integrating skills across all phases.

Frequently Asked Questions

What is AI Engineering from Scratch?

A 20-phase, 260-lesson course teaching you to build AI systems - transformers, LLMs, agents, computer vision models, and more - from first principles. All coding runs in your browser via Pyodide (Python-in-WASM). No installs. Based on the open MIT curriculum by Rohit Ghumare.

Is the course content free?

Yes. The full 20-phase reading curriculum is freely accessible to everyone. The $20 one-time payment unlocks graded exercises, the AI tutor, and the verified completion certificate.

What does the $20 lifetime access unlock?

Three things: (1) graded in-browser coding exercises with an autograder that checks your solution against real automated tests, (2) an AI tutor (bring your own API key for Anthropic Claude, OpenAI, or Gemini) that answers questions in context of each lesson without spoiling solutions, and (3) a verified completion certificate earned by passing all graded exercises.

Is the certificate verified?

Yes. You earn it by passing machine-graded coding exercises, not by watching videos. Every graded lesson has tests that your solution must pass. The autograder is the same one that verified the lesson's reference solution. This makes the certificate verifiable and meaningful.

Do I need a GPU?

No. All 20 phases run in the browser via Pyodide (Python compiled to WebAssembly). Numpy, scikit-learn-style libraries, and custom implementations run on any modern laptop - no GPU, no cloud compute, no local Python installation required.

What AI topics does this cover?

Math and statistics, machine learning fundamentals, deep learning, computer vision, NLP, speech, transformers, generative AI, reinforcement learning, LLMs from scratch, LLM engineering, multimodal AI, tool use and MCP, agent engineering, autonomous systems, multi-agent swarms, MLOps, AI safety and alignment, and capstone projects.

Curriculum based on AI Engineering from Scratch by Rohit Ghumare (MIT, used under attribution). Platform by AI Engineering Academy.

quot;		 Limite rígido no gasto total por artigo; contadores Langfuse + estimativas pré-execução
Red team "Auditoria de escape de sandbox" Tarefas adversárias que escapariam da sandbox se a política estivesse errada

Further Reading