O Hacker News acordou ontem com 937 upvotes numa única postagem. Não era sobre uma nova startup de IA levantando bilhões, nem sobre um leak de dados de uma big tech. Era sobre o Pi 1.0, um agente de código que se orgulha de tudo que ele não faz.

Enquanto o Claude Code, o Cursor e o Codex disputam quem empacota mais funcionalidades, a Earendil lançou a versão 1.0 do Pi com uma promessa bem diferente: “se eu não preciso disso, não vai ser construído”. E o mais curioso? Nos testes de ferramentas reais, o Pi completou mais tarefas gastando uma fração do custo dos concorrentes.

Eu acompanho agentes de código há meses. Já escrevi sobre Claude Code, sobre Cursor, sobre vibe coding e suas armadilhas. Mas o Pi 1.0 representa uma mudança de filosofia que merece atenção. Não porque ele é o “melhor” (essa palavra não faz sentido quando cada dev tem um workflow diferente), mas porque ele prova que minimalismo em 2026 não é limitação: é vantagem competitiva.

O que raios é o Pi?

Pi é o que a Earendil chama de “agente harness endurecido, mínimo e extensível”. Traduzindo do marketês: é um framework que roda no terminal, conecta qualquer modelo de IA a ferramentas do sistema, e faz questão de não inventar funcionalidade que não foi pedida.

O criador original é Mario Zechner, um desenvolvedor austríaco que construiu o Pi como uma ferramenta pessoal. A Earendil adquiriu o projeto em abril de 2026 e, com input de centenas de milhares de usuários semanais, chegou à versão 1.0 em 1 de outubro de 2026.

A filosofia do Pi é quase estoica: muitas novidades no mundo de IA “não duram”, segundo a equipe. Por isso, eles adotam tecnologias só depois que elas provam que vieram pra ficar. O resultado é um agente com ~15.000 linhas de código (sem contar testes), licença MIT, e zero vendor lock-in.

MCP: A Reviravolta que Ninguém Esperava

Aqui entra a parte mais interessante da história. O próprio Mario Zechner era publicamente contra o MCP (Model Context Protocol). Ele considerava o protocolo desnecessário para o Pi. Quando a Earendil comprou o projeto e anunciou que o MCP seria feature de primeira classe no Pi 1.0, a comunidade ficou dividida.

A justificativa da Earendil foi cirúrgica: “as coisas mudam”. E mudaram mesmo. O MCP virou padrão de facto para conectar agentes de IA a ferramentas externas. O Claude Code usa, o Cursor usa, ferramentas enterprise usam. Ignorar o MCP em outubro de 2026 seria como ignorar HTTP em 2005.

Com o Pi 1.0, configurar MCP é trivial:

pi mcp add
pi mcp list
pi mcp login

O suporte é nativo. Sem plugins, sem gambiarras. E isso alimenta a próxima grande feature: o Codemode.

Codemode: Quando o Modelo Vira Programador de Verdade

A maioria dos agentes de código funciona assim: o modelo pede para executar uma ferramenta, o harness executa, retorna o resultado, e o modelo decide o próximo passo. Uma ferramenta por turno. Ida e volta. Ida e volta.

O Codemode do Pi muda essa dinâmica. Em vez de chamar uma ferramenta por vez, o modelo escreve um script JavaScript que roda num sandbox QuickJS dentro do harness. Esse script pode chamar múltiplas ferramentas de uma vez, encadear resultados, e retornar tudo num único turno.

// Exemplo conceitual do Codemode
const files = await tools.glob("src/**/*.ts");
const results = await Promise.all(
  files.map(f => tools.read(f))
);
const bugs = results.filter(r => r.includes("TODO: fix"));
return bugs;

O impacto prático? Com as ferramentas padrão, um request ao GPT-5.6 caiu de ~5.300 tokens de prompt para ~3.300. Isso é uma redução de 37% no custo por request. Multiplica isso por centenas de chamadas durante uma sessão de pair programming com IA e a conta despenca.

O Codemode também abre portas para modelos não-LLM. O Pi 1.0 suporta nativamente modelos de imagem e modelos de decisão como o Jev. Isso significa que seu agente pode, numa mesma sessão, analisar código, gerar um diagrama de arquitetura, e tomar decisões de roteamento sem trocar de ferramenta.

