Early preview
Build AI agents as native software
The OpenEng Compiler builds programs written in the Open Engineering Language, a programming language for building AI agents as reliable, native software, into self-contained native executables.
Linux is the first platform of the early preview. No public build is published.
# 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;
}
}What it is
A compiled language where the agent is the program
You write agents, their prompts, tools, workflows and configuration as typed code in the Open Engineering Language. The Compiler checks that code and builds it into a self-contained native program. The Compiler’s command-line tool is oel.
Type, ownership and permission mistakes are reported before anything runs. There is no interpreter or virtual machine to ship, and nothing is compiled or downloaded when a program starts.
- Agents, subagents, nodes, edges, hooks and configuration are first-class building blocks
- Each building block has its own named file, so a project’s structure reads at a glance
- Optional packages add only what an application selects
A project, file by filesource
main.oelProgram entrypack.oelPackage manifest of the project*.agent.oelAn agent: typed input, typed output*.subagent.oelA short-lived agent, spawned at run time*.node.oelA node: one business step*.edge.oelAn edge: a typed two-way connection*.config.oelTyped configuration, locked for each run
How it works
Write, check, build, run
One command-line tool takes a project from source files to a native executable.
Write
Agents, nodes, edges and configuration are source files with typed inputs and outputs.
Check
oel checkreports type, ownership and permission mistakes and points at your source.Build
oel buildproduces a self-contained native executable, with no interpreter inside.Run
oel runbuilds and runs the program on your machine and reports time and token usage.
$ oel check examples/fibonacci.oel
$ oel build examples/fibonacci.oel -o fibonacci
$ oel run examples/fibonacci.oelThe three commands on a small example program, as they run on Linux in the early preview.
Capabilities
What the language is designed to guarantee
Each property belongs to the language or to the executable it builds. None is a convention you have to remember.
Typed and checked
Static types, ownership and definite initialization. Mistakes surface when you check a program, before anything runs.
Native executables
Programs compile straight to self-contained executables. Desktop and server programs written in the language alone need nothing else installed.
Permissions in the program
Compile-time effect and capability checks let code do only what it has been allowed to do.
Defined behavior
An overflow or an out-of-range access is reported, never silently ignored. Wrapping and saturating arithmetic are explicit.
Predictable memory
Fixed-capacity collections, an explicit result when something is full, and no mandatory heap on small devices.
Clear sharing rules
Helpers stay private to their owner, shared functions are visible by folder, and reuse is imported explicitly.
Functions in other languages
An application can hold private functions written in other languages, with typed signatures, built with your own toolchains.
One command-line tool
Create, check, format, build, run and test a project with
oel, with diagnostics that point at your source.
Agents
Agents are typed code, not configuration files
A node takes a typed input and returns a typed output. Its prompt, its model binding and its retry limit sit in the same file as its logic.
- Supervisors, pipelines, routers and teams are built-in patterns
- Retries, output repair, timeouts and cancellation draw on one shared budget
- Hooks for authorization and auditing fail closed
- A subagent holds only the permissions its parent grants
# 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.
}Packages
A lean core, and packages you select
Servers, model providers, storage, robotics and scientific computing are designed as optional packages. Only what you use ships.
A signed official registry
Only OpenEng Labs publishes to the registry at pack.openeng.ai. Every version is signed, and a published version never changes.
Written in the language
Every package ships in compiled, verified form, with no bundled native code and no install scripts.
Private packages you host
oel packagebuilds your library into one file. You host it, and your project records its address and fingerprint.
Early preview
No official package is published yet. The registry lists a package only once it is published.
Platforms
One language, from servers to microcontrollers
The Compiler is designed to build for Linux, macOS, Windows, containers and microcontroller boards. The early preview starts with Linux.
| Target | What you build | In the early preview |
|---|---|---|
| Linux | Static executables for servers and desktops that need nothing else installed | Qualified |
| Containers | Minimal images around a static Linux executable, with nothing to compile or download at startup | Qualified on Linux |
| macOS | Native executables | Being qualified |
| Windows | Native executables | Being qualified |
| Microcontroller boards | Firmware that needs no heap and no operating system in the smallest profile | Being qualified |
A feature that a target cannot support fails when you build, not on the device. Running a component in a sandbox uses the isolation facilities of Linux and is refused on every other target.
Resources
More on the Compiler
Features
The designed scope by area: language, agents, models, services, tooling, deployment and devices.
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.
Early preview — message us for access
Tell us the platform you build on and what you want to build.