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.

Why This Matters

Agent Spec focuses on portability and standardization. AG-UI focuses on interaction, observability, and user experience.

Together, they form a clean separation of concerns:

• Agent Spec defines what the agent does
• AG-UI defines how users experience it

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.

A Quick Primer on the Two Layers

Open Agent Specification (Agent Spec)

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 (Agent–User Interaction Protocol)

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:

• Messages and responses
• Tool execution and progress
• Shared state updates
• Human-in-the-loop interactions

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.

What the Integration Unlocks

By bridging Agent Spec and AG-UI, teams can now treat agent definitions and UI experiences as composable layers.

From JSON to UI in Minutes

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.

Faster Experimentation With Complex Agents

Developers can preview and interact with sophisticated Agent Spec–based agents built by others, swap runtimes, or iterate on workflows without touching UI code.

True Plug-and-Play Architecture

Agent behavior remains stable while runtimes or frontends change independently. Agent Spec serves as the contract; AG-UI serves as the shared interaction layer.

Built-In Tracing and Observability

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.

Why This Is Powerful for the Ecosystem

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.

Getting Started

You can go from Agent Spec to an interactive AG-UI experience in just a few steps:

1. Bring your Agent Spec JSON
2. Add an AG-UI adapter to expose the agent endpoint
3. Connect an AG-UI frontend (for example, one built with CopilotKit)

Resources to help you get started:

• Agent Spec documentation: oracle.github.io/agent-spec/
• Starter project: https://github.com/copilotkit/with-agent-spec

This is a strong foundation for building agentic systems that are not only powerful under the hood but genuinely usable in the real world.