Open Source Alternatives
  • Alternatives
  • Categories
    Categories by size1,268 projects
    • Developer Tools651
    • AI & Machine Learning537
    • Business & Productivity305
    • Web Development217
    • Security & Monitoring197
    • Communication & Collaboration168
    • IT Management161
    • Design & Creative139
    • DevOps & CI/CD137
    • LLMOps & AI Tooling137
    Browse all 21 categoriesCloud & Hosting, Product & Project Management and 9 more
  • Blog
  • Advertise
SearchNotion, Slack, password manager.../
Submit
Open Source Alternatives
  • Alternatives
    • Developer Tools651
    • AI & Machine Learning537
    • Business & Productivity305
    • Web Development217
    • Security & Monitoring197
    • Communication & Collaboration168
    • Browse all 21 categories
  • Blog
  • Advertise
Submit your project

New open source projects by email

The projects we add and every new guide. Free, unsubscribe any time.

Open Source Alternatives LogoOpen Source Alternatives

Handpicked Open Source Alternatives to Paid Softwares

Add Open Source Alternatives as a preferred source on Google

Product

  • Categories
  • Tag
  • Advertise

Resources

  • Blog
  • Collection
  • Submit

Company

  • Privacy Policy
  • Terms of Service
  • Refund Policy
  • Sitemap

Alternatives

  • Claude Code
  • Jira
  • Notion
  • Slack
  • Linear
  • Wispr Flow
  • All alternatives
© 2026 Open Source Alternatives. All rights reserved.
Open SourceAlternatives
Home/Categories/AI & Machine Learning/Ag Ui
icon of Ag Ui

Ag Ui

Open source alternative to CopilotKit

  • 17.9K stars
  • MIT
  • Active this week
  • Last commit 1 day ago

Last verified Nov 16, 2026

Connect AI agents to any user-facing application with an open, event-based protocol over HTTP and WebSockets.

Visit websiteGitHub17.9K stars
image of Ag Ui
TL;DR

Ag Ui AG-UI is an MIT-licensed, event-based protocol that standardizes how AI agents connect to user-facing applications. It replaces custom ad-hoc WebSocket glue code and reduces dependency on commercial platforms like CopilotKit by defining around 16 standard event types that any agent framework can emit and any frontend client can consume. Best for development teams building multi-turn agentic features who need a framework-agnostic, transport-agnostic event contract between their agent runtime and their UI.

Read the full breakdownHide the full breakdownWho it is for, how it works, trade-offs, the quick start and the FAQ
who it's for

Who Ag Ui is for#

Frontend developers adding agentic features to existing apps

AG-UI gives frontend developers a typed event interface for agent state without having to understand the agent's internal runtime. A React or Vue developer connects a CopilotKit client (or builds their own) to any AG-UI-compatible backend, subscribes to event types, and renders agent state directly in the UI without bespoke protocol code.

Skip if:

Your agent integration is simple (single text stream, no tool calls or shared state). A direct SSE endpoint is simpler for that case.

Backend engineers exposing agents to multiple client surfaces

One AG-UI-compatible backend can serve a web frontend, a mobile app, a Slack integration, and a terminal client simultaneously. Teams building multi-surface agent products get a single event contract to maintain rather than separate WebSocket implementations for each surface.

Skip if:

You are building for a single client surface and have full control over both sides of the connection. Direct protocol is simpler when you own both ends.

Teams running multiple agent frameworks

Organizations that mix LangChain, CrewAI, Pydantic AI, or other frameworks across different product lines share a single frontend integration layer across all of them. The frontend does not change when the agent backend switches frameworks.

Skip if:

Your team is standardized on one agent framework and CopilotKit's React integration already serves your use cases. CopilotKit is a production-ready client on top of AG-UI.

AI platform engineers standardizing agent-UI contracts

Platform teams building internal AI tooling or developer experience products can adopt AG-UI as the event contract for all agentic features, enforcing consistent interrupt, state sync, and generative UI patterns across the company without each product team reinventing the protocol.

Skip if:

Your organization's frontend is predominantly non-web or uses a framework with no community AG-UI client yet. Terminal and mobile are supported, but web frameworks have the most polished integration story.

the problem

The problem it solves#

