Agent-first язык программирования звучит как хорошая идея, да?

В конце концов, агентам не нужны фигурные скобки. Им не нужна красота if, while, for, match, Result, try, await, naming conventions и вот этого всего, сделанного для нас - кожаных мешков.

Именно поэтому Zero от Vercel Labs на первый взгляд выглядит как интересный эксперимент. Официальный сайт называет его языком для агентов, README говорит про "agent-first programming language", а авторский пост в X обещает systems language, который быстрее, меньше и проще для агентов в использовании и дебаге.

Звучит почти убедительно. До тех пор, пока вы не открываете код.

Что такое Zero

Zero - экспериментальный systems language от Vercel Labs. Репозиторий vercel-labs/zero на момент написания уже набрал тысячи звезд, релизы и стандартный для продуктов Vercel уровень упаковки: сайт, документация, примеры, CLI, бенчмарки и т.д, и т.п.

Официальный pitch такой:

• минималистичный и простой синтаксис, чтобы агент мог "выучить его на лету";

• стандартная библиотека вместо поиска зависимостей;

• structured tooling: diagnostics, graph facts, size reports, repair plans в машинно-читаемом виде;

• explicit effects: доступ к внешнему миру должен быть виден в сигнатуре;

• предсказуемая память, маленькие native binaries, меньше магии.

Если убрать маркетинг, идея нормальная. Даже хорошая.

Проблема в том, что почти каждый пункт уже существует где-то рядом: в Rust, Zig, TypeScript, Language Server Protocol, компиляторах с JSON output, статических анализаторах, линтерах, пакетных менеджерах и просто в нормальной инженерной дисциплине. Zero же пытается продать это как новые подходы в дизайне языка, приправленные синтаксисом а-ляret + 40 2, чтобы казаться более "агентским".

Agent-first learnability

Официальная формулировка: язык должен быть маленьким, регулярным, с небольшим количеством special cases, чтобы агент мог быстро научиться по примерам, документации и feedback от компилятора.

В теории - отлично. LLM действительно лучше работают с регулярными паттернами. Чем меньше синтаксических исключений, тем ниже вероятность, что модель начнет галлюцинировать JavaScript внутри Rust внутри YAML.

Но есть нюанс, который почему-то постоянно забывают в разговорах про "язык для AI": агент не появляется в вакууме. Он обучается на датасете.

TypeScript, Rust, Zig, Python, Go, C, C++ есть в training data в промышленных объемах. Там есть миллионы репозиториев, issues, PR, Stack Overflow, блогов, compiler errors, CI logs, cargo output, GitHub Actions, линтеров и гайдов на Хабр о том, как завести create-react-app. Данных по zero, извиняюсь за каламбур, - zero.

То есть "агент может выучить язык на лету" на практике означает: каждый раз кормить агенту документацию, примеры, skill-файлы и надеяться, что он не перепутает синтаксис Zero с любым похожим языком, который был у него в датасете. Это не learnability. Это context tax.

И пока я писал эту статью о синтаксисе Zero, его похожести на другие языки и той самой learnability случается следующее:

21 мая 2026 года в репозитории появляется коммит 229331fe93119e481cd24fd75b3d67a9e2c1db84:

Сухая статистика: 711 файлов изменено, 6854 вставки, 8904 удаления. Мигрировали examples, fixtures, docs, skills и command contracts.

До:

fun answer() -> i32 {
    return 40 + 2
}

pub fun main(world: World) -> Void raises {
    let value = answer()
    if value == 42 {
        check world.out.write("math works\n")
    } else {
        check world.out.write("math broke\n")
    }
}

После:

// Скобки отменили, урааа, будущее
fn answer i32
    ret + 40 2

pub fn main Void world World !
    let value answer()
    if == value 42
        check world.out.write "math works\n"
    else
        check world.out.write "math broke\n"

С одной стороны, да, синтаксис стал "регулярнее". С другой - он стал похож на... Lisp? Извиняюсь перед любителями Lisp на всякий случай.

