The open-source interface layer between humans and AI agents - makers of the AG-UI protocol.
Somewhere right now, an AI agent is updating a dashboard, drawing a chart, and filling out a form inside an app a person is actually using. No chat window. No copy-paste. The agent is just there, part of the software. That quiet shift is the entire business CopilotKit is building.
The company sits at an awkward, valuable seam: the gap between the agents everyone is racing to build and the apps real people open every morning. Most teams can spin up an agent in an afternoon. Getting that agent to do something useful inside their product - that is where the weeks disappear. CopilotKit's answer is an open-source SDK and a protocol that treat the application itself as the interface, not a bolted-on bubble in the corner.
For two years the industry's answer to "how do users talk to AI" was the same rectangle: a chat box that returns paragraphs. It works for demos. It is a strange way to run a bank, a logistics dashboard, or a contract workflow. Humans do not want a wall of text describing the chart - they want the chart, and a button that does the thing.
The deeper problem is plumbing. An agent that wants to act inside an app needs a two-way connection: it has to see the app's state, stream its thinking back, render real components, and hand control to a human when the stakes are high. Every team was reinventing that wiring, badly, in private. CopilotKit's bet was that this connection deserved to be a standard, the way HTTP standardized the web.
CopilotKit was founded in 2023 - originally incorporated, with admirable lack of pretension, as Tawkit, Inc. - by brothers Atai and Uli Barkai. Atai, the CEO, had spent years on the unglamorous end of software that does not get headlines: he led media infrastructure at Meta and flagship application work at Doximity. Uli runs growth.
The bet was contrarian for its moment. While much of the field chased bigger models and slicker chat, the Barkais wagered that the bottleneck would move to the front end - to how agents and interfaces actually talk. Build that layer in the open, get developers to adopt it, and the standard becomes the moat. It is the kind of bet that looks obvious only in hindsight, which is to say it looked like a rounding error to almost everyone at the time.
There is a reason that background matters. Infrastructure people tend to fall in love with boring problems - the connection, the state, the handoff - precisely because those are the problems that, once solved, everyone quietly depends on. CopilotKit was built by people who had spent careers making other engineers' lives easier, and it shows in the shape of the product: opinionated where it helps, open where it counts, and allergic to the kind of magic that breaks the moment you ship it to production.
CopilotKit ships as the frontend stack for agents: React, Angular, Vue, React Native, plus Slack, Teams and Discord surfaces. A developer runs npx copilotkit@latest create, wires an agent to the app's state, and gets generative UI, backend tool rendering, and human-in-the-loop checkpoints out of the box. The point is mundane in the best way - an agent that can update your dashboard is far more useful than one that can describe it.
The open, bi-directional standard connecting any agent backend to a user-facing app. The part Google and Microsoft adopted.
Components for chat, generative UI, shared state and tool rendering across React, Angular, Vue, mobile and chat platforms.
Production human-in-the-loop apps built on LangGraph (Python & JS) and the LangGraph Platform.
Self-hostable infrastructure with support, observability, security boundaries and the business features compliance teams ask about.
Adoption is the only honest scoreboard for a protocol, and CopilotKit's reads well. Google, Microsoft, Amazon and Oracle have adopted AG-UI - four companies that rarely agree on which way the sun rises, let alone which open standard to back. AI libraries including LangChain, Mastra and PydanticAI support it too. On the enterprise side, Deutsche Telekom, Docusign, Cisco and S&P Global are building on the stack, with a large slice of the Fortune 500 close behind.
The money followed the usage. In May 2026 the company announced a $27M raise - a $20M Series A plus a previously unannounced $7M seed - led by Glilot Capital, NFX and SignalFire, with 97212 Ventures joining. Total raised to date: $33.5M. For an open-source company, the numbers that matter most are not on the cap table anyway; they are the millions of weekly installs and the 35,000-plus developers who starred a repo whose entire pitch is plumbing. People do not bookmark plumbing unless they need it.
It is worth being clear-eyed about what the proof is and is not. Adoption of a protocol by Google or Oracle is not a contract; it is a vote of confidence that can be revisited. But standards accrete value the way coral reefs do - slowly, then structurally. Each integration that learns to speak AG-UI makes the next one cheaper, and a developer who has already wired CopilotKit into one app reaches for it reflexively in the next. That compounding is the asset, and it is the kind that does not show up on a balance sheet until it is too late to dislodge.
Bars scaled for legibility, not for your spreadsheet. The relevant fact is the direction of every line: up and to the right, which in startups is the only direction that pays rent.
The mission CopilotKit keeps repeating is unusually plain for a venture-backed company: be the interface layer between humans and AI agents, and keep the core open. The strategic logic is that protocols win by being adopted, not owned. If AG-UI becomes the default way agents and apps talk, the company sits at a useful crossroads regardless of which model or framework wins the week.
The commercial model follows the same grain - an open-source core that developers reach for first, and a paid enterprise tier for the teams that need self-hosting, support and a security story. Give away the protocol, sell the peace of mind. It is a tidy arrangement, assuming you do not mind that your most important asset is one anyone can read on GitHub.
The premise underneath everything is simple: AI agents are going to live inside the software people already use, not in a separate tab they have to remember to open. If that is true, then someone has to standardize how the agent and the app talk - the handshake, the state-sharing, the moment a human says "wait, let me approve that." CopilotKit's wager is that it can be that handshake.
The risks are real and worth naming. Open standards can be forked or absorbed by the very hyperscalers now adopting them. A 22-person team is defending territory that giants find interesting. But standards have a stubborn way of sticking once the ecosystem learns them, and CopilotKit has a head start measured in stars, installs, and logos.
So return to that opening scene. The agent quietly updating a dashboard inside an app, no chat window in sight. A few years ago that was a research demo. Today it ships behind a few lines of code and an open protocol that four of the largest companies on earth agreed to speak. CopilotKit did not make the agents smarter. It made them part of the furniture - and that is the harder, quieter, more durable thing.