Features

The language

• AEL will be statically typed and compiled, so type, ownership and permission mistakes will be caught before anything runs.
• Programs will compile straight to self-contained native executables, with no interpreter or virtual machine to run and no second language to install.
• Agents, nodes, edges, configuration and hooks will be building blocks, each in its own named file, so a project's structure will read at a glance.
• Helpers will stay private to their component, shared functions will be visible by folder, and reusable functions will be imported explicitly.
• Hooks will attach authorization, auditing or cleanup before or after any component, function or statement, and will fail closed when authorization fails.
• Configuration will be locked into a snapshot for each run, and compile-time capability checks will let code do only what it has been allowed to do.
• Memory use will be predictable, with fixed-capacity collections and no mandatory heap on small devices, and an overflow or out-of-range access will be reported, never silently ignored.

More in the Language guide.

Agents, models and knowledge

• You will write an agent's business policy as a system prompt, or run it on its input alone.
• One workflow will mix model-driven and deterministic decisions, and route sensor readings or events without paying for a model call.
• Agents will 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 will be built in.
• Retries, output repair, timeouts and cancellation will draw on one shared budget, and token, time, CPU, memory and concurrency budgets will apply across every child agent.
• Runs will pause, resume, wait for human approval and survive restarts, and memory will be scoped per tenant, agent, session or subject.
• A built-in client for OpenAI-compatible APIs will come with the language, with model policies from exactly one call to an independent verifier model.
• You will choose local model servers, optional packages for major cloud providers, or inference endpoints you run yourself.
• A built-in MCP client will call MCP tools, and agents will delegate long-running work to remote agents over A2A.
• Retrieval (RAG) will cover the whole lifecycle of your own documents, from ingesting to retrieving with ranking and provenance.
• Agents will take and produce text, structured data, images, audio, files and video frames, and process live camera or sensor streams.
• Prompts will be releasable business logic, with evaluations, regression tests and promotion with one-step rollback.

More in Agents.

Services and connections

• A console agent will need 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 will send each reply to the authenticated caller that asked for it.
• Event, polling and scheduled triggers will have overlap, missed-run and time-zone policies, and will survive restarts.
• Code will call a typed service, and the deployment will decide 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 will connect agents to streams, caches and message brokers.
• You will call your existing Python, JavaScript, Java or .NET programs and shell commands as typed tools, with runtimes you provide, and write your own connectors.

More in Agents and Packages.

Packages

• Only OpenEng will publish to the official registry at pack.ael.openeng.ai; every version will be signed, and a published version will never change.
• You will build your own libraries into shareable packages that ship compiled, without your source, and host them yourself.
• One manifest and one lock file will give reproducible builds that also work offline, and each folder of a project will be able to add its own packages.
• You will select exactly the exports you use, and only what you use will ship: an HTTP-only app will carry no gRPC or WebSocket code.
• Every package, from OpenEng or from you, will be written in AEL and ship as compiled, verified AEL, with no bundled native code and no install scripts.

More in Packages.

Tooling

• One command-line tool will create, check, format, build, run and debug projects, with diagnostics that point at your source.
• A reference map will show what references what, and list unused code and packages.
• The command line will find references, rename safely and generate API documentation.
• You will debug at source level in standard native debuggers, and record control and orchestration runs and replay them to find where behaviour diverged.
• Installers for Linux, macOS and Windows will come with target management and a health check.
• Changes to the language or project format will come with explicit, reviewable migrations.

More in the Command-line reference.

Deployment and operations

• Programs will build into standalone native binaries, including static Linux binaries, and minimal container images will start with nothing to compile, install or download at startup.
• A multi-core, nonblocking runtime will need no thread per user.
• A trusted tenant identity will flow through every call, store, log and reply.
• Per-agent CPU and memory limits will state whether each limit is hard-enforced or accounted.
• Time and token usage will be reported by default on every channel, and structured logs will go to the console, a file, or custom or remote sinks.
• An optional self-hosted build and run server will add backups, staged deployments and rollback.

More in Platforms and deployment.

Devices

• One language will reach from servers down to microcontrollers, and a feature a target cannot support will fail at compile time, not on the device.
• The smallest profile will need no heap and no operating system; small networked boards will get an optional heap, storage, networking and TLS.
• Concurrency on microcontrollers will use bounded mailboxes, timers, cooperative scheduling, supervision and restarts.
• Hardware access will cover GPIO, clocks, UART, interrupts and defined panic behaviour, and firmware images will come with RAM, flash and stack reports.
• You will flash and monitor supported boards from the command line, using each board's standard flashing tools.
• Prompt-driven agents will run on small devices through a gateway, and each device will keep its safe local behaviour when offline.

More in Platforms and deployment.

Robotics, science and quantum computing

• Optional robotics packages will provide typed units, coordinate frames and sensor and actuator schemas, and connect robot agents over ROS 2 and DDS.
• The same code will run against virtual hardware, a simulator or a real robot, and safety will stay deterministic: AI will propose, validators will check freshness and limits, and the watchdog and emergency stop will stay in charge.
• Optional packages will cover kinematics, dynamics, trajectories, optimal control, localization, mapping, navigation and vision.
• Optional packages will provide numerical arrays, linear algebra, optimization, signal processing and automatic differentiation.
• Quantum circuits will be typed, simulators will state their cost and precision limits, and circuits will export to OpenQASM and QIR.

More in Use cases.

Platforms, AEL Cloud and trust

• You will build for Linux, macOS, Windows, containers and microcontroller boards from one language. Platforms and deployment lists the exact targets.
• AEL Cloud, a service hosted by OpenEng, is coming with the beta at cloud.ael.openeng.ai. There you will build and run agents in the cloud with your own account. Details will be announced at launch.
• The AEL toolchain will be self-contained: one install will take your code all the way to a native program.
• Beta releases will be signed and reproducible, with a software bill of materials, and each build will record exactly what went into it.