AEL Docs
Follow updates
Menu
Follow updates
Browse the documentation

AEL 1.0.0

Agents

In AEL, the Agent Engineering Language, an agent is ordinary typed code: a workflow of nodes and edges, each in its own named file, with its system prompt, model binding, tools, limits and checks written beside it. This guide describes the agents you build with AEL 1.0.0, one subject per page.

The pages

  • Agents, nodes and edges

    The three building blocks, definitions and instances, runs, and model-driven or deterministic decisions.

  • System prompts

    Prompt sources, ordered fallback, running on input alone and the prompt each run keeps.

  • Models and providers

    Model bindings, the built-in client for OpenAI-compatible APIs, local and cloud models, and model policies.

  • Tools and MCP

    Typed tools and their permissions, the tool loop, MCP tools, services and your own connectors.

  • Typed inputs and outputs

    Inputs, input builders, output checks, raw or typed results, several inputs, media and streams.

  • Workflows

    Starting points and completion, edge modes, delivery, callbacks, fan-out, feedback and triggers.

  • Communication between agents

    Every edge as a typed two-way channel, in one process, between processes or over the network, and services built elsewhere that call your agents.

  • Budgets, retries and validation

    The shared budget, attempts and repairs, which failures are retried, output checks and resource limits.

  • Teams of agents

    Supervisors, pipelines, routers, peers, quorum, handoff, typed delegation and remote agents over A2A.

  • Subagents

    Spawning at run time: the subagent file, spawn and join, handles, refusals and failures, lifecycle, budgets and limits.

  • Isolated components

    The isolated modifier: a sandbox in its own process, reached only through declared edges, with its own bindings.

  • Durable runs and approval

    The life of a run, pausing and resuming from a storage point, human approval, restarts and side effects.

  • Bindings and storage

    The bindings record of memory, skills, knowledge, storage and databases, the storage point that makes a run durable, and database bindings.

  • Memory and state

    Run state and long-term memory, scopes, retention and deletion, shared memory and retrieval (RAG).

  • Skills

    The skill file, what a skill bundles, packaging and loading skills, and what the check refuses.

  • Evaluations and prompt releases

    Evaluation suites, recorded-model regression tests, drift checks, promotion and rollback.

  • Reporting, logs and replay

    Time and token reports, structured logs, and recording and replaying runs.

What agents give you

  • Agents as code. 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.
  • Prompts as business policy. You 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.
  • Models where you choose. A built-in client for OpenAI-compatible APIs comes with the language, for local model servers, major cloud providers and inference endpoints you run yourself.
  • Model policies. One call, a bounded loop, routing, ordered fallback, parallel fan-out or an independent verifier model.
  • Mixed decisions. One workflow mixes model-driven and deterministic decisions, and routes sensor readings or events without paying for a model call.
  • Typed inputs and outputs. Your own input builders and output checks, a choice of raw or typed results, and text, structured data, images, audio, files and video frames.
  • Tools and MCP. A built-in MCP client discovers and calls MCP tools, and an optional package exposes your agents as MCP tools.
  • One shared budget. Retries, output repair, timeouts and cancellation draw on one budget, and token, time, CPU, memory and concurrency budgets apply across every child agent.
  • Teams of agents. Supervisor, pipeline, fan-out and join, router, peers, quorum, handoff and typed delegation, and delegation to remote agents over A2A.
  • Subagents. 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.
  • Two-way edges. 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.
  • Isolated components. 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.
  • Declared resources. 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.
  • Durable runs. Runs pause, wait for human approval and reconcile side effects safely, and a run whose agent declares a storage point resumes and survives restarts. 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.
  • Scoped memory. State and long-term memory are scoped per tenant, agent, session or subject, with retention and deletion rules.
  • Skills. 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.
  • Releasable prompts. Evaluations, recorded-model regression tests, drift checks, and promotion with one-step rollback, while active runs stay pinned to their version.
  • Reports and logs. Time and token usage is reported by default, structured logs go where you choose, and you record runs and replay them.
  • A first agent: a console agent from start to finish.
  • Language guide: files and roles, configuration, hooks, concurrency and capabilities.
  • Packages: the HTTP and MCP server packages, and model provider packages.
  • Agent inputs and outputs: the JSON Schemas of agent components, prompts, model requests and runs.