AGUI protocol on Bedrock: Stream agents via SSE

AWS launched AG-UI protocol support for Bedrock AgentCore Runtime on March 13, 2026, enabling real-time agent streaming. This integration proves that decoupled agent logic requires a standardized event stream rather than custom API glue. The AG-UI protocol serves as the critical bridge between backend reasoning engines and flexible frontend rendering layers.

Developers will learn how Amazon Bedrock AgentCore acts as a secure proxy, handling authentication and session isolation while your container listens strictly on port 8080. The article details the architecture of event streaming and shared state management within the runtime environment. It specifically examines how the FAST template accelerates deployment by providing pre-built patterns for Strands Agents and LangGraph.

Readers will discover methods to stream responses via SSE events without rewriting core agent code. The guide explains how to use CopilotKit extensions for human-in-the-loop interactions and shared canvases. By adopting this open protocol, teams can swap frontend libraries like React or Vue without altering backend agent frameworks.

The Role of AG-UI in Decoupling Agent Logic from Frontend Rendering

AG-UI Protocol Definition: Event-Based Agent-to-User Standard

AG-UI establishes an open, event-based standard that separates agent logic from how interfaces render content. This Agent-User Interaction Protocol lets backends emit structured events for generative UI, shared state, and human-in-the-loop approvals instead of relying on static text streams. Abstraction of the communication layer allows developers to pair diverse agent frameworks like Strands Agents, LangGraph, and CrewAI with any frontend library such as React or Angular. Server-sent events form the backbone of this mechanism, translating framework-specific outputs into a unified contract. Support extends natively or via integration to at least three distinct agent frameworks: Strands Agents, LangGraph, and CrewAI.

Modular architecture emerges from this decoupling, permitting backend and frontend teams to iterate independently. Adopting this event-driven model shifts complexity away from custom API glue code toward rigorous event definition and validation. Teams gain the flexibility to swap LangGraph for CrewAI without rewriting the user interface, provided the agent adheres to the core protocol specification. Such separation ensures Amazon Bedrock AgentCore acts as a transparent proxy, handling authentication and scaling while the agent focuses on tool execution.

Deploying AG-UI on Amazon Bedrock AgentCore Runtime Port 8080

Containerized servers running the AG-UI protocol on Amazon Bedrock AgentCore Runtime must listen on port 8080 for all incoming HTTP and WebSocket traffic. This fixed configuration ensures the runtime correctly routes Server-Sent Events (SSE) to the `/invocations` path while maintaining health checks via `/ping` on the same interface. Deploying a container with the AG-UI protocol flag enabled turns the platform into a transparent proxy that automatically manages authentication using Signature Version 4 (SigV4) or OAuth 2.0 through Amazon Cognito. Developers no longer need to engineer custom middleware for session isolation or complex auto-scaling rules since the runtime handles these operational burdens natively. Select this deployment model over standard chat interfaces when an application demands persistent bidirectional state or human-in-the-loop approvals rather than simple request-response text streams. Engineers building with Strands Agents can use wrappers like `ag_ui_strands` to automatically encode these events, simplifying the integration of generative UI components. Frontend libraries like React remain decoupled from backend logic yet still receive real-time updates for shared canvases or inline charts without custom WebSocket servers.

AG-UI vs MCP and A2A Protocols in the Agent System

Specific design goals distinguish AG-UI as an event-based standard for Agent-to-User interaction, filling a gap alongside the Model Context Protocol (MCP) for tool connectivity and the Agent-to-Agent (A2A) protocol for inter-agent communication. MCP connects agents to external data sources while A2A enables multi-agent coordination, yet only AG-UI handles rendering generative UI components directly to end users. The AG-UI protocol contract specifies that a timestamp advancing on every ping prevents idle session timeouts, allowing sessions to persist until the MaxLifetime limit is reached.

AG-UI serves as the transport mechanism for user interactions whereas A2UI defines the specification for actual UI widgets, keeping the protocol agnostic to specific rendering technologies. Architectural clarity ensures Amazon Bedrock AgentCore routes discrete traffic types through dedicated handlers, preventing misapplication of tool-oriented protocols for complex front-end tasks. Recognizing this boundary helps developers building interactive agents keep session management and state synchronization strong across the user interaction layer.

Architecture of Event Streaming and Shared State in AgentCore Runtime

Session Isolation and Proxy Mechanics in AgentCore Runtime

Amazon Bedrock AgentCore Runtime sits between the user and the agent container, acting as a transparent proxy that enforces session isolation before any request reaches application code. Deploying with the AG-UI protocol flag triggers automatic handling of Signature Version 4 [SigV4] or OAuth 2.0 through Amazon Cognito, removing the need for custom authentication middleware inside the container. The application exposes `POST /invocations` to receive AG-UI requests and `GET /ping` for health checks, binding strictly to port 8080. This design separates connection management from business logic, letting the runtime scale traffic independently while the agent focuses on execution.

