One of the most complex problems in agentic systems today isn’t defining intelligent agents, it’s connecting those agents to real, reliable user experiences.
Oracle’s Open Agent Specification (Agent Spec) and AG-UI (Agent-User Interaction Protocol) now work together to solve that gap.
This integration connects portable, declarative agent definitions with event-driven, stateful frontends, making it dramatically easier to move from agent configuration to a production-ready interactive experience.
Instead of building the UI from scratch for every new framework or runtime, teams can now define agents once and connect them directly to AG-UI-compatible frontends, including CopilotKit.
Agent Spec focuses on portability and standardization. AG-UI focuses on interaction, observability, and user experience.
Together, they form a clean separation of concerns:
This means backend agent orchestration and frontend experience no longer need to be tightly coupled-or rewritten every time a team changes frameworks.
The result: faster iteration, fewer bespoke integrations, and a clearer path from experimentation to production.
Agent Spec is a framework-agnostic, declarative format for describing agents, workflows, and multi-agent systems. It captures behavior, tool usage, and orchestration logic in a portable JSON configuration that can be executed across compatible runtimes.
Define once. Run anywhere.
Supported runtimes already include systems like LangGraph, WayFlow, and CrewAI, with more to follow.
AG-UI is an open, event-based protocol that standardizes how agents communicate with user-facing applications. Instead of custom WebSockets, or polling, AG-UI provides a consistent event stream for:
Any frontend that speaks AG-UI can render these interactions in real time. CopilotKit provides production-ready React components out of the box, but AG-UI itself remains framework-agnostic.
By bridging Agent Spec and AG-UI, teams can now treat agent definitions and UI experiences as composable layers.
Load an existing Agent Spec JSON file, run it on a compatible runtime, and expose an AG-UI endpoint via an adapter. That agent can be explored immediately in an AG-UI frontend without custom integration.
Developers can preview and interact with sophisticated Agent Spec–based agents built by others, swap runtimes, or iterate on workflows without touching UI code.
Agent behavior remains stable while runtimes or frontends change independently. Agent Spec serves as the contract; AG-UI serves as the shared interaction layer.
With Agent Spec Tracing, standardized agent events can flow not only to the UI, but also to observability and evaluation tools via pluggable hooks, making debugging and performance analysis significantly easier.
In short, define once, choose your runtime, and connect to a user-ready interface with minimal effort.
This integration signals a broader shift toward open, composable agent architectures.
Instead of betting on a single framework or UI stack, teams can invest in standards that enable independent evolution. That flexibility is critical as agent runtimes, tooling, and interaction patterns continue to change rapidly.
Agent Spec provides portability. AG-UI provides interaction. Together, they make agentic systems far more practical to build, ship, and maintain.
You can go from Agent Spec to an interactive AG-UI experience in just a few steps:
Resources to help you get started:
This is a strong foundation for building agentic systems that are not only powerful under the hood but genuinely usable in the real world.
Subscribe to our blog and get updates on CopilotKit in your inbox.