Pi Durable: Agentes que Sobrevivem a Crashes

Junto com o Pi 1.0, a Earendil lançou o Pi Durable como software experimental. Se o Pi é o agente que roda no seu terminal por 30 minutos e resolve um bug, o Pi Durable é o agente que roda por dias, semanas, ou indefinidamente.

A ideia central é simples e poderosa: cada passo de execução é uma task que salva um checkpoint antes de avançar. Se o processo morre (crash, reboot, falta de energia), uma nova instância retoma do último checkpoint. Só as operações inseguras precisam ser re-executadas.

Pensa num agente que monitora um canal do Slack, faz triage de issues, e dispara subagentes para resolver bugs menores. Se o servidor reinicia às 3 da manhã, o agente acorda exatamente onde parou. Sem perder contexto, sem reprocessar mensagens.

Arquitetura do Pi Durable

O storage é plugável (Memory, SQLite, JSONL), o runtime é JavaScript/TypeScript, e o código tem ~15.000 linhas. A Earendil disponibilizou 30+ exemplos e duas implementações de referência: um agente de código e um planejador de viagens (~1.300 linhas TypeScript cada).

Conversas Concorrentes e Multiplayer

Um único harness roda conversas ilimitadas simultaneamente usando um mecanismo de fork. Imagina um bot no Slack: o canal principal é uma conversa, cada thread é um fork. Nenhum bloqueia o outro.

E tem a parte multiplayer: múltiplos clientes podem se conectar à mesma conversa, recebendo updates em streaming. Qualquer cliente pode “pilotar” o trabalho em andamento ou enfileirar próximos passos. Pensa em code review com IA onde três devs veem o agente trabalhando em tempo real e qualquer um pode redirecionar.

Os Números que Importam: Pi vs Claude Code vs Cursor

Uma comparação publicada no GitHub testou agentes em 30 tarefas reais de ferramentas (não benchmarks sintéticos):

Esse número de custo é brutal. O Pi resolveu 4 tarefas a mais gastando 7 vezes menos por sucesso. Claro, a comparação tem nuances: o Claude Code é mais conservador por design (pede permissão antes de agir), e isso adiciona overhead mas também segurança. O Pi te dá a corda e a responsabilidade é sua.

A comparação com o Cursor é diferente. O Cursor vive dentro do VS Code, com autocomplete por tab, preview no browser, e uma experiência integrada que o Pi não tenta replicar. O Pi é terminal-first. Quem gosta de tmux e vim vai se sentir em casa. Quem precisa de UI, menos.

Quando Usar Cada Um?

Depois de analisar dezenas de reviews e comparativos, o consenso da comunidade se cristalizou assim:

Escolha o Pi se:

• Você quer controle total sobre qual modelo usar (GPT-5.6, Claude, Gemini, modelos locais)
• Custo por token importa no seu workflow
• Você prefere um agente que executa e sai do caminho
• Quer construir aplicações agentic customizadas (Pi Durable)
• Open source e MIT license são requisitos

Escolha o Claude Code se:

• Refactors complexos em múltiplos arquivos são seu dia a dia
• Você quer segurança by default (sandbox, permissões granulares)
• O ecossistema Anthropic (MCP servers, artifacts) faz parte do seu stack
• Prefere um agente que “planeja antes de executar”

Escolha o Cursor se:

• VS Code é sua IDE e você não quer sair dela
• Autocomplete em tempo real é mais útil que execução agentic
• Você é mais “eu dirijo, a IA ajuda” do que “IA dirige, eu supervisiono”

O Que o Pi 1.0 Ensina Sobre o Futuro dos Agentes

O sucesso do Pi no Hacker News (quase mil upvotes) sinaliza algo que vai além de preferência técnica. Existe uma fatiga com ferramentas que tentam fazer tudo.

Nos últimos dois anos, a tendência em IA foi empilhar features: sub-agentes, modo de planejamento, execução paralela, interfaces visuais, integração com tudo que existe. O Pi vai na contramão. Não tem sub-agentes. Não tem plan mode. Não tem IDE. E centenas de milhares de devs usam semanalmente.

