Share plans. Get feedback. Ship faster.
We’re excited to announce the public release of @cochatai/mcp-cochat, an open-source MCP server that connects your coding agent to CoChat so your team and other AI models can review what you’re building. Without leaving your terminal.
It works with Claude Code, OpenCode, Cursor, Codex CLI, and Kilo Code. Install it in one command, and your agent’s plans stop being invisible.
npx @cochatai/mcp-cochat
The Problem: AI Coding Agents Work in Silos
AI coding agents have changed how we build software. You describe what you want, and Claude Code, Cursor, or Codex generates an implementation plan, writes code, and iterates on feedback. The productivity gains are real.
But there’s a gap nobody talks about enough: everything your agent produces stays locked inside your local session.
This creates three distinct problems that compound over time.
1. Your Team Can’t See What the Agent Is Building
When Claude Code creates an implementation plan for a new authentication system, that plan exists in your terminal window. Your co-founder can’t review it. Your backend engineer can’t flag security issues. Nobody knows what’s being built until it shows up in a pull request, at which point the architecture decisions have already been baked in.
The traditional workaround? Copy the plan into Slack, a Google Doc, or a Notion page. Then copy the feedback back. Then re-explain the context your agent already had. This friction means most plans never get reviewed at all.
2. Other Models Can’t Offer a Second Opinion
You might trust Claude to write your implementation plan but want GPT to stress-test the architecture. Or you want Gemini to review the security implications. Today, that means manually copying output between chat windows, losing context with every paste.
Every model has different strengths and blind spots. Using only one perspective on a critical design decision is like having only one reviewer on a pull request. You’ll catch more issues with diverse viewpoints, but the tooling makes it impractical.
3. Knowledge Doesn’t Persist
This might be the most costly problem. Your agent helps you make a critical decision: why you chose PostgreSQL over MongoDB, why you went with JWTs instead of session tokens, why you structured the API that way. That reasoning lives in a chat session that scrolls away.
Next week, when you (or a teammate, or a different agent) revisit the same codebase, the context is gone. You re-debate the same decisions. You reverse choices without realizing they were intentional. Institutional knowledge evaporates at the speed of a closed terminal tab.
The Solution: Connect Your Agent to Your Team
The CoChat MCP bridges your coding agent and CoChat, a collaborative workspace where humans and AI models work together. It creates a feedback loop:
- You code. Your agent creates an implementation plan.
- Everyone sees it. The plan automatically appears in CoChat as a collaborative thread. Engineers, other AI models, anyone with access can review it.
- Multi-perspective review. Humans catch product issues, a different model spots architectural blind spots, another flags security concerns.
- You pull it back. Your agent fetches all feedback and adapts the plan.
- Knowledge compounds. Design decisions get saved as project memories, searchable by any person or model in any future session.
Your Claude Code session stops being a black box. Your team stays in sync, other models provide second opinions, and decisions persist across sessions. No standups, Slack threads, or PRs-as-documentation required.
Your Coding Agent CoChat (Team + AI Workspace)
────────────────── ────────────────────────────
You: "Build a user dashboard"
│
▼
Claude creates plan ─────────────▶ Plan appears as collaborative
(auto-shared via MCP) chat thread in project folder
│
┌─────┼──────────┐
▼ ▼ ▼
Alice GPT-4o Gemini
reviews reviews checks
tasks arch. security
│ │ │
└─────┼──────────┘
▼
Agent pulls feedback ◀────────────── "Use refresh token rotation"
and adapts the plan "Add rate limiting to auth"
│
▼
Agent saves decisions ──────────────▶ Project memories stored
as project memories (searchable by any model/person)
│
▼
Next session: any agent ◀────────── Memories available in all
recalls past decisions CoChat conversations tooWhat You Get
Collaborative Plans
When your agent creates an implementation plan, the MCP shares it as a collaborative chat thread in CoChat, scoped to your project. Your team can review it, comment on specific points, and mark tasks as completed. Back in your terminal, one command pulls all that feedback directly into your agent’s context.
No copy-pasting. No context loss. The plan is a living document that moves between your terminal and your team.
Cross-Model Review
CoChat supports multiple AI models. That means you can have GPT review the plan Claude just wrote, or ask Gemini to audit the security design. Each model brings a different lens: architectural rigor, edge case detection, performance implications. The feedback flows back to your coding agent through the same pull mechanism.
Think of it as multi-model peer review. One model writes the plan. Others critique it. You ship something better.
Project Memories
Every important decision can be saved as a project memory, a piece of semantic knowledge that persists across sessions, agents, and team members. Memories are searchable and scoped to your project.
“Why did we pick PostgreSQL?” becomes a query anyone can run, from any tool, at any time. Your architecture decisions stop being tribal knowledge trapped in someone’s head.
Terminal-First Knowledge Access
The ask tool lets you query your project’s entire knowledge base without leaving your terminal. Questions are answered using your team’s actual decisions, stored memories, and project context. Not generic training data.
Automations
Trigger CoChat automations (scheduled tasks, recurring workflows, monitoring jobs) directly from your coding session. No context-switching to a browser tab.
Zero Configuration
The MCP auto-detects your project from your git remote, MCP roots, or directory name. It creates the CoChat project folder on first use. There’s nothing to set up manually. Just install and start working.
How to Set It Up
Step 1: Get Your API Key
Sign up at app.cochat.ai and generate an API key under Settings → Account → API Key.
Step 2: Add to Your Agent
Claude Code:
claude mcp add cochat \
-e COCHAT_URL="https://app.cochat.ai" \
-e COCHAT_API_KEY="your-api-key" \
-- npx @cochatai/mcp-cochat
OpenCode (add to opencode.json):
{
"mcp": {
"cochat": {
"type": "local",
"command": ["npx", "@cochatai/mcp-cochat"],
"environment": {
"COCHAT_URL": "https://app.cochat.ai",
"COCHAT_API_KEY": "your-api-key"
}
}
}
}
Cursor (add to .cursor/mcp.json):
{
"mcpServers": {
"cochat": {
"command": "npx",
"args": ["@cochatai/mcp-cochat"],
"env": {
"COCHAT_URL": "https://app.cochat.ai",
"COCHAT_API_KEY": "your-api-key"
}
}
}
}
Codex CLI and Kilo Code are also supported. See the full README for details.
Step 3: Start Using It
Plans are shared automatically when your agent creates them. Use slash commands for everything else: pulling feedback, saving memories, querying your knowledge base, and triggering automations.
Control How Much Gets Shared
Not every team wants full automation from day one. The COCHAT_AUTO_SHARE environment variable lets you dial in the behavior:
| Mode | Plans | Memories | Best For |
|---|---|---|---|
off (default) | Agent asks before sharing | On request only | Full control. The agent suggests sharing after creating a plan. |
plan | Shared automatically | On request only | Teams that always want visibility into what agents are building. |
all | Shared automatically | Saved automatically | Maximum automation. Plans and design decisions flow without prompting. |
Start with off, try plan once your team is in the rhythm, and move to all when you’re ready for hands-free knowledge capture.
Who This Is For
If you’re a developer or a small team using AI coding agents and you’ve ever:
- Wished your co-founder could see what Claude just planned before it starts writing code
- Wanted a second AI model to gut-check an architecture decision
- Lost track of why a decision was made three sprints ago
- Spent time re-explaining context that your agent already had
This is for you.
The CoChat MCP is open source (MIT licensed) and available on npm today.
npm install @cochatai/mcp-cochat