Building a frontend for an AI agent requires handling outputs that look nothing like a REST API response: long-running executions, interleaved text tokens and tool call events, state updates that may arrive out of order, and user interrupts that must pause or redirect mid-execution. The traditional request-then-render cycle has no model for this, so most teams build custom WebSocket handlers or SSE parsers that work for one specific agent framework and break when the backend changes.

The harder problem is portability. A custom event protocol written for a LangChain agent cannot be reused for a CrewAI workflow without significant refactoring. Teams running multiple agent frameworks end up maintaining separate frontend integrations for each. This creates a repeated engineering cost where each change to the agent layer forces refactoring the frontend wiring alongside it.

how Ag Ui solves it

How it solves it#

Around 16 standard event types

Agent backends emit events from a standardized set covering text tokens, tool call start and end, state diffs, generative UI trees, interrupt signals, and thinking steps. Frontend clients subscribe to these events without needing to know which agent framework produced them. The fixed vocabulary makes the agent-frontend boundary testable and debuggable.

Transport-agnostic middleware layer

AG-UI builds on HTTP and WebSockets as a protocol layer, not a transport specification. SSE, WebSockets, and webhooks all work without code changes on the frontend side. The reference implementation ships as a TypeScript/Node.js HTTP server, but any backend language works: Go, Rust, Python, Java, Kotlin, C++, and .NET SDKs are available.

Bi-directional state synchronization

Agents and frontends share a typed state store with event-sourced diffs. The agent can read and write shared state while the user edits it simultaneously, with conflict resolution built into the protocol. This enables collaborative patterns like a document editor where the agent and user work on the same canvas in real time.

Human-in-the-loop interrupts

Any mid-flow execution can be paused for user approval, edited, retried, or escalated without losing state. The interrupt event is a first-class protocol event. Frontend clients display the pending action and resume the agent once the user responds, keeping the full execution trace intact.

Frontend tool calls

Agents can hand off typed actions to the frontend to execute (file opens, navigation, form fills) and receive the result back. These typed handoffs are distinct from backend tool calls: the agent delegates UI-layer work to the client rather than trying to control the browser from the server side.

SDK coverage across 9 languages

First-party SDKs ship for TypeScript/JavaScript. Community SDKs cover Go, Rust, Kotlin, Dart, Java, Ruby, C++, and .NET. Each SDK includes a getting-started guide in the GitHub repo. This means a Python FastAPI backend, a Go service, or a JVM-based enterprise application can all serve AG-UI events without language-specific glue code.

strengths · trade-offs

Strengths and trade-offs#

Strengths

  • MIT license with no service dependencyThe protocol spec and all SDKs are MIT licensed. Running AG-UI adds no licensing cost, no per-seat pricing, and no calls to a managed service. Every byte of the agent-frontend communication stays on infrastructure you control. This contrasts with frameworks that bundle protocol handling with hosted services.
  • 20+ framework integrations with 1st-party supportLangChain, CrewAI, Google ADK, Microsoft Agent Framework, AWS Strands, Pydantic AI, Mastra, Agno, LlamaIndex, and AG2 all ship first-party AG-UI integrations with documentation and working demos. Amazon Bedrock AgentCore and Oracle's Agent Spec also carry 1st-party status. Switching agent frameworks does not require rewriting the frontend layer.
  • One backend, any client surfaceThe protocol describes an event stream, not a rendering target. The same agent backend can serve a React web app, a React Native mobile client, a Slack and Microsoft Teams bot (via the Channels SDK), and a terminal simultaneously. CopilotKit, Dojo demos, and OpenBot are each distinct clients built on the same protocol.
  • Active development with broad industry backingThe repo reached 17,883 stars and 1,820 forks since launching in May 2025. The biweekly AG-UI Working Group is public and framework partners include Anthropic, Google, Microsoft, AWS, and others. Community SDK contributions continue across Kotlin, Dart, Rust, Ruby, and C++.
  • Scaffolding tool and interactive demos`npx create-ag-ui-app` generates a working full-stack AG-UI application, not a blank template. The AG-UI Dojo at dojo.ag-ui.com provides live, interactive demos for each supported framework with 50-200 line source examples, letting teams validate integration patterns before writing production code.

