Features — AEL documentation

This page lists the features of AEL, the Agent Engineering Language, in AEL 1.0.0. Each area ends with a link to the guide that describes it in full.

The language

AEL is statically typed and compiled, so type, ownership and permission mistakes are caught before anything runs.
Programs compile straight to self-contained native executables, with no interpreter or virtual machine to run and no second language to install unless you write functions in one.
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.
Your application can hold private functions written in other languages, with typed AEL signatures, built and run with your own toolchains, pinned by version. Functions in other languages describes them.
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. Isolated components describes them.
Helpers stay private to their component, shared functions are visible by folder, and reusable functions are imported explicitly.
Hooks attach authorization, auditing or cleanup before or after any component, function or statement, and fail closed when authorization fails.
Configuration is locked into a snapshot for each run, and compile-time capability checks let code do only what it has been allowed to do.
Memory use is predictable, with fixed-capacity collections and no mandatory heap on small devices, and an overflow or out-of-range access is reported, never silently ignored.

Agents, models and knowledge

You write an agent's business policy as a system prompt, or run it on its input alone.
One workflow mixes model-driven and deterministic decisions, and routes sensor readings or events without paying for a model call.
Agents take typed inputs and return typed outputs, with your own input builders and output checks.
Supervisor, pipeline, fan-out and join, router, peers, quorum, handoff and typed delegation patterns are built in.
Retries, output repair, timeouts and cancellation draw on one shared budget, and token, time, CPU, memory and concurrency budgets apply across every child agent.
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. Subagents describes them.
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.
Runs pause, wait for human approval and reconcile side effects safely, and a run whose agent declares a storage point resumes and survives restarts. Memory is scoped per tenant, agent, session or subject.
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.
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. AEL itself contains no database: the memory, knowledge and durable state of your runs live in the storage, database and vector-store packages you select. Bindings and storage describes them.
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. Skills describes them.
A built-in client for OpenAI-compatible APIs comes with the language, with model policies from exactly one call to an independent verifier model.
You choose local model servers, optional packages for major cloud providers, or inference endpoints you run yourself.
A built-in MCP client calls MCP tools, and agents delegate long-running work to remote agents over A2A.
Retrieval (RAG) covers the whole lifecycle of your own documents, from ingesting to retrieving with ranking and provenance.
Agents take and produce text, structured data, images, audio, files and video frames, and process live camera or sensor streams.
Prompts are releasable business logic, with evaluations, regression tests and promotion with one-step rollback.

Services and connections

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.
Optional HTTP, gRPC, WebSocket and socket servers send each reply to the authenticated caller that asked for it.
Event, polling and scheduled triggers have overlap, missed-run and time-zone policies, and survive restarts when their agent declares a storage point.
Every edge is a typed, two-way channel: AEL 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 AEL's built-in gRPC-compatible transport with TLS.
Services built elsewhere call your agents over gRPC, because each network edge publishes its interface in gRPC's standard interface-definition format. Communication between agents describes edges as channels.
Code calls a typed service, and the deployment decides whether it runs in the same process, on another machine, over HTTPS or over gRPC, with retries, backpressure, circuit breakers and health checks.
Optional packages connect agents to streams, caches and message brokers.
You call your existing Python, JavaScript, Java or .NET programs and shell commands as typed tools, with runtimes you provide, and write your own connectors.

Packages

Only OpenEng publishes to the official registry at pack.ael.openeng.ai; every version is signed, and a published version never changes.
You build your own libraries into shareable packages that ship compiled, without your source, and host them yourself.
One manifest and one lock file give reproducible builds that also work offline, and each folder of a project can add its own packages.
You select exactly the exports you use, and only what you use ships: an HTTP-only app carries no WebSocket code, and no gRPC code unless an edge is placed on the network.
Optional storage packages keep data in files on a local or mounted path or in object storage, and connect to SQL databases you run; each can be an agent's storage point.
Optional vector-store packages index and search your knowledge for retrieval, in a database you run.
Every package, from OpenEng or from you, is written in AEL and ships as compiled, verified AEL, with no bundled native code and no install scripts.

Tooling

One command-line tool creates, checks, formats, builds, runs and debugs projects, with diagnostics that point at your source.
A reference map shows what references what, and lists unused code and packages.
The command line finds references, renames safely and generates API documentation.
You debug at source level in standard native debuggers, and record control and orchestration runs and replay them to find where behaviour diverged.
The AEL 1.0.0 build for Linux, macOS or Windows comes with target management and a health check.
Changes to the language or project format come with explicit, reviewable migrations.

Deployment and operations

Programs build into standalone native binaries, including static Linux binaries, and minimal container images start with nothing to compile, install or download at startup.
A multi-core, nonblocking runtime needs no thread per user.
A trusted tenant identity flows through every call, store, log and reply.
Per-agent CPU and memory limits state whether each limit is hard-enforced or accounted.
Time and token usage is reported by default on every channel, and structured logs go to the console, a file, or custom or remote sinks.
You host your built application on servers you operate, with health checks for the storage, databases and models it declares, graceful shutdown and log rotation. Self-hosting your application describes it.

Devices

One language reaches from servers down to microcontrollers, and a feature a target cannot support fails at compile time, not on the device.
The smallest profile needs no heap and no operating system; small networked boards get an optional heap, storage, networking and TLS.
Runtimes come in sizes for each class of device, from servers down to coin-cell-class microcontrollers, and a program that does not fit its device's class is refused when you build it.
Concurrency on microcontrollers uses bounded mailboxes, timers, cooperative scheduling, supervision and restarts.
Hardware access covers GPIO, clocks, UART, interrupts and defined panic behaviour, and firmware images come with RAM, flash and stack reports.
You flash and monitor supported boards from the command line, using each board's standard flashing tools.
Prompt-driven agents run on small devices through AEL Gateway, and each device keeps its safe local behaviour when offline.

Robotics, science and quantum computing

Optional robotics packages provide typed units, coordinate frames and sensor and actuator schemas, and connect robot agents over ROS 2 and DDS.
The same code runs against virtual hardware, a simulator or a real robot, and safety stays deterministic: AI proposes, validators check freshness and limits, and the watchdog and emergency stop stay in charge.
Optional packages cover kinematics, dynamics, trajectories, optimal control, localization, mapping, navigation and vision.
Optional device packages, written in AEL, drive common robotics components: motor drivers, servos, inertial sensors, encoders and range sensors.
Optional packages provide numerical arrays, linear algebra, optimization, signal processing and automatic differentiation.
Quantum circuits are typed, simulators state their cost and precision limits, and circuits export to OpenQASM and QIR.

Platforms and trust

You build for Linux, macOS, Windows, containers and microcontroller boards from one language. Platforms and deployment lists the exact targets.
AEL 1.0.0 is the full distribution; smaller distributions of the same version leave out components, such as support for other languages or for agents, and refuse a feature they leave out by naming it. Distributions describes them.
The AEL toolchain is self-contained: one install takes your AEL code all the way to a native program.
The AEL 1.0.0 release is signed and reproducible, with a software bill of materials, and each build records exactly what went into it.