AEL
Follow updates
Menu
Follow updates

AEL Beta 0.0.1 — launching soon

Features

Beta 0.0.1 will include a typed, compiled language for agents, with one command-line tool to create, check, format, build, run and debug projects.

Language

Agents as code
  • Programs will build into self-contained native executables, with type, memory and permission checks built in and nothing else to install for desktop and server programs.
  • AEL will be a statically typed, compiled language built for agent engineering, 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 (business steps), edges (typed connections), configuration and hooks will be first-class building blocks, each in its own named file, so a project's structure will read at a glance.
Show all 10Show fewer
  • Sharing will follow clear rules: helpers will stay private to their owner, shared functions will be visible by folder, and reusable functions will be imported explicitly.
  • Typed, reusable configuration will be locked into a snapshot for each run, so settings cannot change underneath a running agent.
  • Hooks will attach authorization, auditing or cleanup before or after any component, function or statement, run in ordered or parallel groups, and fail closed when authorization fails.
  • Compile-time effect and capability checks will let code do only what it has been allowed to do.
  • Memory use will be predictable: fixed-capacity collections, an explicit result when something is full, and no mandatory heap on small devices.
  • Arithmetic and indexing will have defined results: an overflow or an out-of-range access will be reported, never silently ignored.

Agents and workflows

More about agents
  • You will write an agent's business policy as a system prompt (inline, from a file, from the environment or from configuration), or run it on its input alone with no system prompt.
  • 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 and a choice of raw or typed results.
  • Retries, output repair, timeouts and cancellation will draw on one shared budget, so nested retries cannot multiply cost.
Show all 8Show fewer
  • Hierarchical and multi-agent patterns will be built in: supervisor, pipeline, fan-out and join, router, peers, quorum, handoff and typed delegation.
  • Runs will be durable: they will pause, resume, wait for human approval, survive restarts and reconcile side effects safely.
  • State and long-term memory will be scoped per tenant, agent, session or subject, with retention and deletion rules.
  • Token, time, CPU, memory and concurrency budgets will apply across every child agent.

Models and knowledge

Models, tools and testing
  • A built-in client for OpenAI-compatible APIs, including realtime sessions, will come with the language, with explicit or default parameters and no server or SDK to add.
  • Model policies will cover exactly one call, a bounded loop, routing, ordered fallback, parallel fan-out and an independent verifier model.
  • You will choose local or cloud models: local model servers, optional packages for major cloud providers, and clients for inference endpoints you run yourself.
  • A built-in MCP client will discover and call MCP tools, and an optional package will expose your agents as MCP tools.
Show all 8Show fewer
  • Agents will discover remote agents and delegate long-running work to them over A2A.
  • Retrieval (RAG) will cover the whole lifecycle (ingest, chunk, embed, index, update and delete, then retrieve with ranking and provenance), and you will be able to bring your own knowledge connectors.
  • Agents will take and produce text, structured data, images, audio, files and video frames, and process live camera or sensor streams with bounded buffers and backpressure.
  • Prompts will be treated as releasable business logic, with evaluations, recorded-model regression tests, drift checks, and promotion with one-step rollback, while active runs stay pinned to their version.

Services and connections

About packages
  • 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.
Show all 9Show fewer
  • Connections will be resilient, with idempotency-aware 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, shell commands and operating-system operations as typed tools, with runtimes you provide, locally or on a remote worker.
  • You will write your own connectors for services, models, knowledge sources, transports and log sinks.
  • Only what you use will ship: an HTTP-only app will carry no gRPC or WebSocket code, and a GET-only API no POST handlers.

Tooling

What Beta 0.0.1 will include
  • One command will create a ready-to-build project.
  • One command-line tool will check, format, compile, build and run your code, with diagnostics that point at your source.
  • A reference map will show what references what, and list unused code and packages, for a whole project, a folder or one file.
  • The command line will find references, rename safely and generate API documentation.
Show all 8Show fewer
  • You will debug at source level in standard native debuggers.
  • Installers for Linux, macOS and Windows will come with target management and a health check, and desktop and server programs will need nothing else installed.
  • Changes to the language or project format will come with explicit, reviewable migrations.
  • You will record control and orchestration runs and replay them to find the first point where behaviour diverged.

Platforms and deployment

Which platforms will it build for?
  • You will build for Linux, macOS, Windows, containers and microcontroller boards from one language.
  • Programs will run on servers, containers and devices, with nothing to compile or download at startup.
  • Programs will build into standalone native binaries, including static Linux binaries.
  • Minimal container images will start with nothing to compile, install or download at startup.
Show all 10Show fewer
  • A multi-core, nonblocking runtime will need no thread per user, and programs that don't need worker threads won't get them.
  • Agents will be multi-tenant from the start: a trusted tenant identity will flow through every call, store, log and reply, with fair scheduling and predictable behaviour under overload.
  • 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 (command line, HTTP, gRPC, WebSocket and sockets), and you will be able to turn off each field without disabling the limits behind it.
  • Structured logs will go to the console, a file, or custom or remote sinks, with redaction, rotation and retention.
  • An optional self-hosted build and run server will add backups, staged deployments and rollback.

Devices

Services, devices and robots
  • 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.
  • Concurrency on microcontrollers will be safe, with bounded mailboxes, timers, cooperative scheduling, supervision and restarts.
  • Hardware access will cover GPIO, clocks, UART, interrupts and defined panic behaviour.
Show all 8Show fewer
  • 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.
  • An optional heap, storage, networking and TLS will be available on small networked boards.

Robotics, science and quantum

Optional packages for robotics, scientific computing and quantum computing will include ROS 2 support and quantum circuits that export to OpenQASM and QIR.

Package families

Robotics

  • Optional robotics packages will provide typed units, coordinate frames, timestamps and sensor and actuator schemas.
  • The same code will run against virtual hardware, a simulator or a real robot.
  • Robot agents will connect over ROS 2 and DDS, including the DDS-XRCE standard for constrained hardware.
  • Safety will stay deterministic: AI will propose, validators will check freshness and limits, and the watchdog and emergency stop will stay in charge.
Show all 6Show fewer
  • Optional packages will cover kinematics, dynamics, trajectories, optimal control, localization, mapping, navigation and vision.
  • Hierarchical robot agents (for example eyes, face, body and a coordinator) will come with ready-made recipes.

Scientific and quantum computing

  • Optional packages will provide numerical arrays, complex numbers and linear algebra.
  • Optional packages will provide optimization, signal processing, integration and automatic differentiation.
  • Quantum circuits will be typed, with standard and custom gates.
  • Quantum simulators (statevector, density-matrix, stabilizer and tensor-network) will state their cost and precision limits.
Show all 8Show fewer
  • Circuits will export to OpenQASM and QIR, with circuit lowering and routing.
  • Quantum jobs will run asynchronously on quantum hardware providers, with budgets, cancellation and tenant-scoped credentials.
  • Optional packages will cover quantum algorithms, error mitigation and correction, quantum machine learning and quantum chemistry.
  • Hybrid agent workflows will let an agent propose a circuit, validate it, simulate it, optionally run it on hardware and check the result.

Trust

What launching soon means Questions and answers
  • 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.
  • Each build will record exactly what went into it, so you can check what a program contains.

Follow the launch

Follow updates See what's in the beta