Show HN: A11 – typed streams and reusable actions for agentic applications

request DeepResearchRequesttopic stringparallelism integer A11 is an open-source toolkit that turns ordinary async functions into actions: reusable capabilities with named inputs and outputs that can stream. Run the same action locally, across services or browsers, or let an AI model call it as a tool.

plan-research… investigate / architecture``investigate / lifecycles Nested calls keep their own timing and structured status.

plan application/json0 values Waiting for output…

report text/markdown0 chunks · streamusage_metadata application/json0 chunks · stream Describe an action’s inputs and outputs once, then use the same thin, data-driven streaming interface for local models, APIs, agent tools, web agents, native code, and distributed or high-load services. If you have its schema, you can call it.

A voice-enabled desktop app runs capture and recognition on the user’s machine. Words become text input as the person speaks, while microphone access and the speech model stay local.

capture_transcription

action = capture_transcription().run()
await action["asr_options"].finalize({
    "model": "ggml-base.en.bin"
})

async for text in action["transcription_pieces"]:
    composer.insert(text)
options = await action["asr_options"].consume()
microphone = open_microphone()

async for text in recognize(microphone, options):
    await action["transcription_pieces"].put(text)

A11 is an open-source runtime and RPC toolkit for defining application operations as typed actions with independently streamed inputs and outputs. AI frameworks such as LangGraph organize stateful workflows, agent harnesses such as Hermes provide a ready-made model-and-tool loop, MCP connects AI applications to tools and context, and gRPC defines remote service calls. A11 provides orchestration, discovery, persistence, and the same action interface for local or remote execution, without requiring a graph or agent runtime; it can also integrate with each of these other layers.

This compares their primary public abstractions, not every integration or extension. A11 can use gRPC infrastructure, expose operations through MCP, supply capabilities to LangGraph, or act as an execution layer for a harness such as Hermes. Green marks comparable support; yellow marks partial coverage. Hover over dotted values for context.

Start by describing an async handler and its inputs and outputs. Add streaming, model calls, tool use, persistence, remote execution, or Flow when the application requires them. The linked guides show each capability in isolation and how the same action interface carries through Python, TypeScript, and C++.

Actions

Give a handler named inputs and outputs, then run it in the current process or register it for remote calls. Existing loops, branches, and concurrent tasks remain ordinary application code.

Local-to-remote guide LLM integration

Send conversation turns, read model text as it arrives, retain updated interactions, and derive model tools from existing action schemas.

LLM interaction guide Streaming

Use separate ordered streams for tokens, audio frames, records, progress, and final results. Several inputs and outputs can remain active during one call.

Streaming guide Media types

Declare text, JSON, audio, images, and binary values independently so callers know how to decode and present each result.

Generative media guide Lifecycles

Observe when every output is complete, propagate structured errors, set deadlines, and cancel work across nested or remote calls.

Action lifecycle guide Remote calls

Keep the same inputs and outputs when moving a handler to a service, GPU host, browser, or another connected process.

Remote action guide Storage

Keep temporary streams in memory, retain local data with SQLite, share streams through Redis, or provide another storage implementation.

Storage API and examples memory → sqlite → redis

Flow

Use Flow when a composition is supplied at runtime or needs validation before execution. Keep fixed application logic in ordinary code.

Flow language guide Flow is A11’s declarative language for connecting existing actions while an application is running. A person or an AI model can supply a plan as data; A11 checks its syntax, types, inputs, outputs, and permissions before any work starts.

flow research {
  in  question: string required "What should the research answer?"
  out answer:   string stream   "A sourced answer, emitted as it is written."

  search = run web-search(query: question, limit: 3)
  brief = run summarize(question: question)

  nodes fetched {
    for hit in search.hits parallel 3 {
      page = run web-fetch(url: hit.url)
      page.text -> brief.pages
    }
  }

  brief.summary -> answer
}

A11 links application code, AI services, and user experiences through clear streaming interfaces. Adopt it incrementally and keep control of how your system is structured.