CopilotKit has been working toward this architecture upgrade for several months.

v1.50 is the most significant step forward in the CopilotKit 1.x line, focused on the problems developers face when building agentic features: ie, thread persistence, reliable reconnection, multi-agent coordination, shared state, type safety, and a cleaner interface.

Let’s walk through everything included in this release, explain why these changes matter, and show what you can do with the new APIs starting today.

Set your CopilotKit version to:

  
    
pnpm i @copilotkit/react-core@latest @copilotkit/react-ui@latest @copilotkit/runtime@latest

  

Then install with with your preferred package manager.

Introducing useAgent

useAgent is the easiest way to connect your frontend to any agent. It:

• Streams all agent events into your UI (messages, partial outputs, tool calls, status updates).
• Keeps the full conversation state in sync, with no extra overhead.
• Lets you send user input with one function (sendMessage()), automatically wrapped as AG-UI events.
• Enables you to build custom agent dashboards, monitoring tools, and interactive features that respond to your agent's behavior.

Limit the work with a few lines of code and instantly get a real-time, long-running agent inside your app

What v1.50 Enables

Simpler architecture, and what you get out of the box is:

• Reliable threads persistence, ie, conversations load after the session ends and continue streaming
• State syncs between UI, agents, and LLMs
• Multiple agents can work together in the same session
• Developers get tight type safety end to end
• And more

v1.50 tackles all of that in one release, without breaking existing apps.

Fully Backwards Compatible

Everything you’re using from CopilotKit v1.x continues to work - components, hooks, patterns, and runtime setup. You can upgrade, rebuild, and the app should behave identically.

Important: Don't confuse CopilotKit versions with interface versions

• CopilotKit version (e.g., v1.50) = the version of the CopilotKit framework itself
• Interface version (e.g., /v2) = the API endpoint version you're calling

Compatibility:

• CopilotKit v1.50 and newer: Works with both original (unversioned) and v2 interfaces
• CopilotKit versions before v1.50: Only work with the original (unversioned) interfaces

The new capabilities live under versioned imports:

  
    
    
import { CopilotChat, useAgent } from "@copilotkit/react-core/v2";

  

You can mix old and new:

• New Chat + old hooks
• Old components + new hooks

This keeps migration friction low while giving you a path to adopt the more powerful APIs whenever you’re ready.

Threading and Persistence for Any Agent

One of the top developer requests: long-running, resumable conversations.

v1.50 introduces the first fully supported thread model in CopilotKit:

• Each conversation has a thread ID
• Threads can be stored, restored, and reconnected
• UI components know how to reconnect automatically
• Storage is pluggable

Storage Options

Development:

You get InMemory and SQLite runners out of the box.

  
    
    
import { CopilotRuntime } from "@copilotkit/runtime";

const runtime = new CopilotRuntime({
  agents: { default: agent },
  runner: new InMemoryAgentRunner(),
});
  

Production:

Copilot Cloud + Copilot Enterprise (coming soon) will provide:

• Database-backed persistence
• Automatic stream reconnection
• Built-in product analytics
• Self-hosted deployment options

(Teams needing this today can join the Enterprise Early Access program.)

Loading and Reconnecting Threads

On the client:

This:

• Loads a stored thread
• Restores UI and state
• Automatically reconnects the agent streaming if the page reloads

No extra complicated setup is required.

useAgent is the new v2 hook and a superset of useCoAgent. It exposes a more complete set of tools for coordinating agent behavior.

What you’ll get out of the box:

1. Shared State

Useful when the agent needs to maintain a structured memory object tied to your UI.

  
    
    
const { agent } = useAgent({ agentId: "my-agent" });

agent.state;
agent.setState;

  

2. Time Travel

Set or override the message history directly.

  
    
    
agent.setMessages(/* new message array */);


  

Great for restoring conversations, cleaning up state, testing, and replaying interactions.

3. Multi-Agent Execution

Run multiple agents side-by-side in the same UI.

  
    
    
const { agent: langgraph } = useAgent({ agentId: "langgraph" });
const { agent: pydantic } = useAgent({ agentId: "pydantic" });

[langgraph, pydantic].forEach((agent) => {
  agent.addMessage({ id: crypto.randomUUID(), role: "user", content: message });
  agent.runAgent();
});

  

4. Agent-to-Agent Awareness

Agents can read or adopt each other’s messages.

  
    
    
langgraph.setMessages(pydantic.messages);
pydantic.setMessages(langgraph.messages);

  

This enables structured multi-agent orchestration without forcing developers to adopt a specific agent framework.

New Design System (v2 UI Components)

The UI overhaul introduces modernized components with a flexible override system.

Available under @copilotkit/react-core/v2:

• CopilotChat
• CopilotSidebar
• CopilotPopup

Highlights:

• A slot-based architecture for customizing individual UI regions
• More consistent and higher-quality markdown rendering
• Cleaner integration with agents’ suggestion systems
• Works alongside v1 UI if you want incremental upgrades

The goal: build UIs that match your product, not look like a generic chat widget.

Zod Schema Support

v1.50 extends Zod to more hooks, keeping your agent interfaces type-safe in both directions.

Improved runtime and compile-time type checking for:

• useHumanInTheLoop
• useFrontendTool
• useRenderToolCall (new dev-experience tooling)

This tightens the contract between UI components, runtime messages, and LLM-driven operations.

Direct-to-LLM Improvements

For teams that prefer a direct LLM integration rather than a full agent runtime, the Direct-to-LLM path is now more flexible.

Broader Model Support

  
    
    
new BasicAgent({
  model: "openai/gpt-4o",
  prompt: "You are a helpful AI assistant.",
  temperature: 0.7,
});

  

Use more models, more providers, and configure them with fewer constraints.

Shared State for Basic Agents

The same shared state API from useAgent works with BasicAgent as well.

  
    
    
const { agent } = useAgent({ agentId: "myBasicAgent" });
agent.state;
agent.setState;

  

You can now maintain structured UI-level state in setups that don’t rely on more complex agent frameworks.

Simplified Infrastructure

One significant change is that GraphQL has been entirely removed.

The runtime now uses a simpler, more direct architecture that:

• Reduces configuration
• Cuts out an entire dependency surface
• Makes the system easier to self-host and debug

This is one of the most impactful internal cleanups of the release.

Share Your Feedback!

latform questions, early access inquiries, or team integration help:

→ **https://calendly.com/d/cnqt-yr9-hxr/talk-to-copilotkit?**

We’d love to hear how CopilotKit fits into your product.

Wrapping Up

v1.50 brings CopilotKit a lot closer to what developers have been asking for:

• Durable, resumable conversation threads
• Stronger agent APIs
• Multi-agent coordination
• A fully modernized design system
• Zod-based runtime + static type safety
• Cleaner infrastructure
• Broad model support for Direct-to-LLM setups
• Backwards compatibility with everything you already use

If you’re building agentic features into your product, this release provides a simpler, more scalable foundation for doing it well.

Does Your Team Need Help?

If you’re using CopilotKit in a production product or business, we’d love to help.

You can schedule time with the team here:

👉 Scheduling link

‍