И самое смешное: агентам не "не нужны if/while/for". Документация Zero спокойно оставляет if, else, while, range for, match, enum, choice, type, defer, owned<T>, ref<T>, mutref<T>, Alloc, Maybe<T> и прочую человеческую цивилизацию. Просто теперь if value == 42 превратился в if == value 42.

Да, теперь выглядит действительно "agents-first".

Standard library first

Zero говорит: "агентам не надо каждый раз выбирать dependency stack". Частые задачи должны жить в стандартной библиотеке, с документированными API и предсказуемым поведением. Это, без иронии, правильная цель.

Агенты действительно плохо выбирают зависимости. Они берут пакет с 80 звездочками, последним релизом в 2019 году, API из README, которого уже нет, и потом с уверенностью объясняют, что "ошибка, вероятно, связана с окружением. Пошарьте свой .env. Я разберусь".

Но standard-library-first - это не уникальная идея. Go живет на этом десятилетиями. Python со своим "batteries included", тоже пытался. Rust пошел в другую сторону, но компенсировал ecosystem + cargo + docs.rs. TypeScript вообще паразитирует на огромной JS-экосистеме.

У Zero пока есть набор модулей: std.mem, std.codec, std.parse, std.fs, std.io, std.json, std.env, std.time, std.rand, std.proc, std.crypto, std.net, std.http. На бумаге выглядит прилично. Но проблема в том, что агенту нужен не только std.parse.isAsciiDigit, а знания вокруг: библиотеки, баги, паттерны, Stack Overflow, CI failures, странные edge cases и чужой production experience.

Без этого агент не "пишет на языке". Он решает синтаксическую головоломку с подсказками от компилятора.

Deterministic tooling

Несмотря на странную формулировку, тут Zero действительно выделяет хорошую идею.

Идея: человек читает сообщение, агент читает JSON. Компилятор не просто ругается, а дает структурированное описание проблемы и потенциальный план исправления.
Это сильная часть Zero, но проблема в том, что для этого не нужен новый язык. Это уже есть в Rust! Cargo, rust-analyzer, clippy, rustfix, compiler suggestions - вся эта инфраструктура годами строилась именно вокруг машинно-читаемых сигналов. Да даже TypeScript имеет compiler API и language service. ESLint давно выдает machine-readable reports и autofix.

Zero делает правильную вещь, но делает ее в самом дорогом месте: на уровне нового языка, новой экосистемы, нового синтаксиса и новой привычки для всех.

Сравнение с TypeScript, Zig, Rust

Возьмем самый честный пример: функция возвращает 42, программа печатает math works.

Zero (новый row syntax)

fn answer i32
  ret + 40 2

pub fn main Void world World !
  let value answer()
  if == value 42
    check world.out.write "math works\n"
  else
    check world.out.write "math broke\n"

TypeScript

function answer(): number {
  return 40 + 2;
}

function main(): void {
  const value = answer();

  if (value === 42) {
    process.stdout.write("math works\n");
  } else {
    process.stdout.write("math broke\n");
  }
}

main();

TypeScript не systems language, он явно не agents-first, но у него есть то, что для агента пока важнее синтаксической "регулярности": гигантская обучающая база. Модель видела этот код миллионы раз. Она знает, как выглядит if, как выглядит process.stdout.write, как выглядят типы, ошибки tsc, ESLint autofix, Vitest, package.json и Stack Overflow ответы из 2007 года, которые уже не работают, но все еще лежат в датасете как культурный слой.

И самое интересное, что Zero, как язык, сразу сделанный для агентов даже не особо-то и компактнее. То есть вы вряд ли сэкономите много токенов при переезде на него с TS.

Поехали сравнивать с более близкими экземплярами.

Zig

const std = @import("std");

fn answer() i32 {
    return 40 + 2;
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    if (answer() == 42) {
        try stdout.writeAll("math works\n");
    } else {
        try stdout.writeAll("math broke\n");
    }
}

Если бы Zero был "Zig plus first-class JSON repair metadata for agents", разговор был бы интереснее. Но текущий row syntax выглядит не как следующий шаг после Zig, а как попытка доказать, что префиксные операторы - это точно нужно агентам.