Trade-offs

  • -315 open issues on a protocol launched in 2025AG-UI launched in May 2025 and had 315 open issues as of November 2026. As a protocol still evolving, event type definitions and SDK APIs may change between minor versions. Teams building production systems should pin SDK versions and monitor the CHANGELOG. The spec has not yet reached a stable 1.0 that freezes the event contract.
  • -Protocol overhead for simple agent integrationsIf your agent produces a single text stream with no tool calls, state sharing, or UI control, AG-UI adds complexity. A plain SSE endpoint returning token chunks is enough for that case. The protocol's value scales with how stateful and interactive the agent workflow is: minimal-interaction chatbots get limited benefit from adopting it.
  • -Non-TypeScript SDKs are community-maintainedThe TypeScript SDK is maintained by the core team. Go, Kotlin, Rust, Dart, Java, Ruby, C++, and .NET SDKs are community-contributed and vary in maturity. Flowise and Langflow integrations were still in progress as of November 2026. Teams relying on a non-TypeScript SDK should check the specific SDK's issue tracker before committing to production use.
versus alternatives

Ag Ui vs alternatives#

AG-UI vs CopilotKit

AG-UI is the open event protocol; CopilotKit is a React application framework built on top of it. The comparison is not about which one wins but about which abstraction level fits your needs.

FeatureAG-UICopilotKit
LicenseMITCommercial
Self-hostingYes, fully self-hostableProtocol is open; Intelligence service is managed
FrontendAny (web, mobile, terminal, Slack/Teams)React and React Native primary
Agent frameworkFramework-agnostic (LangChain, CrewAI, Google ADK, etc.)Any AG-UI-compatible backend
Abstraction levelEvent protocol with typed SDKsReact hooks, components, managed state

AG-UI is the right choice when your frontend is not React, when you serve multiple surfaces (web, mobile, Slack) from one backend, or when you need to integrate an agent framework not covered by CopilotKit's built-in support. The MIT license and self-hosting path mean the entire communication layer stays on your infrastructure with no per-seat costs.

CopilotKit is the right choice for React teams who want a production-ready integration without building the protocol layer themselves. It ships React hooks, pre-built generative UI components, and CopilotKit Intelligence (memory and thread management) as a managed service. Teams that prioritize time-to-ship over protocol-level flexibility will find CopilotKit faster to get to production.

install · quick start

Quick start#

bash
Install a new AG-UI application using the project setup tool.
```bash
npx create-ag-ui-app my-agent-app
```
tech stack · detected from GitHub

What it's built on#

Languages
C#C++DartGoJavaJavaScriptKotlinPythonRubySwiftTypeScript
frequently asked

FAQ#

Is AG-UI a competitor to CopilotKit, or are they related?

AG-UI is the open protocol layer that CopilotKit (the commercial React framework) is built on top of. CopilotKit is listed as a 1st-party client in the AG-UI ecosystem. AG-UI was born from CopilotKit's initial partnership with LangChain and CrewAI. The two are complementary: AG-UI defines the event contract, CopilotKit provides the React implementation with added managed services. Teams who want to use AG-UI without CopilotKit's React library or its hosted intelligence layer can do so.

How does AG-UI differ from MCP (Model Context Protocol)?

MCP and AG-UI operate at different layers of the agentic stack. MCP connects agents to external tools, workflows, and data sources (agent to data). AG-UI connects agents to user-facing frontends (agent to user). They are not alternatives to each other; a backend can use MCP to call tools and AG-UI to send events to the frontend at the same time. The AG-UI protocol page describes all three layers (MCP, A2A, AG-UI) as distinct and complementary.

What frontend frameworks does AG-UI support?

AG-UI does not prescribe a frontend framework. It defines an event stream, so any frontend that can consume HTTP or WebSocket events works. CopilotKit provides the most complete 1st-party React integration. React Native, terminal clients, and Slack and Teams integrations (via the Channels SDK) are also maintained. The protocol is designed so a team can build a Vue, Angular, or Svelte client against it, though those require building the client integration.

Can I self-host AG-UI without using any CopilotKit services?

Yes. AG-UI is the protocol specification and SDK set, not a service. You implement the event types in your agent backend and consume them in your frontend, entirely on your own infrastructure. CopilotKit Intelligence (a hosted memory and thread service) is used by some AG-UI-based applications like OpenBot but is not part of the protocol itself. The MIT license places no restrictions on this.