Session state shifts from an application feature to an infrastructure concern. Centralizing these cross-cutting duties allows the full-stack AgentCore Solution Template (FAST) to process requests with integrated identity context via Amazon Cognito. Both Strands Agents and LangGraph patterns run under this unified security model without requiring framework-specific auth implementations.

Implementing Shared State with agui-strands-agent and agui-langgraph-agent

Wrapping framework-specific agents with StrandsAgent or LangGraphAGUIAgent enables bidirectional shared state persistence. The `agui-strands-agent` pattern uses the `ag-ui-strands` library to translate streaming events into AG-UI Server-Sent Events automatically. In contrast, the `agui-langgraph-agent` pattern employs `LangGraphAGUIAgent` from the `copilotkit` library to compile graphs fresh on every request. Both implementations attach AgentCore Memory per thread using a session-manager provider, ensuring conversation history survives scaling events. Code uses BedrockAgentCoreApp to read AgentCore Runtime headers like WorkloadAccessToken, Authorization, and Session-Id.

Frontend parsers consume these standardized events to render flexible interfaces without needing knowledge of the backend framework. This abstraction supports complex workflows, such as a shared todo canvas or a meeting scheduler that pauses execution for human input. The protocol defines a typed event stream over Server-Sent Events, guaranteeing consistent communication between the agent runtime and the frontend.

Memory remains opt-in; the provider returns `None` if `MEMORY_ID` is unset. This design prevents accidental state leakage between distinct user sessions in multi-tenant deployments. Validating header extraction logic is necessary to guarantee proper context isolation before production rollout.

Validating AG-UI Protocol Compliance for Timestamp Pings and Memory Providers

Operators must verify the container advances the timestamp on every ping to prevent premature session termination before the MaxLifetime limit expires. The protocol contract mandates this counter increment to signal active status, yet omitting it triggers idle timeouts regardless of backend processing state. This mechanism ensures long-running tasks do not fail due to transport-layer inactivity policies set in the runtime agreement. Relying solely on ping intervals ignores data persistence requirements for complex workflows.

Memory configuration stays optional; the provider returns None when MEMORY_ID is unset, forcing developers to handle statelessness explicitly. Unlike fixed session timers, this opt-in model requires code-level checks for the memory provider existence.

Developers using the `agui-langgraph-agent` pattern must ensure the graph compilation respects these null states. When MEMORY_ID is unset, the agent operates without persistent conversation history, requiring explicit handling of stateless interactions during scaling events. Testing these edge cases under load confirms session continuity and proper memory attachment.

Strategic Advantages of the FAST Template for Multi-Framework Agent Development

Architectural Divergence: agui-strands-agent vs LangGraphAGUIAgent Initialization

Wrapping a Strands Agent happens through the StrandsAgent class inside the `ag-ui-strands` library to translate streaming events automatically. The `agui-langgraph-agent` takes a different path by using LangGraphAGUIAgent from the `copilotkit` library to compile a graph fresh per request. Both patterns scope MCP tools specifically to the caller, yet their initialization lifecycles diverge notably regarding object instantiation and event translation.

The Strands approach relies on a direct wrapper that intercepts native streaming events without extra steps. LangGraph constructs a new execution graph for every invocation instead. This distinction means the LangGraph pattern incurs a compilation overhead absent in the direct wrapping model, though both achieve identical AgentCore Memory attachment per thread. Developers must note that while AgentCore Memory persists conversation history, the provider returns `None` if `MEMORY_ID` remains unset.

Cold-start latency suffers when graph compilation enters the equation compared to simple object wrapping. Strict type safety for complex multi-step workflows becomes available only through the compiled graph structure. Teams should select the pattern based on whether their priority is minimal initialization latency or rigorous workflow validation. Further details on deploying these patterns appear in the guide on deploying AG-UI agents. Builders aiming for rapid iteration on standard chat interfaces may prefer the Strands wrapper. Those requiring complex state machines should adopt the LangGraph compiler despite the overhead. AI Agents News recommends validating both initialization paths against your specific latency budgets before production deployment.

Deploying Generative UI and Shared State with CopilotKit on AgentCore

Custom components like `pieChart` render inline when agents trigger them via AG-UI tool calls using the CopilotKit React library. This mechanism shifts control from static templates to flexible, declarative descriptions where the agent queries data and triggers specific UI renders through tool call events. Bidirectional synchronization maintains a shared todo canvas. User edits update the system prompt, allowing the agent to call `manage_todos` and refresh the view via state snapshots.

Framework agnosticism across Strands, LangGraph, and CrewAI works without rewriting the frontend parser. Managing component registration lifecycles within the React host application adds complexity though. Builders must ensure the frontend strictly validates incoming tool call names against a whitelist to prevent unauthorized component rendering. Visual evolution decouples from backend logic, permitting independent iteration on charting libraries or canvas widgets. AI Agents News readers should note that while this enables rich human-in-the-loop approvals, it requires rigorous testing of state synchronization to avoid race conditions during rapid user inputs.

Framework Selection Criteria: Strands Automation vs LangGraph Graph Compilation

