Agent frameworks have become great at reasoning, orchestration, and tool execution. But the moment you want to ship a real product experience, such as interactive UI, mid-run progress, state that stays in sync, you often end up rebuilding the same “middle layer” in every stack.

Oracle, CopilotKit, and Google are aligning three open specifications so agentic apps can be assembled end-to-end with portable parts:

  • Open Agent Specification (from Oracle): define agent behavior and workflows once, run them across compatible runtimes
  • AG‑UI (from CopilotKit): standardize the live, tool-aware interaction stream between an agent run and an application
  • A2UI (from Google): let agents propose safe, declarative UI surfaces that applications can render natively

The goal is simple: plug-and-play portability across runtimes, UI frameworks, and observability tooling, without rewriting the experience each time.

In short: Agent Spec defines what runs, AG‑UI carries the interaction, and A2UI defines what the user touches. Swap implementations at any layer while keeping the experience stable.

A2UI AG-UI Agent Spec positioning

How the layers align

Open Agent Specification (Agent Spec): portable definitions and tracing A framework-agnostic, declarative way to describe agents and workflows once and run them on compatible runtimes (for example, LangGraph or WayFlow). With Agent Spec Tracing, executions emit structured events that can be forwarded to AG-UI. 

AG‑UI (CopilotKit): user–agent interaction stream:  An open, event-based protocol that standardizes the live stream between agent and app: messages, tool calls, state updates, and UI surface events (from A2UI or other generative UI specs). Any AG-UI client can consume this stream;  CopilotKit provides components and middleware. 

A2UI (Google): generative UI that stays safe and portable: A declarative specification for “generative UI” where an agent emits JSON that describes UI surfaces. The frontend renders those surfaces using native components, enabling guided interactions. 

What this integration enables

  • Define once, run anywhere: share and reuse Agent Spec configurations across runtimes
  • Render anywhere: stream A2UI surfaces to any compatible UI without per-agent wiring
  • Keep everything in sync: AG‑UI carries tool progress, state changes, UI updates, and user actions in one stream
  • Align UX with observability: the same structured events can feed UI, logging, evaluation, and monitoring
  • Plug-and-play: each layer stays independently replaceable

End-to-end demo: Calendar assistant

The with-agent-spec starter repository shows the full stack: a React UI connected to a Python backend that runs an Agent Spec agent equipped with special tools that enable A2UI

  • Agent Spec executes the agent in the chosen agent runtime (LangGraph or WayFlow) and emits tracing events via Agent Spec Tracing.
  • Those events are streamed to the frontend according to the AG-UI protocol. This includes the A2UI JSON payloads that the agent generates.
  • The React frontend renders the A2UI JSONs via, e.g., the CopilotKit A2UI renderer, as a UI component.
  • Once the user interacts with the UI (e.g., clicking a button), this action is sent back to the agent via AG-UI, to inform the agent of what has happened so that it can decide what to do next, e.g., update the data of the displayed UI or generate other UI surfaces.

Get started