OpenEng Labs

OEL (previously AEL) 1.0.0

Agents

You write agents, their prompts, tools and typed inputs and outputs as ordinary code, so mistakes surface before anything runs.

What you build

With OEL 1.0.0 you build software-engineering agents, agents that serve HTTP or MCP clients, agents on devices and microcontrollers, and robot agents.

  • Software-engineering agents

  • Agents that serve HTTP or MCP clients

  • Agents on devices and microcontrollers

  • Robot agents

Agents as code

Agents, subagents, nodes (business steps), edges (typed two-way connections), configuration, hooks and skills are first-class building blocks, each in its own named file, so a project's structure reads at a glance.

  • You write an agent's business policy as a system prompt (inline, from a file, from the environment or from configuration), or run it on its input alone with no system prompt.
  • Agents take typed inputs and return typed outputs, with your own input builders and output checks and a choice of raw or typed results.
  • Hooks attach authorization, auditing or cleanup before or after any component, function or statement, run in ordered or parallel groups, and fail closed when authorization fails.
nodes/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.
}
agents/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;
    }
}

Workflows and teams of agents

You compose supervisors, pipelines, routers and teams of agents that share one budget, wait for human approval when needed and resume from a storage point you declare.

  • One workflow mixes model-driven and deterministic decisions, and routes sensor readings or events without paying for a model call.
  • Hierarchical and multi-agent patterns are built in: supervisor, pipeline, fan-out and join, router, peers, quorum, handoff and typed delegation.
  • Agents discover remote agents and delegate long-running work to them over A2A.
  • Runs pause, wait for human approval and reconcile side effects safely, and a run whose agent declares a storage point resumes and survives restarts.
  • A run is durable only when its agent declares a storage point, a storage package you select that keeps the run's state in a directory, in object storage or in an SQL database you run; without one, the run runs to completion and keeps nothing.

Teams of agents

  • Supervisors
  • Pipelines and routers
  • Resume from a storage point
  • Human approval

Subagents and two-way edges

  • Subagents

    • An agent spawns subagents at run time: short-lived agents that each do one task, return a typed result to the agent that spawned them and end, leaving nothing running.
    • One agent can spawn more than a hundred subagents for a single request, while only a bounded number run at the same time.
    • A subagent draws on the budget, deadline and cancellation of the agent that spawned it, and holds only the permissions and resources that agent grants it, or, when it is isolated, only the resources it declares itself.

  • Two-way edges

    • Every edge is a typed, two-way channel: OEL generates the communication between nodes, agents and subagents from your edge declarations, with no client or server code for you to write.
    • The same edge runs in one process, between processes or over the network, as your deployment places it, with no change to your source, and over the network it uses OEL's built-in gRPC-compatible transport with TLS.

Guardrails built in

  • One shared budget

    Retries, output repair, timeouts and cancellation draw on one shared budget, so nested retries cannot multiply cost.

  • Budgets across every child agent

    Token, time, CPU, memory and concurrency budgets apply across every child agent.

  • Scoped state and memory

    State and long-term memory are scoped per tenant, agent, session or subject, with retention and deletion rules.

  • Multi-tenant from the start

    Agents are multi-tenant from the start: a trusted tenant identity flows through every call, store, log and reply, with fair scheduling and predictable behavior under overload.

  • Isolated components

    You mark an agent, node or subagent as isolated: it always runs in a sandbox in its own process, outside the shared communication layer, reachable only through the edges you declare and holding only the resources it declares itself.

    Isolation needs the isolation facilities of Linux and runs only on the Linux target the documentation names for it: on macOS, on Windows, on microcontroller boards, on other Linux targets and on any host without those facilities, an isolated component is refused, never run without isolation.

  • Declared resources

    An agent, subagent or node declares the memory, skills, knowledge, storage and database it uses, each bound to a package you select, and the check refuses any use it did not declare.

Models, tools and testing

  • MCP tools

    A built-in MCP client discovers and calls MCP tools, and an optional package exposes your agents as MCP tools.

  • Skills

    A skill is a versioned, reusable bundle of instructions, typed tools and functions that an agent or subagent loads through the skills it declares; its tools run only where the agent's permissions allow, and it adds nothing the agent did not declare.

  • Prompts as releasable business logic

    Prompts are treated as releasable business logic, with evaluations, recorded-model regression tests, drift checks, and promotion with one-step rollback, while active runs stay pinned to their version.

  • Record and replay

    You record control and orchestration runs and replay them to find the first point where behavior diverged.

All model and knowledge features

Services, devices, robots and quantum

  • REST APIs

    A console agent needs no server: add the HTTP package and declare routes to make it a REST API, or remove them to go back to console-only.

  • Small devices

    Prompt-driven agents run on small devices through OEL Gateway, and each device keeps its safe local behavior when offline.

  • Hierarchical robot agents

    Hierarchical robot agents (for example eyes, face, body and a coordinator) come with ready-made recipes.

  • Hybrid agent workflows

    Hybrid agent workflows let an agent propose a circuit, validate it, simulate it, optionally run it on hardware and check the result.

Examples

Complete example agent systems and deployment recipes come with OEL 1.0.0.

Read the documentation (opens in a new tab)Everything in OEL 1.0.0Get OEL 1.0.0