The ProgrammingLanguage for Agents

Experimental

The Programming

A programming language where the graph is the program. Humans ask for outcomes. Agents query the program graph, submit checked edits, and prove the result.

For humans

For agents

`$ curl -fsSL https://zerolang.ai/install.sh | bash`

1Human

Asks for an outcome

Build a CRM API, add auth, or fix a failing route

2Agent

Uses Graph

Symbols, calls, types, effects, node IDs, and graph hashes

3Compiler

Checks patches

Shape, type, stale-state, and repository metadata checks

4Human

Reviews projection

Readable .0 projections stay available for review and rare manual edits

Expect breaking changes. Run it in a safe environment, not against production systems.

Start with a request.

The expected workflow is a normal conversation. The graph discipline lives in the agent skills and compiler commands, not in stiff human prompts.

your agent

build hello world in zerolang

I'll set up the package, patch the graph, and run it.

zero init

zero patch \--op addMain \--op 'addCheckWrite fn="main" text="hello from zero\\n"'

zero run

Done. `zero.graph` validated at `graph:a7f7e689` with symbol `main`. It prints:

hello from zero

Tighter agent loop.

A traditional loop writes text, then runs tools to learn what the edit meant. Zerolang puts the compiler in the loop, so an edit is a checked change to the graph.

Traditional

Text is the source of truth

Zerolang

Graph is the program

repeat

repeat

agent writes source text

format

check

build

test

inspect failures

agent writes graph patch

compiler checks patch

projection available for review

Checked by default.

Graph patches target semantic nodes and fields, guarded by graph hashes and expected values. Stale or invalid edits fail before they touch the store.

zero patch

zero patch \
  --expect-graph-hash graph:a7f7e6899a73f3b4 \
  --op 'set node="#expr_653eeb6e" \
    field="value" \
    expect="hello from zero\n" \
    value="hello graph\n"'

graph hashgraph:b3c1d04f

node#expr\_653eeb6e

fieldvalue

symbolsmain

projectionsrc/main.0

The program database.

Readable text stays useful for review. The compiler-owned graph is the program database agents edit and the compiler consumes.

zero query · graph

zero-graph v1
origin source-text
module "hello"
hash "graph:a7f7e6899a73f3b4"
node #decl_ad8d9028 Function name:"main" type:"Void" public:true fallible:true
node #param_4610ae76 Param name:"world" type:"World"
node #expr_c403020c MethodCall name:"write" type:"Void"
node #expr_653eeb6e Literal type:"String" value:"hello from zero\n"
edge #expr_c403020c arg #expr_653eeb6e order:0

src/main.0 · projection

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

Built for runtime constraints.

The graph model should reduce guessing without relaxing the runtime goals. Zerolang still aims to stay small, fast, explicit, and dependency-free.

Token efficiency

Low memory

Fast startup

Fast builds

Low latency

Zero dependencies

Explore with us.

Start with the getting started guide, then read the graph architecture and compile-path pages to see why the program database matters.

Get started Graph architecture