Open Multi-Agent Canvas: A Chat Interface for Managing Multiple LangGraph Agents
The open-source multi-agent chat interface that lets you manage multiple agents in one dynamic conversation and add MCP servers for deep research
At a glance
- What is it?
- Open Multi-Agent Canvas is a Next.js and LangGraph application from CopilotKit that lets you run travel planning, research, and general-purpose AI agents in a single conversation, with a configurable MCP server layer for deep research tasks.
- Who is it for?
- Open Multi-Agent Canvas is the right starting point for developers who want to see LangGraph-based multi-agent coordination in a working chat UI without building the scaffolding themselves. The hard dependency on a Copilot Cloud API key is a real barrier for teams that want to self-host the full stack.
- Can I use it commercially?
- Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 28, 2026, and from our analysis. They are not legal advice.
Editorial analysis
When to Use a Multi-Agent Solution
A single AI agent running a monolithic prompt works for narrow, well-defined tasks: summarize this document, answer this question, write this function. When a task naturally decomposes into specialized subtasks that can benefit from different tools, context windows, or domain knowledge, multiple agents become more practical than one large agent trying to do everything.
Open Multi-Agent Canvas demonstrates this by shipping three separate agents: a travel planning agent that manages itineraries, an AI research agent for deep-dive information gathering, and a general-purpose MCP agent configurable at runtime. Each agent runs against a different LangGraph backend, but they appear in a single conversation UI. The user switches between agents or lets them hand off context within the same chat session.
CopilotKit, the company behind this repository, uses it as a showcase for its CoAgents framework, which connects LangGraph agent backends to frontend chat interfaces. The repository is not a minimal example but a functional application with real agents that can be deployed to LangSmith.
Architecture: Next.js Frontend, LangGraph Backends, MCP Layer
The repository splits into a frontend/ directory (the Next.js application) and an agent/ directory (a Python LangGraph backend with a built-in math MCP server). The frontend handles conversation state, agent routing, and the MCP server configuration panel. The backends run separately and communicate with the frontend over HTTP.
The two pre-existing agents (travel planning and AI researcher) live in separate CopilotKit repositories referenced from the README. They can be run locally or deployed to LangSmith for cloud execution. The MCP agent is built into the project and connects to any MCP-compatible server the user configures.
CopilotKit sits between the frontend and the LangGraph backends, handling the real-time streaming of agent responses into the chat UI. The frontend requires a NEXT_PUBLIC_CPK_PUBLIC_API_KEY from Copilot Cloud. The MCP agent backend requires both an OPENAI_API_KEY and a LANGSMITH_API_KEY. These dependencies mean the project has three external service requirements before it runs.
Setting Up and Running the Frontend
The frontend is a pnpm-managed Next.js project. After obtaining a Copilot Cloud API key from dashboard.operations.copilotkit.ai, rename the example environment file and set the key:
cd frontend
pnpm iThen add your Copilot Cloud key to the .env file:
NEXT_PUBLIC_CPK_PUBLIC_API_KEY=...Build and start the frontend:
pnpm run build && pnpm run startThe README marks the Copilot Cloud key as required. Without it, the frontend will not connect to any agent backend. This is the primary constraint for self-hosting: Copilot Cloud is a commercial service, and the README does not document a self-hosted alternative for the CopilotKit coordination layer.
Running the MCP Agent Backend and Configuring Servers
The MCP agent backend is a Python project managed with Poetry. It includes a built-in math server as a default MCP tool:
cd agent
poetry install
poetry run langgraph dev --host localhost --port 8123 --no-browserOnce the backend is running on port 8123, the README instructs opening another terminal to run a tunnel, then selecting Remote Endpoint and Local Development in the frontend UI, and copying the tunnel command with the port set to 8123.
The MCP configuration panel in the top-right of the frontend UI allows connecting to additional MCP servers. Standard IO connections run local commands, such as Python scripts. SSE connections point to external MCP-compatible servers. The README lists mcp.composio.dev and mcp.run as examples of public MCP servers the agent can connect to at runtime.
Consolidation into the CopilotKit Monorepo
The README includes a note that the project has been consolidated into the CopilotKit monorepo. The latest version lives at examples/showcases/multi-agent-canvas in the main CopilotKit repository. Issues and pull requests should be opened there, not in this repository.
This is a meaningful signal for adoption decisions. The canonical codebase is now maintained in a different location. This repository still serves as a deployable reference and received a push on 2026-09-28, which suggests it is kept current, but new feature development follows the monorepo.
For teams building on this as a foundation, reading the monorepo version first is worthwhile because it may have diverged from what this repository contains. The live demo is available at open-multi-agent-canvas.vercel.app. The repository contains a renovate.json for automated dependency updates, suggesting the maintainers intend to keep the dependency graph current even as the canonical development moves elsewhere.
Limitations: Copilot Cloud Dependency and Single-Agent Alternatives
The hard dependency on a Copilot Cloud API key is the project's most significant constraint. The README does not describe a fully self-hosted path without Copilot Cloud. Teams that need to avoid third-party dependencies for compliance or cost reasons cannot run the full stack without that key.
The two showcase agents (travel and research) live in separate repositories and require their own environment setup. Anyone who wants to test the multi-agent coordination with real agents needs to set up at minimum the frontend and one agent backend, plus the Copilot Cloud key.
A comparable alternative is the LangGraph multi-agent supervisor example in the LangChain GitHub organization, which demonstrates multi-agent orchestration without requiring a third-party coordination service. The difference is that the LangGraph supervisor example does not include a production-ready chat frontend; it is a Python notebook or script. Open Multi-Agent Canvas trades deployment simplicity (Copilot Cloud required) for a working chat UI out of the box.
The project has no GitHub releases. The README does not document a production deployment path beyond the Vercel demo at open-multi-agent-canvas.vercel.app.
Editorial conclusion
Open Multi-Agent Canvas is the right starting point for developers who want to see LangGraph-based multi-agent coordination in a working chat UI without building the scaffolding themselves. The hard dependency on a Copilot Cloud API key is a real barrier for teams that want to self-host the full stack. The project has been consolidated into the CopilotKit monorepo, so long-term development, issue tracking, and pull requests should target the canonical location at examples/showcases/multi-agent-canvas rather than this repository. Anyone evaluating it should run the frontend against the public example agents before investing in a custom LangGraph backend.
Frequently asked questions
When would you use a multi-agent solution like Open Multi-Agent Canvas?
When a task decomposes into specialized subtasks that benefit from separate agents: travel planning, research, and general-purpose tool use are three examples the project ships. A single agent works for narrow tasks; multi-agent coordination is practical when different agents need different tools or context windows in the same conversation.
What is agent canvas in Open Multi-Agent Canvas?
In this project, the canvas is the chat interface that manages multiple LangGraph-based AI agents in a single conversation. It lets users switch between or combine a travel agent, a research agent, and a configurable MCP agent within one UI session.
Does Open Multi-Agent Canvas require a Copilot Cloud account?
Yes. The README states that Copilot Cloud is required to run the project. The NEXT_PUBLIC_CPK_PUBLIC_API_KEY environment variable must be set to a Copilot Cloud key. The README does not document a self-hosted alternative to the Copilot Cloud coordination layer.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/copilotkit-open-multi-agent-canvas)