AEL
Follow updates
Menu
Follow updates

AEL Beta 0.0.1 — launching soon

Agents

You will write agents, their prompts, tools and typed inputs and outputs as ordinary code, so mistakes surface before anything runs.

What you will build

With Beta 0.0.1 you will be able to build software-engineering agents, agents that serve HTTP or MCP clients, agents on devices and microcontrollers, and robot agents.

  • Software-engineering agents

  • Agents that serve HTTP or MCP clients

  • Agents on devices and microcontrollers

  • Robot agents

Agents as code

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.

  • 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.
  • 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.
  • 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.
Preview syntax — may change before launch
# nodes/summarize.node.ael
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.
}
Preview syntax — may change before launch
# agents/support.agent.ael
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;
    }
}

Workflows and teams of agents

You will compose supervisors, pipelines, routers and teams of agents that share one budget, wait for human approval when needed and resume after a restart.

  • One workflow will mix model-driven and deterministic decisions, and route sensor readings or events without paying for a model call.
  • Hierarchical and multi-agent patterns will be built in: supervisor, pipeline, fan-out and join, router, peers, quorum, handoff and typed delegation.
  • Agents will discover remote agents and delegate long-running work to them over A2A.
  • Runs will be durable: they will pause, resume, wait for human approval, survive restarts and reconcile side effects safely.

Guardrails built in

  • One shared budget

    Retries, output repair, timeouts and cancellation will draw on one shared budget, so nested retries cannot multiply cost.

  • Budgets across every child agent

    Token, time, CPU, memory and concurrency budgets will apply across every child agent.

  • Scoped state and memory

    State and long-term memory will be scoped per tenant, agent, session or subject, with retention and deletion rules.

  • Multi-tenant from the start

    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.

Models, tools and testing

  • MCP tools

    A built-in MCP client will discover and call MCP tools, and an optional package will expose your agents as MCP tools.

  • Prompts as releasable business logic

    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.

  • Record and replay

    You will record control and orchestration runs and replay them to find the first point where behaviour diverged.

All model and knowledge features

Services, devices and robots

  • REST APIs

    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.

  • Small devices

    Prompt-driven agents will run on small devices through a gateway, and each device will keep its safe local behaviour when offline.

  • Hierarchical robot agents

    Hierarchical robot agents (for example eyes, face, body and a coordinator) will come with ready-made recipes.

  • Hybrid agent workflows

    Hybrid agent workflows will let an agent propose a circuit, validate it, simulate it, optionally run it on hardware and check the result.

Examples

Complete example agent systems and deployment recipes will be published with the beta.

Preview the documentation Everything in Beta 0.0.1 What launching soon means