Language

Mistakes surface before anything runs

The Open Engineering Language is statically typed and compiled. Its checks cover types, ownership, permissions and the limits of the target.

FeatureWhat it means for your code
Static types and ownershipType, ownership and definite-initialization mistakes are caught when you check a program.
Native executablesPrograms compile straight to self-contained executables, with no interpreter or virtual machine to run and no second language to install unless you write functions in one.
Effects and capabilitiesCompile-time checks let code do only what it has been allowed to do.
Defined arithmetic and indexingAn overflow or an out-of-range access is reported, never silently ignored.
Predictable memoryFixed-capacity collections, an explicit result when something is full, and no mandatory heap on small devices.
Building blocksAgents, subagents, nodes, edges, configuration, hooks and skills are first-class, each in its own named file.
Snapshot configurationTyped, reusable configuration is locked into a snapshot for each run, so settings cannot change under a running agent.
HooksAuthorization, auditing or cleanup before or after any component, function or statement, in ordered or parallel groups. A failed authorization fails closed.
Isolated componentsAn agent, node or subagent marked as isolated runs in a sandbox in its own process, reachable only through the edges you declare. This uses the isolation facilities of Linux: on any other target an isolated component is refused, never run without isolation.
Functions in other languagesPrivate functions written in other languages, with typed signatures in the language, built and run with your own toolchains and pinned by version.

Agents and models

Agents, models and knowledge as typed code

An agent is a typed function with a prompt, tools and a budget. The models, tools and documents it uses are declared, not discovered at run time.

  • Typed agents

    A system prompt as business policy, typed tools, and typed inputs and outputs with your own input builders and output checks.

  • Multi-agent patterns

    Supervisor, pipeline, router, fan-out and join, peers, quorum, handoff and typed delegation are built in.

  • Budgets and approval

    Token, time, CPU, memory and concurrency budgets apply across every child agent, and a run can pause for human approval.

  • Models

    A built-in client for OpenAI-compatible APIs, local or cloud, with policies for one call, a bounded loop, routing, ordered fallback and an independent verifier.

  • Tools and delegation

    A built-in MCP client discovers and calls MCP tools. Agents delegate long-running work to remote agents over A2A.

  • Knowledge

    Retrieval (RAG) from ingestion to ranked results with provenance, with your own knowledge connectors and multimodal input.

Agents as typed code

Services and connections

A console agent first, a service when you need one

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 the console.

  • Optional HTTP, gRPC, WebSocket and socket servers
  • Event, polling and scheduled triggers
  • Retries that respect idempotency, backpressure, circuit breakers and health checks
  • Your existing Python, JavaScript, Java or .NET programs and shell commands as typed tools, with runtimes you provide
  • Your own connectors for services, models, knowledge sources and log sinks

One edge, three placementssame source

  1. In one process

    A direct, typed call between two components

  2. Between processes

    The same typed channel across a process boundary

  3. Over the network

    The built-in gRPC-compatible transport, with TLS

The Compiler generates the communication from your edge declaration. The deployment decides the placement.

Optional packages

Robotics, scientific computing and quantum computing

These domains are designed as optional packages, so a program that does not select them carries none of their code.

  • Robotics

    The same code runs against virtual hardware, a simulator or a robot.

    • Typed units, coordinate frames and sensor schemas
    • ROS 2 and DDS, with DDS-XRCE for constrained hardware
    • AI proposes; validators, the watchdog and the emergency stop stay in charge
  • Scientific computing

    Numerical work in the same language as the agent that uses it.

    • Numerical arrays, complex numbers and linear algebra
    • Optimization, signal processing and integration
    • Automatic differentiation
  • Quantum computing

    Circuits are typed values an agent can propose, validate and simulate.

    • Typed circuits with standard and custom gates
    • Simulators that state their precision limits
    • Export to OpenQASM and QIR

No official package is published yet in the early preview. How packages work

Deployment and devices

Built for servers you operate, down to small devices

Programs run on servers, in containers and on devices, with nothing to compile or download at startup.

  • Static Linux executables and minimal container images
  • A multi-core, nonblocking runtime with no thread per user
  • A trusted tenant identity through every call, store, log and reply
  • CPU and memory limits per agent, each stated as hard-enforced or accounted
  • Time and token usage reported by default on every channel
  • Structured logs with redaction, rotation and retention

On microcontroller boardsBeing qualified

  • No heap and no operating system in the smallest profile
  • Bounded mailboxes, timers, cooperative scheduling and supervision
  • GPIO, clocks, UART, interrupts and defined panic behavior
  • RAM, flash and stack reports for a firmware image

A feature a target cannot support fails when you build, not on the device.

Tooling

One command-line tool for the working loop

The tool is oel. These commands are in the early preview; the full reference is in the documentation.

CommandWhat it does
oel initCreates a ready-to-build project.
oel checkRuns the type, ownership and permission checks, with diagnostics that point at your source.
oel fmtFormats source files the same way every time.
oel buildBuilds a native executable, with debug information for standard native debuggers.
oel runBuilds and runs a program on this machine, and reports time and token usage.
oel testRuns the tests a project declares, with line and function coverage of your code.
oel refmapShows what references what, and lists unused code, for a project, a folder or one file.
oel packageBuilds a library into one package file.

Command-line reference

Resources

More on the Compiler

Request early preview access

Tell us which of these areas matter to you, and the platform you build on.