Was ist Zero? Die Programmiersprache für KI-Agenten

Eine Sprache, die um ihre Leser herum entworfen wurde

Die meisten Programmiersprachen wurden für Menschen entworfen. Ihre Grammatiken optimieren für das, was Menschen wichtig ist: knappe Syntax, ausdrucksstarke Idiome, „elegante" Abkürzungen. Compiler geben Fehlermeldungen als Prosa aus, weil sie von einem Menschen gelesen werden. Standardbibliotheken sind so organisiert, wie es sich für die Autorinnen und Autoren gut einprägt.

Zero startet von einer anderen Prämisse. Seine primären Leser sind KI-Agenten – Sprachmodelle, die im Auftrag von jemandem Code schreiben, debuggen und reparieren. Menschen bleiben im Spiel, aber das Sprachdesign behandelt Agenten von Tag eins an als erstklassige Nutzer. Dieser eine Perspektivwechsel zieht sich durch fast jedes sichtbare Feature der Sprache.

Zero wird von Vercel Labs gebaut, lebt unter zerolang.ai und ist quelloffen auf github.com/vercel-labs/zero zu finden. Quelldateien enden auf .0.

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

Fünf Dinge in diesem Snippet – pub, World, raises, check und das explizite world.out.write – verraten schon eine Menge darüber, wie Zero tickt. Wir packen sie unten der Reihe nach aus.

„Alles ist explizit"

Der inoffizielle Slogan in Zeros Doku lautet alles ist explizit. Die Sprache vermeidet bewusst die versteckte Mechanik, die andere Systems-Sprachen für Menschen bequem, aber für Code-Generatoren tückisch macht:

• Kein verpflichtender Garbage Collector.
• Kein versteckter Allocator.
• Keine implizite Async-Runtime.
• Keine magischen Globals – kein ambient verfügbares stdout, kein process.env, kein impliziter Dateisystemzugriff.

Alles, was eine Funktion tut und dabei die Außenwelt berührt, muss in ihrer Signatur auftauchen. Für einen Menschen ist das viel Tipparbeit; für einen Agenten, der überlegt, was eine Funktion tatsächlich tut, ist es ein Geschenk.

Capabilities statt Globals

Wie Zero mit I/O umgeht, ist das klarste Beispiel für diese Philosophie. Es gibt keine globale print-Funktion. Ausgabe läuft über einen World-Wert, den die Runtime an main übergibt:

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

Wenn eine Funktion tief im Aufrufstack eine Log-Zeile schreiben will, muss ihr World (oder eine engere Capability) explizit übergeben werden. Du kannst die Signatur einer Funktion lesen und weißt – ohne ihren Body anzuschauen – ob sie das Netzwerk, das Dateisystem oder stdout berühren könnte. Genau auf so eine Eigenschaft kann sich ein statischer Analyzer (oder ein Agent, der ein Code-Review macht) verlassen.

Die World-Capability geht tiefer auf diese Idee ein.

Explizites Fehlschlagen mit raises und check

Funktionen, die fehlschlagen können, deklarieren das. Aufrufer, die fehlbare Funktionen aufrufen, bestätigen das. Es gibt kein stilles Werfen:

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 } auf validate heißt: „diese Funktion kann mit InvalidInput fehlschlagen". check an der Aufrufstelle heißt: „falls das fehlschlägt, propagiere den Fehler nach oben". Du kannst keinen Fehler aus Versehen unter den Tisch fallen lassen – er taucht in der Signatur deiner Funktion auf, oder der Compiler stoppt dich. Siehe Raises und Check für die ganze Geschichte.

Ein Compiler, der mit Agenten spricht

Das markanteste Stück von Zero ist kein Syntaxfeature – es ist die Ausgabe des Compilers. Lass zero check --json auf ein kaputtes Programm los und du bekommst etwas wie das hier zurück:

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

Drei Dinge unterscheiden das von einer normalen Compiler-Fehlermeldung:

