Early preview
Agents as typed code
You write agents, their prompts, tools and typed inputs and outputs as ordinary code, so mistakes surface before anything runs.
Agents as code
The prompt, the model and the logic in one file
A node is one business step. Its configuration names the prompt, the model binding and the retry limit; its body is ordinary typed code.
- A system prompt inline, from a file, from the environment or from configuration
- Typed inputs and outputs, with your own input builders and output checks
- Private helpers that only their owner can call
# nodes/summarize.node.oel
node summarize(input: Request) -> Summary {
config {
prompt: file("prompts/summarize.md");
model: binding("primary_model");
max_attempts: 2;
}
return write_summary(input);
}
fn write_summary(input: Request) -> Summary {
# A private helper: only this node can call it.
}Building blocks
Seven building blocks, each in its own file
An agent system is made of a small set of parts. The file name of each part says which one it is.
| Building block | What it is |
|---|---|
| Agent | Takes a typed input and returns a typed output. Its configuration names its nodes, its edges, and where a run starts and completes. |
| Subagent | A short-lived agent spawned at run time. It does one task, returns a typed result to the agent that spawned it and ends, leaving nothing running. |
| Node | One business step: a prompt, a model binding and typed code. |
| Edge | A typed, two-way channel. The Compiler generates the communication between nodes, agents and subagents from its declaration, with no client or server code to write. |
| Configuration | Typed and reusable, locked into a snapshot for each run. |
| Hook | Authorization, auditing or cleanup before or after a component, a function or a statement. A failed authorization fails closed. |
| Skill | A versioned bundle of instructions, typed tools and functions that an agent loads through the skills it declares. |
Teams
Compose agents into teams
An agent’s configuration wires nodes together with edges. The same patterns reach from two nodes to a hierarchy of agents.
- Supervisor, pipeline, router, fan-out and join, peers, quorum, handoff and typed delegation
- Model-driven and deterministic decisions in one workflow
- Runs that pause and wait for human approval
- A run is durable only when its agent declares a storage point; without one it runs to completion and keeps nothing
# agents/support.agent.oel
agent support(input: Request) -> Decision {
config {
nodes: [summarizer = summarize, verifier = verify];
edges: [summary_to_verify(summarizer, verifier)];
starts: [summarizer];
completion: summary_to_verify.callback_result;
}
}Guardrails
Limits that hold across every child agent
Budgets, permissions and resources are declared in the program and checked, so a nested agent cannot exceed what its parent was given.
One shared budget
Retries, output repair, timeouts and cancellation draw on one budget, so nested retries cannot multiply.
Budgets for every child
Token, time, CPU, memory and concurrency budgets apply across every child agent.
Granted permissions
A subagent draws on the budget, deadline and cancellation of the agent that spawned it, and holds only the permissions that agent grants.
Declared resources
An agent declares the memory, skills, knowledge, storage and database it uses. The check refuses any use it did not declare.
Scoped state
State and long-term memory are scoped per tenant, agent, session or subject, with retention and deletion rules.
Isolated components
An isolated agent, node or subagent runs in a sandbox in its own process. This uses the isolation facilities of Linux; elsewhere it is refused.
Models and tools
Models, tools and knowledge you choose
No model is bundled. An agent names a model binding, and you decide which endpoint stands behind it.
| Area | What the Compiler is designed to provide |
|---|---|
| Models | A built-in client for OpenAI-compatible APIs, for local model servers and for major cloud providers. |
| Model policies | Exactly one call, a bounded loop, routing, ordered fallback, parallel fan-out and an independent verifier model. |
| Tools | A built-in MCP client that discovers and calls MCP tools. A query a model proposes is data until your validator admits it. |
| Remote agents | Discovery of remote agents, and delegation of long-running work to them over A2A. |
| Knowledge | Retrieval (RAG) with ranking and provenance, and your own knowledge connectors. |
| Prompts | Prompts treated as releasable logic, with evaluations and regression tests against recorded model replies. |
| Usage | Time and token usage reported for every run, by default. |
Resources
More on the Compiler
Compiler overview
What the Compiler is, how you write, check, build and run a program, and where programs run.
Features
The designed scope by area: language, agents, models, services, tooling, deployment and devices.
Packages
The signed official registry, the package families, and private packages you build and host.
Compiler 1.0.0
What the early preview covers today, area by area, and how to follow each update.
Get the Compiler
Early preview access by message, per platform. No public download is published.
Questions and answers
Platforms, access, packages, security reports and support, answered in one place.
Documentation
The language guide, agents, packages, platforms and the command-line reference.
Release notes
The record of every Compiler release, on the releases site.
Request early preview access
Tell us what kind of agents you want to build and where they will run.