Graph-first program model
Agents work with the semantic graph instead of raw text, so edits target nodes, fields, calls, declarations, and other program facts directly.
Zero
ReclamarZero is an experimental graph-first programming language for agent-assisted development. Checked semantic edits, readable projections, compiler validation.
Overview
Zero is an experimental graph-first programming language built for agent-assisted development. It treats the graph as the program database, so agents query semantic structure, submit checked edits, and rely on the compiler to validate changes before they become part of the package.
The site positions Zero as a tool for situations where humans ask for outcomes and agents carry out the edit loop. Humans review projections and command output, while the compiler keeps the graph consistent through shape checks, stale-state protection, and repository metadata validation.
Features
Checked semantic edits
Patches are checked against graph hashes, expected values, shape rules, and repository metadata before they are accepted.
Early validation of invalid changes
The compiler rejects stale or invalid edits before they touch the store, which makes the edit loop more deterministic for agents.
Human-readable projections
Readable `.0` projections provide a source-like view for review and rare manual edits without making text the primary program database.
Agent-oriented command workflow
The day-to-day workflow includes query, patch, check, test, run, and build commands for agent-assisted development.
Lightweight runtime focus
The runtime goals emphasize a small, fast, explicit, dependency-free system with low memory use and fast startup/builds.
Use Cases
Agent-driven program edits
Use Zero when an agent needs to make a semantic code change, such as adding a function, updating a call, or adjusting typed program facts without rewriting text spans by hand.
Human review of generated code
Use the projection and review flow when a human wants to inspect a readable representation of the program before accepting or manually adjusting a change.
Safer incremental changes
Use the checked patch workflow when you want stale-state protection and validation to fail invalid edits before they alter the store.
Local experimentation and iteration
Use the install-and-bootstrap flow to get a local package ready, then run the daily loop of query, patch, check, test, run, and build commands.
Artifact generation and execution
Use the build and run commands when you need executable, object, or LLVM IR artifacts from the graph-backed program, especially during early exploration.
Pros and Cons
Pros
- Checked graph patches provide stale-state protection and shape validation before changes are accepted.
- `.0` projections give humans a readable review view without making text the primary source of truth.
- The command workflow is explicit, with dedicated commands for query, patch, check, test, run, and build.
- The project emphasizes a small, fast, explicit, dependency-free runtime posture.
Cons
- The site describes Zero as pre-1 and experimental, so breaking changes are expected.
- It is meant for safe, non-production environments rather than production systems.
- The documented workflow is still evolving, with some pages only partially covering features and integrations.
FAQ
How is Zero meant to be used?
Zero is designed for a human working with an agent. The agent authors the program through the graph, while the human reviews the graph summary, command output, and the `.0` projection when needed.
How do you install and start using Zero?
The getting started guide shows `curl -fsSL https://zerolang.ai/install.sh | bash`, then adding `$HOME/.zero/bin` to `PATH` and running `zero --version`. It also mentions installing the agent bootstrap skill with `npx skills add vercel-labs/zerolang`.
What does the Zero workflow look like?
The source says to use `zero query`, `zero patch`, `zero check`, `zero test`, `zero run`, and `zero build` for the daily loop. It also notes that `zero export` and `zero verify-projection` are for human review workflows.
Are there any important limitations or cautions?
The site says Zero is pre-1 and experimental, so breaking changes are expected. It also says to run it in a safe environment, not against production systems.
Can humans edit the source directly?
The product is built around `.0` projections for readable review, while the compiler owns the graph database that agents edit. Humans can occasionally edit projections, but agents are expected to work through `zero query` and `zero patch`.
Quick Facts
- Category
- Developer Tool
- Primary users
- Humans working with agents
- Source domain
- zerolang.ai
- Interface model
- Graph-first programming language
- Workflow
- `zero query`, `zero patch`, `zero check`, `zero test`, `zero run`, `zero build`
- Pricing
- Pricing page is not available; the site shows a 404/not found response