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.

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;
    }
}

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 entry
  • pack.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
Each role has its own file name, so the kind of every file is visible before you open it.

How it works

Write, check, build, run

One command-line tool takes a project from source files to a native executable.

  1. Write

    Agents, nodes, edges and configuration are source files with typed inputs and outputs.

  2. Check

    oel check reports type, ownership and permission mistakes and points at your source.

  3. Build

    oel build produces a self-contained native executable, with no interpreter inside.

  4. Run

    oel run builds and runs the program on your machine and reports time and token usage.

terminal
$ oel check examples/fibonacci.oel
$ oel build examples/fibonacci.oel -o fibonacci
$ oel run examples/fibonacci.oel

The 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.

All features, by area

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

Agents as typed code

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.
}

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 package builds 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.

How packages workThe package registry

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.

TargetWhat you buildIn the early preview
LinuxStatic executables for servers and desktops that need nothing else installedQualified
ContainersMinimal images around a static Linux executable, with nothing to compile or download at startupQualified on Linux
macOSNative executablesBeing qualified
WindowsNative executablesBeing qualified
Microcontroller boardsFirmware that needs no heap and no operating system in the smallest profileBeing 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

Early preview — message us for access

Tell us the platform you build on and what you want to build.