Is AG-UI stable enough for production use?

AG-UI launched in May 2025 and has 17,883 GitHub stars and integrations from Google, Microsoft, AWS, and Amazon as first-party adopters. CopilotKit uses it in production. As of November 2026, 315 open issues exist in the repo and some SDK features are still in progress. For production use, pin your SDK version, track the changelog, and test against your specific framework integration. The TypeScript SDK and the core event set are the most mature parts.

also worth a look

Similar open-source tools#

page-agent

Alternative toCopilotKit

AI-powered GUI Agent for your website

  • 29,685 GitHub stars
  • MITLicence MIT

Agent Reach

Featured

Alternative toFirecrawl

Give any AI agent internet access, free and local

  • 111,579 GitHub stars
  • MITLicence MIT

Trawl

Alternative toFirecrawl

Self-hosted scraper with Cloudflare bypass, MCP, and a live dashboard

  • 1,182 GitHub stars
  • AGPL-3.0Licence AGPL-3.0

Routerly

Alternative toPortkey

Self-hosted LLM gateway with 11 routing policies and no database.

  • 112 GitHub stars
  • AGPL-3.0Licence AGPL-3.0

Desearch MCP

InAI & Machine Learning

Hosted MCP server for web, X, people, and company search

  • 1 GitHub stars
  • MITLicence MIT

LibreTranslate

Alternative toDeepL Pro

Self-hosted, offline-capable machine translation API.

  • 17,682 GitHub stars
  • AGPL-3.0Licence AGPL-3.0
by category

Open source tools in these categories#

537

AI & Machine Learning

freeCodeCamp, REA (Reverse Engineer Anything), OpenClaw
651

Developer Tools

REA (Reverse Engineer Anything), Skills for Real Engineers, superpowers
92

APIs & Integration

n8n, Firecrawl, iptv

Sponsors

Inbox Zero

Alternative toSuperhuman

AI email assistant that drafts replies and clears your inbox

  • 13,025 GitHub stars
  • AGPL-3.0Licence AGPL-3.0
  • #Email

rakazo

Alternative toGrok Bot

AI teammates you own: your keys, your model, your machine.

  • 8,291 GitHub stars
  • Apache-2.0Licence Apache-2.0
  • #AI Agents

SnitchFeed

Live monitoring on LinkedIn, X, Reddit & more. Agentic social listening for startups.

Marketing & Growth

Advertise your product

New open source projects by email

The projects we add and every new guide. Free, unsubscribe any time.

Find open source alternatives to paid software

/
  • Claude Code to OpenCode
  • Jira to Windshift
  • Notion to AppFlowy
  • Slack to Mattermost
  • Linear to GitLab
  • Wispr Flow to Handy
  • Arc to Zen Browser
  • CapCut to Concat
  • Grok Bot to rakazo
  • Superhuman to Inbox Zero
  • Discord to Stoat
  • Airtable to AITable
  • Datadog to SigNoz
  • Muse to OpenClaw
  • Railway to Coolify
  • GitHub Copilot to Cline
  • Confluence to Wiki.js
  • Microsoft Teams to Rocket.Chat
  • 1Password to KeePassXC
  • Firebase to Supabase
  • Pinecone to Qdrant
  • Zapier to n8n
  • Devin AI to OpenHands
  • Asana to Leantime
  • Claude Code to OpenCode
  • Jira to Windshift
  • Notion to AppFlowy
  • Slack to Mattermost
  • Linear to GitLab
  • Wispr Flow to Handy
  • Arc to Zen Browser
  • CapCut to Concat
  • Grok Bot to rakazo
  • Superhuman to Inbox Zero
  • Discord to Stoat
  • Airtable to AITable
  • Datadog to SigNoz
  • Muse to OpenClaw
  • Railway to Coolify
  • GitHub Copilot to Cline
  • Confluence to Wiki.js
  • Microsoft Teams to Rocket.Chat
  • 1Password to KeePassXC
  • Firebase to Supabase
  • Pinecone to Qdrant
  • Zapier to n8n
  • Devin AI to OpenHands
  • Asana to Leantime