1. Stabile Fehlercodes. NAM003 heißt heute „unknown identifier" und wird in der nächsten Compiler-Version genau dasselbe heißen. Agenten können auf den Code Pattern-matchen, ohne englische Sätze zu parsen.
2. Strukturierte Repair-Metadaten. Das repair-Feld benennt eine Fix-Art, von der der Compiler glaubt, dass sie den Fehler lösen würde. Ein Agent kann den Plan mit zero fix --plan --json abrufen und anwenden.
3. Kein Parsing von Prosa nötig. Der ganze Sinn ist, dass ein Agent keine menschenfreundliche Nachricht interpretieren muss, um zu entscheiden, was als Nächstes zu tun ist.

JSON-Diagnostik erklärt das Format im Detail.

Kleine Oberfläche mit Absicht

Zeros Grammatik ist klein und regulär – im Geiste näher am frühen C als an einer „Eierlegende-Wollmilchsau"-Sprache wie Scala oder modernem C++. Die Überlegung ist praktisch: Ein Agent sollte die gesamte Sprache während einer Sitzung verinnerlichen können, ohne bei Randfällen Mist zu bauen.

Du findest:

• Einen Weg, eine Funktion zu deklarieren (fun oder pub fun).
• Einen Weg, einen lokalen Wert zu binden (let).
• Einen Weg, Produkttypen zu modellieren (shape), einen Weg für Summentypen (choice), einen Weg für reine Aufzählungen (enum).
• Ein Konstrukt für Pattern-Matching (match).
• Ein Loop-Konstrukt in der frühen Sprache (while).

Was du nicht findest – jedenfalls nicht in diesem Stadium – sind Operator-Overloading, implizite Konvertierungen, Makros, Decorators oder drei konkurrierende Wege, dieselbe Idee auszudrücken. Das ist keine Askese; es ist eine bewusste Entscheidung, die Oberfläche klein genug zu halten, damit ein Agent selten die falsche Variante wählt.

Was Zero nicht ist

Damit die Erwartungen stimmen:

• Keine Skriptsprache. Zero kompiliert zu nativen Binärdateien. Programme sind klein (die Doku spricht von Executables unter 10 KB) und schleppen keine Runtime mit.
• Nicht Rust, nicht Go, nicht Zig. Die Syntax hat gemeinsame Vorfahren, aber die Prioritäten sind anders – Rust optimiert für Speichersicherheit mit einem ausgefeilten Typsystem, Zero optimiert für Lernbarkeit durch Agenten mit einem bewusst winzigen.
• Nicht stabil. Zero ist pre-1.0. Das Team sagt ausdrücklich, dass es Breaking Changes geben wird, wenn sie Agent-first-Ziele voranbringen. Verlass dich noch auf nichts Ernsthaftes.
• Kein Feature der Vercel-Deployment-Plattform. Obwohl Zero von Vercel Labs kommt, ist es nicht an Next.js oder Vercel-Hosting gebunden. Es ist eine eigenständige Systems-Sprache.

Wann du Zero heute ausprobieren würdest

Du würdest Zero heute ausprobieren, wenn dich Folgendes interessiert:

• Wie sich eine Sprache verändert, wenn ihre Designvorgaben von Agenten und nicht von Menschen kommen.
• Mit Capability-basierter I/O experimentieren, ohne zu einer Forschungssprache greifen zu müssen.
• Anschauen, wie „strukturierte Compiler-Ausgabe" als First-Class-Feature aussieht statt als nachträglicher Gedanke.
• Vercel Labs Feedback zu einem aktiv weiterentwickelten Projekt geben.

Du würdest es (vorerst) auslassen, wenn du eine stabile Sprache für echte Arbeit brauchst, ein gereiftes Bibliotheks-Ökosystem willst oder plattformübergreifendes Tooling auf dem Niveau von Rust oder Go benötigst.

Als Nächstes: Zero installieren

Das nächste Dokument führt dich durch die Installation der Zero-Toolchain und bringt dein erstes Programm zum Kompilieren. Von Anfang bis Ende dauert das etwa eine Minute.