Early preview
Compiler features
What the Compiler is designed to do, area by area: the language, agents, services, packages, deployment and tooling.
This page states the designed scope. For what the early preview covers today, see Compiler 1.0.0.
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.
| Feature | What it means for your code |
|---|---|
| Static types and ownership | Type, ownership and definite-initialization mistakes are caught when you check a program. |
| Native executables | Programs 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 capabilities | Compile-time checks let code do only what it has been allowed to do. |
| Defined arithmetic and indexing | An overflow or an out-of-range access is reported, never silently ignored. |
| Predictable memory | Fixed-capacity collections, an explicit result when something is full, and no mandatory heap on small devices. |
| Building blocks | Agents, subagents, nodes, edges, configuration, hooks and skills are first-class, each in its own named file. |
| Snapshot configuration | Typed, reusable configuration is locked into a snapshot for each run, so settings cannot change under a running agent. |
| Hooks | Authorization, auditing or cleanup before or after any component, function or statement, in ordered or parallel groups. A failed authorization fails closed. |
| Isolated components | An 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 languages | Private 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.
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
In one process
A direct, typed call between two components
Between processes
The same typed channel across a process boundary
Over the network
The built-in gRPC-compatible transport, with TLS
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.
| Command | What it does |
|---|---|
oel init | Creates a ready-to-build project. |
oel check | Runs the type, ownership and permission checks, with diagnostics that point at your source. |
oel fmt | Formats source files the same way every time. |
oel build | Builds a native executable, with debug information for standard native debuggers. |
oel run | Builds and runs a program on this machine, and reports time and token usage. |
oel test | Runs the tests a project declares, with line and function coverage of your code. |
oel refmap | Shows what references what, and lists unused code, for a project, a folder or one file. |
oel package | Builds a library into one package file. |
Resources
More on the Compiler
Compiler overview
What the Compiler is, how you write, check, build and run a program, and where programs run.
Agents
Agents, nodes and edges as typed source files, with teams, subagents and built-in guardrails.
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 which of these areas matter to you, and the platform you build on.