The agentic space has been buzzing for a while now, but we are extremely excited about today’s announcement: AWS Strands is now compatible with AG-UI!

If you’re building agents, this is a meaningful step forward.

Strands brings a fresh model to the space—a runtime designed for long-lived, event-driven agents. These agents keep track of changes, react to signals, and manage complex workflows over time. Instead of running one-off tools and shutting down, Strands agents persist, monitor, and adapt.

Until recently, connecting an agent to a real frontend experience required extensive manual work-custom websockets, polling loops, state-syncing logic, and endless patches.

AG-UI removes that pain entirely.

And the fact that the Strands team chose AG-UI as the integration point says a lot about where things are heading.

A Quick Shoutout to the People Behind This

Before getting into the technical bits, this deserves recognition:

👉 This integration was initially built by one of our community members and early CopilotKit adopters, Umar Majeed Rana, of Datics AI, an AI first engineering studio specializing in agentic systems development.

Umar jumped in early, saw the potential, and built the first version of the Strands integration on his own. Community work like this is what pushes the space forward.

Afterward, the AWS Strands team stepped in to refine, test, and officially approve the integration, which means this isn’t a hack or a weekend prototype.

It’s solid, supported, and ready for real applications.

Strands Agents + CopilotKit

Here’s what the integration unlocks today.

1. Strands agents can now easily connect to the frontend

And that means:

• Real-time event streaming that just works
• Live UI updates in real time
• Multi-step, long-running workflows that stay in sync

2. CopilotKit ties it all together

CopilotKit acts as the layer between AG-UI (frontend) and Strands (backend), giving teams:

• One place to build agent UIs
• Automatic threading (no manual state juggling)
• Instant reconnection to live agents
• Direct tool outputs plugged into the UI

Instead of spending weeks on infrastructure, you can focus on what your agent actually does.

3. It moves the ecosystem forward

When AWS officially supports a protocol like AG-UI, it matters.

It signals that:

• The ecosystem is starting to align around shared standards
• Frameworks don’t need to invent their own UI/agent protocols
• Multi-agent applications are becoming first-class citizens

Seeing AWS embrace AG-UI is surreal in the best way.

What This Means for Agent Builders

If you’re working with Strands today, you suddenly get a lot of capability with very little effort:

• Real-time dashboards
• Agents that update the UI even while working in the background
• Mobile capabiltity using the Kotlin SDK
• Multi-agent features out of the box
• Scaling from prototype to production without rewrites

Building with Strands just became significantly easier.

Get Started

To start building:

👉 Get started with one command: npx copilotkit create -f aws-strands-python

👉 Check out the CopilotKit / AWS Strands docs to get started

👉 Check out our example repo for a minimal integration setup

👉 Check out the dojo (mini-examples with code & docs)

What’s Next

We’re collaborating with the AWS Strands team to keep this integration clean, well-documented, and ready to evolve.

The pace of agent-focused development is only accelerating, and it’s clear that frontends and backends need a shared language.

AG-UI is shaping up to be that brigde - and with AWS now supporting it, the future looks a lot closer than it did a few months ago.

If you’re curious to follow along, join the CopilotKit or AG-UI communities.

There’s a lot more coming soon.