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
summarize.node.oel
# 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 blockWhat it is
AgentTakes a typed input and returns a typed output. Its configuration names its nodes, its edges, and where a run starts and completes.
SubagentA 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.
NodeOne business step: a prompt, a model binding and typed code.
EdgeA 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.
ConfigurationTyped and reusable, locked into a snapshot for each run.
HookAuthorization, auditing or cleanup before or after a component, a function or a statement. A failed authorization fails closed.
SkillA 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
support.agent.oel
# 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.

AreaWhat the Compiler is designed to provide
ModelsA built-in client for OpenAI-compatible APIs, for local model servers and for major cloud providers.
Model policiesExactly one call, a bounded loop, routing, ordered fallback, parallel fan-out and an independent verifier model.
ToolsA built-in MCP client that discovers and calls MCP tools. A query a model proposes is data until your validator admits it.
Remote agentsDiscovery of remote agents, and delegation of long-running work to them over A2A.
KnowledgeRetrieval (RAG) with ranking and provenance, and your own knowledge connectors.
PromptsPrompts treated as releasable logic, with evaluations and regression tests against recorded model replies.
UsageTime and token usage reported for every run, by default.

All features, by area

Resources

More on the Compiler

Request early preview access

Tell us what kind of agents you want to build and where they will run.