Qué es Zero: el lenguaje de programación para agentes de IA

Un lenguaje diseñado pensando en quien lo lee

La mayoría de los lenguajes de programación se diseñaron para humanos. Sus gramáticas se optimizan para lo que importa a una persona: sintaxis breve, modismos expresivos, atajos "elegantes". Los compiladores imprimen mensajes de error en prosa porque quien los lee es un humano. Las bibliotecas estándar se organizan según lo que a sus autores les pareció memorable.

Zero parte de una premisa distinta. Sus lectores principales son agentes de IA: modelos de lenguaje que escriben, depuran y reparan código por encargo de alguien. Los humanos siguen estando en el bucle, pero el diseño del lenguaje trata a los agentes como usuarios de primera clase desde el primer día. Ese único cambio se propaga a casi todas las características visibles del lenguaje.

Zero lo construye Vercel Labs, vive en zerolang.ai y es código abierto en github.com/vercel-labs/zero. Los archivos fuente terminan en .0.

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

Cinco cosas en ese fragmento — pub, World, raises, check y la llamada explícita world.out.write — ya te dicen mucho sobre cómo piensa Zero. Vamos a desglosar cada una a continuación.

"Todo es explícito"

El lema no oficial en la documentación de Zero es todo es explícito. El lenguaje evita deliberadamente esa maquinaria oculta que hace cómodos otros lenguajes de sistemas para humanos pero traicioneros para generadores de código:

• Sin recolector de basura obligatorio.
• Sin asignador de memoria oculto.
• Sin runtime asíncrono implícito.
• Sin globales mágicos: nada de stdout ambiental, nada de process.env, nada de sistema de archivos implícito.

Cualquier cosa que una función haga que toque el mundo exterior tiene que aparecer en su firma. Es bastante texto para una persona; para un agente que razona sobre lo que hace una función, es un regalo.

Capacidades, no globales

La forma en que Zero gestiona la E/S es el ejemplo más claro de esta filosofía. No existe una función print global. La salida ocurre a través de un valor World que el runtime entrega a main:

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

Si una función en lo más profundo de tu pila de llamadas quiere escribir una línea de log, tiene que recibir explícitamente un World (o una capacidad más estrecha). Puedes leer la firma de una función y saber, sin leer su cuerpo, si podría tocar la red, el sistema de archivos o la salida estándar. Esa es la clase de propiedad en la que un analizador estático (o un agente revisando código) puede confiar.

La capacidad World entra más a fondo en esta idea.

Fallos explícitos con raises y check

Las funciones que pueden fallar lo declaran. Quienes las invocan lo reconocen. No hay lanzamientos silenciosos:

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 } en validate significa "esta función puede fallar con InvalidInput". check en el sitio de llamada significa "si esto falla, propaga el error hacia arriba". No puedes dejar caer un error por accidente: o aparece en la firma de tu función o el compilador te detiene. Mira Raises y Check para la historia completa.

Un compilador que habla con los agentes

La parte más distintiva de Zero no es una característica de sintaxis, sino la salida del compilador. Ejecuta zero check --json sobre un programa con errores y recibes algo así:

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

Tres cosas hacen que esto sea distinto de un error de compilador normal:

1. Códigos de error estables. NAM003 significa "identificador desconocido" hoy y va a significar exactamente lo mismo en la próxima versión del compilador. Los agentes pueden hacer pattern matching sobre el código sin parsear inglés.
2. Metadatos de reparación estructurados. El campo repair nombra un tipo de arreglo que el compilador cree que resolvería el error. Un agente puede pedir el plan con zero fix --plan --json y aplicarlo.
3. No hace falta parsear prosa. El objetivo es justamente que un agente no tenga que interpretar un mensaje amigable para humanos para decidir qué hacer.

Diagnósticos JSON explica el formato en detalle.

Superficie pequeña a propósito

La gramática de Zero es pequeña y regular, más cercana en espíritu al C temprano que a un lenguaje "todo en uno" como Scala o el C++ moderno. El motivo es práctico: un agente debería poder interiorizar todo el lenguaje durante una sesión sin equivocarse en casos límite.

Eso significa que vas a encontrar:

• Una forma de declarar una función (fun o pub fun).
• Una forma de ligar un valor local (let).
• Una forma de modelar tipos producto (shape), una forma de modelar tipos suma (choice), una forma para enumeraciones simples (enum).
• Un único constructo de pattern matching (match).
• Un único constructo de bucle en la versión temprana del lenguaje (while).

Lo que no vas a encontrar — al menos en esta etapa — son sobrecarga de operadores, conversiones implícitas, macros, decoradores ni tres formas competidoras de expresar la misma idea. No es ascetismo; es una decisión deliberada para mantener la superficie lo bastante pequeña como para que un agente rara vez elija la variante equivocada.

Lo que Zero no es

Para fijar expectativas:

• No es un lenguaje de scripting. Zero compila a binarios nativos. Los programas son pequeños (la documentación menciona ejecutables por debajo de los 10 KB) y no arrastran un runtime.
• No es Rust, no es Go, no es Zig. La sintaxis comparte ancestros pero las prioridades son distintas: Rust optimiza para la seguridad de memoria con un sistema de tipos sofisticado, Zero optimiza para que un agente lo aprenda con uno deliberadamente diminuto.
• No es estable. Zero es pre-1.0. El equipo es claro: aterrizarán cambios incompatibles si sirven a los objetivos agent-first. No dependas de él para nada serio todavía.
• No es una funcionalidad de la plataforma de despliegue de Vercel. Aunque venga de Vercel Labs, Zero no está atado a Next.js ni al hosting de Vercel. Es un lenguaje de sistemas independiente.

Cuándo probar Zero hoy

Te interesa probar Zero hoy si te llama la atención:

• Cómo cambia un lenguaje cuando sus restricciones de diseño vienen de los agentes y no de los humanos.
• Experimentar con E/S basada en capacidades sin adoptar un lenguaje de investigación.
• Ver cómo se siente una "salida de compilador estructurada" como característica de primer nivel en lugar de un añadido a posteriori.
• Darle feedback a Vercel Labs sobre un proyecto que evoluciona activamente.

Te conviene saltártelo (por ahora) si necesitas un lenguaje estable para trabajo real, si quieres un ecosistema maduro de bibliotecas o si necesitas herramientas multiplataforma al nivel de Rust o Go.

Lo siguiente: instalar Zero

La próxima página recorre la instalación de la cadena de herramientas de Zero y la compilación de tu primer programa. Lleva un minuto de principio a fin.