What are CoAgents?

We launched the CoAgents beta a few months ago, and it was a huge success right out of the gate. We've been working with Fortune 100 companies, thousands of individual developers, small teams, and a bunch of design partners. Through all those conversations and real-world use cases, we've identified the core building blocks for building a full-stack agent with LangGraph using CopilotKit.

Coagents v0.5 is our production-ready release (though we're still going to keep improving it), and we're really proud of how far it's come. If you're curious about the building blocks of a full-stack agent, our documentation is the place to start. Even if you don't use CopilotKit, there's a ton to learn there.

Let’s walk through the major features in Coagents v0.5 and hear why both large enterprises and smaller teams told us these features were absolutely critical.

1. New Documentation

When we first rolled out Coagents, developers told us that the biggest hurdle was figuring out exactly how to piece together everything that makes an agent "full-stack." Additionally some of the Fortune 100 teams we worked with wanted a single, authoritative source that they could use train their whole organization on these concepts. That's why we went all-in on the documentation for v0.5.

What It Is

We now have brand-new, comprehensive docs that break down every step. If you're wondering how chat flows work, or how to integrate multiple agents into your application, or how LangGraph interrupt fits into the big picture—our docs have you covered. We detail everything, from the smallest chat UI tweaks to the biggest multi-agent workflows.

Why It Matters

Whether you're a one-person dev shop or a major enterprise, the learning curve can be steep if you're trying to figure this all out from scratch. Our updated docs mean you can follow clear examples, adopt best practices, and get up to speed quickly without needing to do a bunch of guesswork. One of our design partners told us they had a hard time communicating the ins and outs of building a full-stack agent to their engineers. Now, they just point them to our docs.

2. Seamless LangGraph Integration

While we were in the beta phase LangGraph launched their LangGraph platform, and immediately teams of all sizes were asking for us to support it. Another major ask was for us to support the newest LangGraph.js implementations. We quickly worked to make sure that these and the self hosted options were all available across users self hosting CopilotKit runtime and those using the new CopilotKit cloud. We’re proud to say that all of these configurations are working and supported!

What It Is

We've built seamless support for connecting to LangGraph in pretty much any way you can imagine. We support running agent in LangGraph Studio via the langgraph dev command, the LangGraph platform, or even your own FastAPI self-hosted version.

Why It Matters

Being "all in" on integration means you don't get stuck with a single approach. We heard from a small startup that was rapidly prototyping different data workflows with LangGraph. They needed to bounce between a local dev environment and a full production environment within the same week. Now, they can do exactly that without rewriting a bunch of code every time.

3. Chat With an Agent

We’ve long been known for our drop in chat tools but we’ve taken steps to make our headless UI component more visible and easy to understand. More and more teams are looking for a way to seamlessly embed the agentic interface natively throughout their application, and our headless  UI is the way to do that. Over the last few months we’ve been impressed by all the ways teams are finding to deeply integrate their agentic experiences, with the release we’re hoping to make that headless option more front and center.

What It Is

Our core building block for user-agent interaction is "Chat with an Agent." We've got multiple UI styles—pop-up, sidebar, a floating chat window, and a fully headless UI component. If you want a pre-built chat window that you can just drop in, we got you. If you need to customize every pixel of your UI, you can use the headless option.

Why It Matters

Some teams at big companies told us they needed a white-labeled chat interface that matched their app exactly, no exceptions. Meanwhile, smaller devs working on side projects didn't want to reinvent the wheel for a chat UI. The headless mode plus our flexible UI options mean you can get rolling fast or customize to the max—whatever suits your product best.

4. Agentic Generative UI

We also discovered a huge pain point around "How does the agent show the user what it's doing beyond just text?" Whether you're a large media company or a small dev building a weather app, you sometimes want the agent to pull up a more visual component or a specialized card. Agentic Generative UI is the secret sauce for making your application feel agent native. CopilotKit makes it easy to give your agent the power to hide, surface, or rearrange components anywhere in your application.

What It Is

Agentic Generative UI is where the agent can build out UI components in real time to help the user understand what's going on. We even let the agent create tool-based generative UI. So, if you're asking for the weather, the agent can automatically display a little weather card with the temperature and whether it's sunny or raining, all without you hard-coding that UI from scratch.

Why It Matters

One design partner that does data analytics told us they were spending way too long building dynamic visual elements manually. With tool-based generative UI, the agent itself can render the right card or chart on the fly, which cuts down on the development overhead and makes the experience more immersive.

5. Human-in-the-Loop

We’ve heard from companies of all sizes who say, "We need to ensure that sometimes a human can intervene before the agent finalizes an action." The pattern in the market is very clearly converging on human in the loop flows for actions of all levels of importance. Workers are transitioning to “agent conductors” and as  such, human in the loop interfaces are an incredibly important thing to get right.

What It Is

Human-in-the-loop means the agent and user can both take actions inside the chat and the application at any time. So the agent might add a new row to a database, and the user can hop in and delete that row right away if needed. We also built full support for LangGraph Interrupt flows, so you can pause an agent's execution mid-flight. Or you can use node-based flows where the agent is fully aware of everything happening during the human interaction.

Why It Matters

A retail service provider told us they needed to ensure that many actions have multimillion dollar consequences and require a sign-off from a real person. The interrupt-based flow was perfect for them. For many use cases however it’s okay to let the agent follow through with a task before updating it’s context from the user. Now you've got a robust way to handle both scenarios.

6. Shared State & Predictive State Updates

If you’re going to be co-working with an agent then you both need to know what one another are doing. Shared state and Predictive state updates are a crucial tool in maintaining continuity between human and agent. Shared state simply means that the user sees what the agent sees and vice versa, and each party can update the others context. Predictive state updates are one of those things that we built because of feedback from developers in the field. It’s something you will reach for when the time comes, and we’re excited that it will just be there waiting for you!

What It Is

With our shared state building block, you can view the agent's current state (which helps everyone trust what the agent is doing), and you can write to that state from your application. We also introduced predictive state updates, which is where if the agent is taking an action that might take a while, you can predict the end state and show it immediately so the user doesn't feel like they're waiting around in the dark.

Why It Matters

We had a Fortune 100 team building an internal procurement agent that could take a few minutes to confirm large orders. They wanted a way to let users see a "predicted" next step right away, so they didn't bounce off the system or wonder if the agent was stuck. Predictive state updates solved that perfectly. For smaller devs, it's just a killer feature so their users aren't confused about what's going on behind the scenes.

What’s next?

So that's Coagents v0.5 in a nutshell. We've taken everything we've learned from our work with Fortune 100 companies, thousands of devs, and a whole bunch of design partners, and distilled it into one product. The new documentation walks you through these building blocks, whether you're dealing with chat integration, generative UI, multi-agent flows, or advanced features like predictive state updates.

If you're building a full-stack agent, or you just want to understand what goes into one, we really think Coagents v0.5 is the best place to start. And even if you don't use CopilotKit, you can still learn a lot by going through our docs. We're excited to see what you build next and how you'll take advantage of these building blocks to create the next generation of agent-driven applications. We're here if you have any questions, and we can't wait to see where you go with it.

‍