O que é Zero? A linguagem de programação para agentes de IA

Uma linguagem desenhada em torno de seus leitores

A maioria das linguagens de programação foi desenhada para humanos. As gramáticas otimizam para o que os humanos valorizam: sintaxe enxuta, idiomas expressivos, atalhos "elegantes". Compiladores imprimem mensagens de erro em prosa porque quem lê é humano. Bibliotecas padrão são organizadas da forma que os autores da biblioteca acharam mais fácil de lembrar.

Zero parte de uma premissa diferente. Os leitores principais são agentes de IA — modelos de linguagem escrevendo, depurando e reparando código em nome de alguém. Os humanos continuam no jogo, mas o desenho da linguagem trata os agentes como usuários de primeira classe desde o primeiro dia. Essa única mudança se propaga para quase toda funcionalidade visível da linguagem.

Zero é construída pela Vercel Labs, vive em zerolang.ai e é open source em github.com/vercel-labs/zero. Os arquivos-fonte terminam em .0.

pub fun main(world: World) -> Void raises {
    check world.out.write("hello from zero\n")
}

Cinco coisas nesse trecho — pub, World, raises, check e o world.out.write explícito — já dizem muita coisa sobre como Zero pensa. Vamos destrinchar cada uma.

"Tudo é explícito"

O lema não oficial da documentação do Zero é tudo é explícito. A linguagem evita deliberadamente o tipo de maquinário escondido que torna outras linguagens de sistema convenientes para humanos mas traiçoeiras para geradores de código:

• Sem garbage collector obrigatório.
• Sem alocador escondido.
• Sem runtime assíncrono implícito.
• Sem variáveis globais mágicas — sem stdout ambiente, sem process.env, sem sistema de arquivos implícito.

Qualquer coisa que uma função faça que toque o mundo externo precisa aparecer na assinatura dela. Para um humano, é muito a digitar; para um agente raciocinando sobre o que uma função realmente faz, é um presente.

Capacidades, não globais

A forma como Zero lida com I/O é o exemplo mais claro dessa filosofia. Não existe uma função print global. A saída acontece através de um valor World que o runtime entrega para main:

pub fun main(world: World) -> Void raises {
    check world.out.write("hello\n")
}

Se uma função no fundo da sua pilha de chamadas quiser escrever uma linha de log, ela precisa receber um World (ou alguma capacidade mais restrita) explicitamente. Você consegue ler a assinatura de uma função e saber — sem ler o corpo — se ela pode tocar a rede, o sistema de arquivos ou a saída padrão. É o tipo de propriedade em que um analisador estático (ou um agente fazendo code review) pode confiar.

A capacidade World aprofunda essa ideia.

Falha explícita com raises e check

Funções que podem falhar declaram isso. Quem chama funções falíveis reconhece o fato. Não existe lançamento silencioso:

fun validate(ok: Bool) -> i32 raises { InvalidInput } {
    if ok == false {
        raise InvalidInput
    }
    return 42
}

pub fun main(world: World) -> Void raises {
    check validate(true)
    check world.out.write("ok\n")
}

raises { InvalidInput } em validate significa "esta função pode falhar com InvalidInput". check no ponto de chamada significa "se isso falhar, propague o erro para cima". Você não consegue esquecer um erro por acidente — ele aparece na assinatura da sua função ou o compilador te impede. Veja Raises e Check para a história completa.

Um compilador que fala com agentes

A parte mais distintiva do Zero não é uma funcionalidade de sintaxe — é a saída do compilador. Rode zero check --json num programa quebrado e você recebe algo como isto:

{
    "ok": false,
    "diagnostics": [
        {
            "code": "NAM003",
            "message": "unknown identifier",
            "line": 3,
            "repair": { "id": "declare-missing-symbol" }
        }
    ]
}

Três coisas fazem isso diferente de um erro de compilador normal:

1. Códigos de erro estáveis. NAM003 significa "identificador desconhecido" hoje e vai significar exatamente isso na próxima versão do compilador. Agentes podem fazer pattern matching no código sem precisar interpretar inglês.
2. Metadados de reparo estruturados. O campo repair nomeia um tipo de correção que o compilador acredita resolver o erro. Um agente pode buscar o plano com zero fix --plan --json e aplicá-lo.
3. Sem necessidade de interpretar prosa. A ideia toda é que um agente não precise interpretar uma mensagem feita para humanos para decidir o próximo passo.

Diagnósticos em JSON explica o formato em detalhes.

Superfície pequena por desenho

A gramática do Zero é pequena e regular — mais próxima em espírito do C original do que de uma linguagem cheia de funcionalidades como Scala ou C++ moderno. O raciocínio é prático: um agente deve conseguir internalizar a linguagem inteira durante uma sessão, sem errar em casos limites.

Isso quer dizer que você vai encontrar:

• Uma forma de declarar uma função (fun ou pub fun).
• Uma forma de criar uma ligação local (let).
• Uma forma de modelar tipos produto (shape), uma forma de modelar tipos soma (choice), uma forma para enumerações simples (enum).
• Uma construção de pattern matching (match).
• Uma construção de loop na linguagem inicial (while).

O que você não vai encontrar — pelo menos por enquanto — são sobrecarga de operadores, conversões implícitas, macros, decoradores ou três formas concorrentes de expressar a mesma ideia. Não é ascetismo; é uma escolha deliberada para manter a superfície pequena o bastante para que um agente raramente escolha a variante errada.

O que Zero não é

Para alinhar expectativas:

• Não é uma linguagem de script. Zero compila para binários nativos. Os programas são pequenos (a documentação cita executáveis de menos de 10 KB) e não arrastam um runtime junto.
• Não é Rust, não é Go, não é Zig. A sintaxe tem ancestrais em comum, mas as prioridades são diferentes — Rust otimiza para segurança de memória com um sistema de tipos sofisticado, Zero otimiza para a capacidade do agente de aprender, com um sistema deliberadamente minúsculo.
• Não é estável. Zero é pré-1.0. O time é claro que mudanças incompatíveis virão se ajudarem nos objetivos agent-first. Não dependa dele para nada sério ainda.
• Não é uma funcionalidade da plataforma de deploy da Vercel. Apesar de vir da Vercel Labs, Zero não está atrelado ao Next.js ou à hospedagem Vercel. É uma linguagem de sistemas independente.

Quando você experimentaria Zero hoje

Você experimentaria Zero hoje se tem interesse em:

• Como uma linguagem muda quando as restrições de desenho vêm de agentes em vez de humanos.
• Experimentar I/O baseado em capacidades sem adotar uma linguagem de pesquisa.
• Ver como fica a "saída estruturada de compilador" como funcionalidade de primeira classe em vez de um adendo.
• Dar feedback para a Vercel Labs em um projeto que está evoluindo ativamente.

Você pularia (por enquanto) se precisa de uma linguagem estável para trabalho real, quer um ecossistema maduro de bibliotecas ou precisa de ferramentas multiplataforma no nível de Rust ou Go.

A seguir: instalar o Zero

A próxima documentação mostra como instalar a toolchain do Zero e fazer seu primeiro programa compilar. Leva mais ou menos um minuto, do início ao fim.