AILANG · sketch
§1 · AI-readiness
The radar shows AILANG-readiness across three commercial concerns. High means docs.ag-ui.com is already strong there; low means AILANG could meaningfully help.
§2 · what an AI sees on docs.ag-ui.com
AG-UI is an open, event-based protocol standardizing communication between AI agents and user-facing applications. It enables real-time, multimodal, interactive experiences by managing agent state and user interactions. This protocol simplifies the development of reliable, debuggable agentic features, bridging traditional client-server architectures with dynamic AI agent systems.
Structural extraction — the same content an AI agent would consume from this page.
3 sections — page skeleton
35 headings
2 images
10 list items
6 links
# AG-UI Overview - Agent User Interaction Protocol [Skip to main content](#content-area) Agent User Interaction Protocol home page [Image: light logo] [Image: dark logo] [Agent User Interaction Protocol home page](/) Search...⌘K - [Discord](https://discord.gg/Jd3FzfdJa8) - [ ag-ui-protocol/ag-ui](https://github.com/ag-ui-protocol/ag-ui) - [ ag-ui-protocol/ag-ui](https://github.com/ag-ui-protocol/ag-ui) Search... Navigation Get Started AG-UI Overview [Documentation](/introduction) [SDKs](/sdk/js/core/overview) - [TypeScript SDK](https://docs.ag-ui.com/sdk/js/core/overview) - [Python SDK](https://docs.ag-ui.com/sdk/python/core/overview) ##### Get Started - [ AG-UI Overview](/introduction) - [ MCP, A2A, and AG-UI](/agentic-protocols) - Quickstart ##### Concepts - [ Core architecture](/concepts/architecture) - [ Events](/concepts/events) - [ Agents](/concepts/agents) - [ Middleware](/concepts/middleware) - [ Messages](/concepts/messages) - [ Reasoning](/concepts/reasoning) - [ State Management](/concepts/state) - [ Interrupts](/concepts/interrupts) - [ Serialization](/concepts/serialization) - [ Tools](/concepts/tools) - [ Capabilities](/concepts/capabilities) - [ Generative UI](/concepts/generative-ui-specs) ##### Draft Proposals - [ Overview](/drafts/overview) - [ Generative User Interfaces](/drafts/generative-ui) - [ Meta Events](/drafts/meta-events) ##### Tutorials - [ Developing with Cursor](/tutorials/cursor) - [ Debugging](/tutorials/debugging) ##### Development - [ What's New](/development/updates) - [ Roadmap](/development/roadmap) - [ Contributing](/development/contributing) - [ Enterprise](/talk-to-us) On this page - The Agent–User Interaction (AG-UI) Protocol - Agentic Protocols - Building blocks (today & upcoming) - Why Agentic Apps need AG-UI - The requirements of user‑facing agents - AG-UI in Action - Supported Integrations - Direct to LLM - Agent Framework - Partnerships - Agent Framework - 1st Party - Agent Framework - Community - Agent Interaction Protocols - Infrastructure / Deployment - Specification (standard) - SDKs - Clients - Quick Start - Explore AG-UI - Resources - Contributing - Support and Feedback *Header:* Get Started # AG-UI Overview ## Documentation Index Fetch the complete documentation index at: [https://docs.ag-ui.com/llms.txt](https://docs.ag-ui.com/llms.txt) Use this file to discover all available pages before exploring further. # The Agent–User Interaction (AG-UI) Protocol AG-UI is an **open**, **lightweight**, **event-based** protocol that standardizes how AI agents connect to user-facing applications. AG-UI is designed to be the general-purpose, bi-directional connection between a user-facing application and any agentic backend. Built for simplicity and flexibility, it standardizes how agent state, UI intents, and user interactions flow between your model/agent runtime and user-facing frontend applications—to allow application developers to ship reliable, debuggable, user‑friendly agentic features fast while focusing on application needs and avoiding complex ad-hoc wiring. --- ## Agentic Protocols **Confused about “A2UI” and “AG-UI”?** That’s understandable! Despite the naming similarities, they are quite different and work well together. A2UI is a [generative UI specification](./concepts/generative-ui-specs) - allowing agents to deliver UI widgets, where AG-UI is the Agent↔User Interaction protocol - which connects an agentic frontend to any agentic backend. [Learn more](https://copilotkit.ai/ag-ui-and-a2ui) AG-UI is one of three prominent open [agentic protocols](./agentic-protocols). | **Layer** | **Protocol / Example** | **Purpose** | | --- | --- | --- | | **Agent ↔ User Interaction** | **AG-UI (Agent–User Interaction Protocol)** | The open, event-based standard that connects agents to user-facing applications — enabling real-time, multimodal, interactive experiences. | | **Agent ↔ Tools & Data** | **MCP (Model Context Protocol)** | Open standard (originated by Anthropic) that lets agents securely connect to external systems — tools, workflows, and data sources. | | **Agent ↔ Agent** | **A2A (Agent to Agent)** | Open standard (originated by Google) which defines how agents coordinate and share work across distributed agentic systems. | --- ## Building blocks (today & upcoming) Streaming chat Live token and event streaming for responsive multi turn sessions, with cancel and resume. Multimodality Typed attachments and real time media (files, images, audio, transcripts); supports voice, previews, annotations, provenance. Generative UI, static Render model output as stable, typed components under app control. Generative UI, declarative Small declarative language for constrained yet open-ended agent UIs; agents propose trees and constraints, the app validates and mounts. Shared state (Read-only & read-write). Typed store shared between agent and app, with streamed event-sourced diffs and conflict resolution for snappy collaboration. Thinking steps Visualize intermediate reasoning from traces and tool events; no raw chain of thought. Frontend tool calls Typed handoffs from agent to frontend-executed actions, and back. Backend tool rendering Visualize backend tool outputs in app and chat, emit side effects as first-class events. Interrupts (human in the loop) Pause, approve, edit, retry, or escalate mid flow without losing state. Sub-agents and composition Nested delegation with scoped state, tracing, and cancellation. Agent steering Dynamically redirect agent execution with real-time user input to guide behavior and outcomes. Tool output streaming Stream tool results and logs so UIs can render long-running effects in real time. Custom events Open-ended data exchange for needs not covered by the protocol. --- ## Why Agentic Apps need AG-UI Agentic applications break the simple request/response model that dominated frontend-backend development in the pre-agentic era: a client makes a request, the server returns data, the client renders it, and the interaction ends. #### The requirements of user‑facing agents While agents are just software, they exhibit characteristics that make them challenging to serve behind traditional REST/GraphQL APIs: - Agents are **long‑running** and **stream** intermediate work—often across multi‑turn sessions. - Agents are **nondeterministic** and can **control application UI nondeterministically**. - Agents simultanously mix **structured + unstructured IO** (e.g. text & voice, alongside tool calls and state updates). - Agents need user-interactive **composition**: e.g. they may call sub‑agents, often recursively. - And more… AG-UI is an event-based protocol that enables dynamic communication between agentic frontends and backends. It builds on top of the foundational protocols of the web (HTTP, WebSockets) as an abstraction layer designed for the agentic age—bridging the gap between traditional client-server architectures and the dynamic, stateful nature of AI agents. --- ## AG-UI in Action Your browser does not support the video tag. You can see demo apps of the AG-UI features with the framework of your choice, with preview, code, and walkthrough docs in the [AG-UI Dojo](https://dojo.ag-ui.com/) --- ## Supported Integrations AG-UI was born from CopilotKit’s initial **partnership** with LangGraph and CrewAI - and brings the incredibly popular agent-user-interactivity infrastructure to the wider agentic ecosystem. **1st party** = the platforms that have AG‑UI built in and provide documentation for guidance. ### Direct to LLM | Framework | Status | AG-UI Resources | | --- | --- | --- | | Direct to LLM | Supported | [Docs](https://docs.copilotkit.ai/direct-to-llm) | ### Agent Framework - Partnerships | Framework | Status | AG-UI Resources | | --- | --- | --- | | [LangGraph](https://www.langchain.com/langgraph) | Supported | [Docs](https://docs.copilotkit.ai/langgraph/), [Demos](https://dojo.ag-ui.com/langgraph-fastapi/feature/shared_state) | | [CrewAI](https://crewai.com/) | Supported | [Docs](https://docs.copilotkit.ai/crewai-flows), [Demos](https://dojo.ag-ui.com/crewai/feature/shared_state) | ### Agent Framework - 1st Party | Framework | Status | AG-UI Resources | | --- | --- | --- | | [Microsoft Agent Framework](https://azure.microsoft.com/en-us/blog/introducing-microsoft-agent-framework/) | Supported | [Docs](https://docs.copilotkit.ai/microsoft-agent-framework), [Demos](https://dojo.ag-ui.com/microsoft-agent-framework-dotnet/feature/shared_state) | | [Google ADK](https://google.github.io/adk-docs/get-started/) | Supported | [Docs](https://docs.copilotkit.ai/adk), [Demos](https://dojo.ag-ui.com/adk-middleware/feature/shared_state?openCopilot=true) | | [AWS Strands Agents](https://github.com/strands-agents/sdk-python) | Supported | [Docs](https://docs.copilotkit.ai/aws-strands), [Demos](https://dojo.ag-ui.com/aws-strands/feature/shared_state) | | [AWS Bedrock AgentCore](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-agui-protocol-contract.html) | Supported | [Docs](https://github.com/awslabs/fullstack-solution-template-for-agentcore) | | [Mastra](https://mastra.ai/) | Supported | [Docs](https://docs.copilotkit.ai/mastra/), [Demos](https://dojo.ag-ui.com/mastra/feature/tool_based_generative_ui) | | [Pydantic AI](https://github.com/pydantic/pydantic-ai) | Supported | [Docs](https://docs.copilotkit.ai/pydantic-ai/), [Demos](https://dojo.ag-ui.com/pydantic-ai/feature/shared_state) | | [Agno](https://github.com/agno-agi/agno) | Supported | [Docs](https://docs.copilotkit.ai/agno/), [Demos](https://dojo.ag-ui.com/agno/feature/tool_based_generative_ui) | | [LlamaIndex](https://github.com/run-llama/llama_index) | Supported | [Docs](https://docs.copilotkit.ai/llamaindex/), [Demos](https://dojo.ag-ui.com/llamaindex/feature/shared_state) | | [AG2](https://ag2.ai/) | Supported | [Docs](https://docs.copilotkit.ai/ag2/)[Demos](https://dojo.ag-ui.com/ag2/feature/shared_state) | | [AWS Bedrock Agents](https://aws.amazon.com/bedrock/agents/) | In Progress | – | ### Agent Framework - Community | Framework | Status | AG-UI Resources | | --- | --- | --- | | [OpenAI Agent SDK](https://openai.github.io/openai-agents-python/) | In Progress | – | | [Cloudflare Agents](https://developers.cloudflare.com/agents/) | In Progress | – | ### Agent Interaction Protocols | Protocol | Status | AG-UI Resources | Integrations | | --- | --- | --- | --- | | [A2A Middleware](https://a2a-protocol.org/) | Supported | [Docs](https://docs.copilotkit.ai/a2a-protocol) | Partnership | ### Infrastructure / Deployment | Platform | Status | AG-UI Resources | Integrations | | --- | --- | --- | --- | | [Amazon Bedrock AgentCore](https://aws.amazon.com/bedrock/agentcore/) | Supported | [Docs](https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-agui.html) | 1st Party | ### Specification (standard) | Framework | Status | AG-UI Resources | | --- | --- | --- | | [Oracle Agent Spec](http://oracle.github.io/agent-spec/) | Supported | [Docs](https://go.copilotkit.ai/copilotkit-oracle-docs), [Demos](https://dojo.ag-ui.com/agent-spec-langgraph/feature/tool_based_generative_ui) | ### SDKs | SDK | Status | AG-UI Resources | Integrations | | --- | --- | --- | --- | | Kotlin | Supported | [Getting Started](https://github.com/ag-ui-protocol/ag-ui/blob/main/docs/sdk/kotlin/overview.mdx) | Community | | Golang | Supported | [Getting Started](https://github.com/ag-ui-protocol/ag-ui/blob/main/docs/sdk/go/overview.mdx) | Community | | Dart | Supported | [Getting Started](https://github.com/ag-ui-protocol/ag-ui/tree/main/sdks/community/dart) | Community | | Java | Supported | [Getting Started](https://github.com/ag-ui-protocol/ag-ui/blob/main/docs/sdk/java/overview.mdx) | Community | | Rust | Supported | [Getting Started](https://github.com/ag-ui-protocol/ag-ui/tree/main/sdks/community/r
Couldn't render a preview for this site. Open the URL in a new tab ↗
Screenshot via thum.io
§3 · AILANG × your business
docs.ag-ui.com scored 3/10 on agent-ready. AILANG opportunity is therefore 7/10. Here's where it would land first.
ailang serve-api takes your typed AILANG functions and exposes them as REST endpoints, MCP tools, A2A skills, and OpenAPI 3.1 docs simultaneously. One module, four agent surfaces.
ailang serve-api --port 8092 --mcp-http \ pricing.ail catalogue.ail -- POST /api/pricing/quote, MCP at /mcp/, -- A2A at /.well-known/agent.json, OpenAPI at /api/_meta/redoc.→ AILANG docs
Every tool an agent can call has a contract. Bounds, refusal paths, type signatures — proven before the agent ever sees it. The agent cannot exceed the tool's declared authority.
func placeOrder(item: SKU, qty: int) -> Receipt requires { qty > 0, qty <= 10 } ensures { result.total > 0.0 } -- the MCP server exposes this with its contract intact.→ AILANG docs
Generate an MCP server from your typed AILANG functions; the docs MCP exposes a submit_feedback tool so agents can flag issues back to the maintainer. The language and its consumers stay on the same wire.
-- The AILANG docs MCP server lets Claude / Cursor / any -- MCP client query the language directly: -- stdlib_search "URL encoding" -- submit_feedback "..."→ AILANG docs
func sketchSite(url: string<pii>, topic: Topic) -> Sketch
! {Net @limit=1, AI @limit=5, FS @limit=4, Process, Declassify}
| Signal | Topic | Result | Points | AILANG primitive |
|---|---|---|---|---|
| agent.json referenced | agent-ready | ✗ | 0/1 | ailang serve-api generates A2A agent cards automatically — bonus if you're an early adopter |
| openapi.json referenced | agent-ready | ✗ | 0/2 | ailang serve-api generates OpenAPI 3.1 from Hindley-Milner type signatures |
| MCP endpoint referenced | agent-ready | ✓ | 2/2 | ailang serve-api --mcp-http exposes typed functions as MCP tools |
| Public API docs linked | agent-ready | ✓ | 2/2 | ailang serve-api hosts Swagger + ReDoc at /api/_meta/ by default |
| Webhooks documented | agent-ready | ✓ | 2/2 | ailang serve-api handles webhooks as typed handler functions with effect-tracked side effects |
| Rate limits documented | agent-ready | ✓ | 2/2 | Capability budgets — Net @limit=N is the symmetric server-side primitive for what agents see as rate limits |
| Streaming / SSE endpoint | agent-ready | ✗ | 0/2 | std/stream — ssePost and Stream effect handle event-source endpoints with typed event types |
| Sandbox / test environment offered | agent-ready | ✗ | 0/2 | ailang --ai-stub plus mock effect handlers — deterministic, capability-scoped fakes for any effect, including Net and AI |
| Authentication documented | agent-ready | ✗ | 0/2 | std/jwt for verification, IFC labels (string |
| Idempotency keys documented | agent-ready | ✗ | 0/2 | Pure functions are idempotent by construction; requires/ensures contracts express idempotence as a static guarantee |
| AG-UI streaming protocol | agent-ready | ✓ | 1/1 | std/stream — the AG-UI event lifecycle (RUN_STARTED → TEXT_MESSAGE_CONTENT → TOOL_CALL_RESULT → RUN_FINISHED) is a textbook sum type. ADTs + exhaustive pattern matching make every event-type branch a compile error to skip. |
| HTTP 402 agent payments (x402 / pay-per-crawl) | agent-ready | ✗ | 0/1 | Net @endpoint-scoped capability budgets bound payment destinations; requires { amount <= budget } gates the payload; IFC labels keep the signed payment key out of public sinks. Same primitives cover x402 payload signing and Cloudflare's crawler-price negotiation. |
| AP2 Agent Payments Protocol | agent-ready | ✗ | 0/1 | Mandates ARE contracts. requires { intent.price <= mandate.maxPrice } + ensures { cart.total <= intent.price } is a one-to-one translation of an Intent/Cart Mandate into AILANG. Z3 can verify the bounds at compile time. |
| UTCP tool-calling protocol | agent-ready | ✗ | 0/1 | Typed function signatures are the manifest. ailang serve-api emits the same metadata as a UTCPManual (name, input/output schema, native endpoint) — direct-call discovery without a proxy server. |
| End-to-end encryption documented | privacy | ✗ | 0/2 | IFC labels (string |
| Compliance certifications cited | privacy | ✗ | 0/2 | requires/ensures contracts express machine-verifiable claims; capability budgets bound audit-trail effects; effect rows leave nothing un-declared |
| Data minimisation language | privacy | ✗ | 0/2 | Capability scoping — each Net call declares its endpoint in the effect row, so "doesn't sell" becomes a type-system-enforceable claim, not a marketing one |
| Third-party domains restrained | privacy | ✗ | 0/2 | Capability scoping — each Net call declares its endpoint in the effect row |
| Data residency / on-prem language | privacy | ✗ | 0/2 | Three-runtime deploy — same module runs in WASM (browser), Cloud Run, and native CLI |
| Single-vendor LLM language | portable | ○ | 2/2 | std/ai multi-provider — switch from Anthropic to Gemini to OpenAI without rewriting |
| Multiple AI providers cited | portable | ✓ | 2/2 | std/ai — one Step API across Anthropic, OpenAI, Gemini, OpenRouter, Ollama, and custom-package providers |
| Cross-runtime / deployment portability | portable | ✗ | 0/2 | Effect handlers as runtime adapters — same .ail runs as WASM in the browser, a Cloud Run container, and a native CLI; only the handlers change |
| BYO key / model-agnostic | portable | ✗ | 0/2 | AILANG WASM — the full interpreter ships as a browser bundle, so caller-held keys (BYOK), offline apps, and embedded demos all work client-side |
The rubric that scored this page is open-source AILANG code — every signal extractor is contract-verified. View rubric →