Isso lembra o movimento que aconteceu com editores de texto: depois do VS Code dominar com extensões infinitas, o Helix e o Zed ganharam tração oferecendo menos, mas melhor. O Pi é o Helix dos agentes de IA.

A Earendil articula essa filosofia de forma clara: “queremos criar software e protocolos abertos que fortaleçam a agência humana”. Não é sobre a IA fazer tudo por você. É sobre a IA ser uma ferramenta que você molda pro seu workflow, não o contrário.

O Deferred Tool Loading e o Cache Warming

Duas features menos comentadas mas igualmente relevantes para quem se preocupa com performance e custo:

Deferred Tool Loading: ferramentas são inicializadas sob demanda, não no boot. Se você configurou 50 MCP servers mas só vai usar 3 nessa sessão, os outros 47 não consomem memória nem tokens de contexto. Parece óbvio, mas a maioria dos agentes carrega tudo de uma vez.

Cache Warming para Anthropic: quando você usa modelos Claude via Pi, o harness faz warm-up do cache de prompt. Isso significa que chamadas repetidas ao mesmo contexto custam menos, porque o provider reconhece o cache hit. A Earendil implementou isso especificamente para modelos Anthropic, sugerindo que uma boa fatia dos usuários Pi roda Claude por baixo dos panos.

Instalação e Primeiros Passos

Se bateu a curiosidade, começar com o Pi é rápido:

# macOS/Linux
curl -fsSL https://pi.dev/install.sh | sh

# Primeiro uso
pi

# Adicionar MCP server
pi mcp add

# Para Pi Durable
npm install @earendil-works/pi-durable @earendil-works/pi-ai @earendil-works/chord

O Pi detecta automaticamente seu diretório, lê arquivos de configuração locais, e conecta ao modelo que você configurar. Não precisa de conta na Earendil. Não precisa de setup wizard. Abre o terminal e começa.

A Questão da Segurança

Preciso ser honesto aqui: o modelo de segurança do Pi é… questionável pra ambientes corporativos. Acesso total ao sistema desde o primeiro prompt, sem sandbox, sem deny-first. Se o modelo decide deletar seu diretório home, ele deleta. A responsabilidade é 100% sua.

O Claude Code, por comparação, opera num sandbox por padrão. Cada operação potencialmente destrutiva precisa de aprovação explícita. Pra um dev solo que sabe o que está fazendo, o modelo do Pi é mais rápido. Pra uma equipe de 50 pessoas com juniors usando agentes, é um risco.

A Earendil poderia argumentar que segurança é responsabilidade do wrapper, não do harness. E tecnicamente, com o Pi Durable e seu sistema de Extensions, dá pra implementar permissões customizadas. Mas “dá pra implementar” é diferente de “já vem implementado”, e na prática poucos vão se dar ao trabalho.

Quem é a Earendil, Afinal?

A Earendil é uma empresa austríaca que entrou no radar do mercado ao adquirir o Pi do Mario Zechner em abril de 2026. Pouco se sabe sobre a estrutura da empresa, mas a missão declarada é “criar software e protocolos abertos que fortaleçam a agência humana”.

O fato de manterem tudo em MIT license, sem plano premium ou paywalls, levanta a pergunta óbvia: como vão monetizar? O Pi Durable, com suas capacidades enterprise (crash resilience, multiplayer, conversas concorrentes), é a resposta mais provável. Oferecer o agente básico de graça e cobrar por infraestrutura durável é o playbook clássico do open source.

O que vem pela frente?

O Pi 1.0 é só o começo. O Pi Durable ainda é experimental, e a Earendil já sinalizou que quer expandir o conceito de “agentes que rodam em qualquer superfície”, não só no terminal. Slack, email, dashboards, CI/CD, qualquer lugar onde um agente persistente faça sentido.

A guerra dos agentes de código em 2026 não é mais sobre qual modelo é melhor. É sobre qual harness dá mais poder ao dev com menos atrito. O Pi apostou em minimalismo radical e, pelo menos no Hacker News, a aposta pagou. 937 upvotes não mentem.

Resta saber se a filosofia do “menos é mais” sobrevive quando empresas precisam de compliance, audit trails, e controle de acesso granular. Mas essa é uma história pra outro artigo.