Workflow requirements dictate whether direct event streaming or explicit state machine compilation fits best. The agui-strands-agent pattern wraps a Strands Agent to automatically translate streaming events into AG-UI Server-Sent Events, minimizing middleware overhead for linear interactions Framework Agnosticism. Conversely, the LangGraph approach compiles a graph fresh on every request, strictly scoping MCP tools to the caller for complex, multi-step orchestration. Both patterns attach AgentCore Memory per thread via a session-manager provider, ensuring history persists regardless of the underlying framework choice. The constraint is structural: Strands offers simplified setup for conversational agents, while LangGraph provides rigorous control for workflows requiring set node transitions and cycle handling. Developers should select Strands when rapid iteration on chat interfaces is the priority, reserving LangGraph for scenarios demanding explicit graph compilation benefits.

Development speed clashes with runtime predictability in this architectural decision. Strands reduces boilerplate for standard queries but lacks the native cycle detection found in compiled graphs, potentially leading to infinite loops in unbounded reasoning tasks without external guards. This limitation necessitates careful prompt engineering when using Strands for open-ended problem solving compared to the deterministic paths of LangGraph.

Deploying Secure Generative UI Agents with Cognito and CDK

FAST Application Deployment Architecture via CopilotKit and AgentCore

Cloning the FAST Samples repository starts the chain reaction that builds core infrastructure through a single shell script execution. This operation spawns an Amazon Cognito user pool, an Amazon ECR repository, and the required AgentCore Runtime, Gateway, and Memory resources. The process simultaneously deploys the CopilotKit Runtime Lambda backed by Amazon API Gateway alongside AWS Amplify hosting for the interface.

1. Configure the `config.yaml` file with your specific AWS account details.
2. Run `./deploy-strands.sh` or `./deploy-langgraph.sh` to initiate the stack creation.
3. Verify the installation by requesting the agent render a pie chart or update a todo list.

Manual configuration of SSE endpoints and auth middleware becomes unnecessary with this architecture, removing a common source of production friction deployment complexity. The system wraps agent logic to handle event encoding for server-side transmission automatically, sidestepping custom middleware development Strands Agents Deployment with Event Encoding. Shared state and human-in-the-loop interactions function immediately, meeting enterprise requirements without extra plumbing Generative UI with Shared State.

Convenience here creates a rigid dependency on the provided CDK templates. Changing the underlying network topology demands a fork-and-modify workflow instead of simple parameter overrides. Operators gain rapid iteration speed yet sacrifice fine-grained control over VPC peering or custom subnet placement during the initial deployment phase.

Executing FAST Deployment Scripts and Verifying Generative UI Endpoints

Retrieve the FAST Samples repository and enter the `copilotkit-generative-ui` directory to begin provisioning infrastructure. This first step pulls the AWS Cloud Development Kit definitions needed for subsequent stack creation.

1. Update `config.yaml` with your specific AWS account identifier and target Region.
2. Execute `./deploy-langgraph.sh` or `./deploy-strands.sh` based on your chosen agent framework.
3. Wait for the script to provision the Amazon Cognito user pool, Amazon ECR repository, and AgentCore Runtime resources.

Scripts automatically configure the CopilotKit Runtime Lambda and establish AWS Amplify hosting for the frontend interface. This integrated approach removes the need for manual SSE endpoint and auth middleware setup, tasks typically required when native support is absent Deployment Complexity. Validation requires testing specific generative UI capabilities once the stack status reports `CREATE_COMPLETE`, moving beyond simple text responses. Issue a prompt requesting a pie chart render or ask the agent to add tasks to the todo canvas. These actions verify that the frontend parses AG-UI events correctly and that shared state synchronization functions bidirectionally. The AgentCore Runtime container must expose port 8080 for these health checks and invocations to succeed, representing a hard constraint. If the agent fails to render the component, check Amazon Cognito token exchange logs before assuming a framework error. Infrastructure errors often manifest as silent failures in the event stream rather than explicit crash logs because deployment logic remains separate from agent code.

Infrastructure Cleanup Protocol Using CDK Destroy Commands

Tearing down deployed stacks immediately after testing prevents ongoing charges. Leaving resources active incurs costs for Amazon ECR storage and AgentCore Runtime compute capacity even when idle. The cleanup process requires executing specific AWS Cloud Development Kit commands tailored to your deployment target.

1. Navigate to the `infra-cdk` directory and run `npx cdk destroy --all` to remove core FAST infrastructure components.
2. For CopilotKit samples, execute `npx cdk destroy --all` within the specific sample project directory.
3. Manually delete any lingering Amazon ECR repositories if the automated stack removal fails to clear container images.

This sequence ensures the Amazon Cognito user pool and AWS Amplify hosting environment are fully decommissioned. Operators must verify that CopilotKit Runtime Lambda functions no longer appear in the console post-execution. Failure to manually purge Amazon ECR assets often leaves small but persistent billing items on the account. This final step completes the lifecycle management for temporary agentic environments.

References

• What Is Agentic AI Testing & Why It Matters