AG-UI is heading to 1.0 - the draft specification is live

[mme]

AG-UI has grown from an idea - one protocol between agents and the applications people actually use - into an ecosystem of SDKs, framework integrations, and products running it in production. Today marks the next major milestone on that road: AG-UI 1.0 is coming, and its complete draft specification is live:

→ https://docs.ag-ui.com/spec/draft

AG-UI is what it is because of you

Every framework integration, every SDK port, every partner who bet a product on this protocol, every issue and pull request from the community - that's what turned an event protocol into an ecosystem. So here is our promise for 1.0 and beyond: this protocol is built with the people who build on it. The specification is published as a draft precisely so that the freeze reflects the ecosystem's reality, not just our own - and that's how every future version will be made too: in the open, as a draft, with your name in the discussion before it ships.

If you've built on AG-UI, read the pages closest to what you've implemented. If a rule contradicts what your integration does, if something is too ambiguous to test against, or if a behavior you depend on isn't specified: tell us. Reply here or open an issue referencing the page.

A comprehensive specification

The draft is a full, formal behavioral specification in RFC 2119 language (MUST / SHOULD / MAY): event sequencing and the run lifecycle, every event family, the transport bindings, and precise compatibility rules - paired with a machine-readable JSON Schema as the source of truth for structure, and a generated reference for every definition in it. Each rule is written to be testable, and the whole document has already been through heavy adversarial review against the reference implementation.

Everything the protocol can do is now specified with the same rigor - the capabilities you've been shipping on for a long time, like reasoning (including encrypted provider artifacts that round-trip unread), activity (structured progress a UI renders as its own widgets), shared state, and streamed messages and tool calls, each now with exact sequencing, error-handling, and compatibility rules you can test an implementation against.

What's new on the road to 1.0

On top of that, the draft defines the newest additions to the protocol surface:

• Subagents - delegated work is first-class: attribution on every event a subagent produces, lifecycle events for announced invocations, nesting, parallel execution, and clear termination semantics.
• Interrupts and resumption - runs that need human input end with a structured interrupt and resume cleanly on the next run: human-in-the-loop as a protocol pattern, not an app convention.
• Run outcomes and token usage - runs report how they ended, with per-provider, per-model usage.
• Metadata, formalized - the open channel on events, messages and tool calls now has defined merge semantics (per key, last write wins) and per-family merge targets, so provider data travels cleanly.
• Multimodal input - typed content parts for images, audio, video and documents, by URL or inline data.
• Byte-pinned binary parity - the HTTP + Protobuf binding is generated from the same schema as everything else, with cross-implementation parity pinned byte-for-byte by a shared corpus.
• Forward compatibility by design - the tolerant-reader rules: unrecognized material survives to middleware and is stripped with a warning, malformed values fail loudly, and the protocol can grow without breaking a single deployed consumer.

It is a draft: the wording is not final, and nothing is covered by a compatibility promise until 1.0 freezes. That's deliberate - it's published now so you can shape it.

How the protocol evolves from here

1.0 is also where protocol governance levels up, permanently:

• Explicit versioning. Everything about a version - readable spec and machine-readable schema - lives together under one versioned address: /spec/draft today, /spec/1.0 at freeze.
• Drafts before changes. Protocol changes will be written into a draft specification and put up for community discussion before they ship.
• Every version carries a clear way forward. Additions are designed to be safe for older implementations, retired shapes get documented translations rather than silent removal, and losing content on a downgrade obliges a warning. Upgrading will never be archaeology.

The draft is open - and the best version of 1.0 is the one you helped write.