A11¶

A11 connects model calls, application tools, storage, and user interfaces through actions and streams. The open-source runtime supports Python, TypeScript, and C++.

An agent can use the included model actions, expose application functions as tools, keep conversation state in ordinary application data, and compose work at runtime with Flow. The same action can run beside the agent, on a GPU host, or in the browser that owns the state it needs to change.

The runtime also serves GPU models, streams speech-recognition captions, feeds decoded records into indexing pipelines, and reports diffusion progress before returning an image. These systems use the same typed operations and streams without an agent loop.

If A11 is new to you, start with an action: an asynchronous operation whose inputs and outputs have names. Each input and output is a node, an ordered stream that may carry one value or many. This lets a caller display text, process records, or report progress while the action is still running.

An action keeps the same contract when it becomes an LLM tool or moves to another process. Storage and transport are separate choices, and Flow is available when several actions need a reusable or runtime-defined composition. Applications can begin with local calls and add these pieces as their deployment and reliability needs grow.

Try the live research agent Install A11 Star the project Join a discussion

Choose what you want to build¶

The examples page groups the remaining guides by task, including persistent chat, browser-hosted tools, parallel research, local models, and distributed streams.

Research-agent composition¶

The deep-research agent exposes one deep-research action to a browser. Its Python handler asks a model to plan the topic, starts several investigations with an asyncio concurrency limit, and keeps their reports local. A final model action synthesizes those findings while its report streams to the caller.

The browser receives the plan, action log, and final report. Larger intermediate reports remain on the backend. The implementation uses ordinary Python control flow for bounded parallel work and streams progress through action ports.

A stream in one minute¶

An AsyncNode is an ordered stream. A producer writes values and finalizes the stream; a reader can process each value as it arrives.

import asyncio
import a11


async def main() -> None:
    node = a11.AsyncNode.create("greeting")

    await node.put("hello")
    await node.finalize("world")

    async for value in node:
        print(value)


asyncio.run(main())

Action inputs and outputs use these same streams. A handler can therefore emit progress or partial output before it has finished, and its caller can begin processing that output immediately.

Core interfaces¶

An action is a named operation with described inputs and outputs.
Each input or output is a node, so a single value and a live stream use the same interface.
A session carries action calls and node data between peers. Local handlers use the same action contract as remote handlers.
A store controls how long node data remains available. A transport carries that data between peers.
A registry makes actions discoverable and supplies their handlers. A per-turn allow-list controls which registered actions a model may call.
A flow connects actions when a composition should be checked, shared, or supplied at runtime. It resolves against the actions available to its host; ordinary action calls remain sufficient elsewhere.

The same primitives cover common agent application needs:

They also cover APIs and pipelines that contain no agent:

Understand the design¶

A11 design explains the streaming model, local and remote execution, storage choices, and lifecycle boundaries. The lifecycle articles then show exactly when a node, action, session, or connection is complete.

API references¶

If an example is unclear or fails in your environment, report the friction. If A11 is part of a project, share the integration. Public documentation analytics are described in Analytics and privacy.