Rust

use std::io::{self, Write};

fn answer() -> i32 {
    40 + 2
}

fn main() -> io::Result<()> {
    let value = answer();
    let mut out = io::stdout().lock();

    if value == 42 {
        out.write_all(b"math works\n")?;
    } else {
        out.write_all(b"math broke\n")?;
    }

    Ok(())
}

Rust сложный. Давайте все, кто пытался его изучить, но так и не осилил, нажмут стрелочку вверх под этой статьей. Но Rust дает агенту сильные guard rails в виде типов, ownership, ?, cargo check, rustc --error-format=json, rust-analyzer и огромной базы реального кода.

Да, агент будет спорить с borrow checker. Но это хотя бы будет спор с надежным механизмом, который уже проверен годами и тысячами разработчиков.

Если свести сравнение к тому, что реально важно агенту, получается не очень празднично для Zero:

Но самый честный аргумент против Zero: агенты учатся на прошлом

Vercel говорит: язык должен быть learnable on demand.

Но LLM не учится как человек-разработчик, которому выдали tutorial. LLM продолжает предсказывать следующий токен на основе своего датасета. Если в прошлом нет языка, у модели нет "интуиции". Есть только prompt, docs и feedback loop.

Да, агент может читать документацию Zero. Да, можно положить в репозиторий AGENTS.md, skill-data и examples. Да, можно сделать zero check --json, zero fix --plan --json, zero explain NAM003.

Но это означает, что лучший сценарий для Zero - не "агенты наконец получили свой язык". Лучший сценарий - "мы построили маленькую closed-loop среду, где агент может много раз ошибаться, компилятор его поправляет, а человек надеется, что итоговый diff имеет смысл".

Это не революция языка. Это REPL с autocomplete с ценой в ваших токенах.

Что говорят люди

Запуск в X был заметным. В агрегированном кластере Digg по оригинальному посту Chris Tate указаны 1.2M views, сотни комментариев и почти идеально расколотый sentiment: 49.9% positive против 50.1% negative. Удивительно, что так много позитивных.

На Reddit в обсуждении r/WebAfterAI дискуссия была более инженерной. Один комментарий хорошо формулирует скепсис: effects flavor - интересно, но не объяснено, что именно здесь так хорошо для агентов, потому что похожие linter/checker workflows есть во многих языках.
Но один комментарий хочу выделить отдельно, потому что это буквально та мысль, которая мучает меня и по сей день: почему это не middleware/readable layer поверх существующих языков?

То есть общественный консенсус примерно следующий: идея интересная, но все ждут, когда кто-то объяснит, зачем ради нее нужен новый язык, а не нормальные инструменты для старых.

Итог

Стоит проговорить, что вообще мне нравятся Vercel и их продукты, пока не нужно за них платить. Они сделали деплой пет-проектов очень простым и бесплатным, запустили классную инициативу с skills.sh, сделали шикарный cli agent-browser, но есть и очень спорные решения с их стороны, как например и это.

Zero - хороший эксперимент и ненужный язык программирования.

Если язык “для агентов”, но отсутствует в датасетах агентов, он начинает с минуса.
Если он “learnable on demand”, но синтаксис уже через несколько дней радикально меняется, будто у авторов нет четкого представления, что они хотят сделать.
Если он “agent-first”, но его все равно должны ревьюить люди в какой-то момент, то human readability нельзя выбрасывать как необязательную роскошь.

Возможно, через год Zero превратится в очень умный compiler/tooling layer, который все будут цитировать как ранний пример agent-readable development environment. Возможно, Vercel найдет killer use-case. А возможно, Zero станет еще одним репозиторием, который люди будут открывать в 2030 году со словами: “О, помните, когда мы думали, что AI-агентам нужен свой язык программирования?”

Если вам понравилась статья, и вы все-таки хотите читать о реально полезных инструментах для агентской разработки, то приглашаю в свой телеграм канал: OpenKirill: AI Coding и другие приколы. Мы там разбираем тулинг, следим за новыми трендами в AI кодинге, и хорошо проводим время.