# Gossipcat Ai

> Multi-agent code review mesh — orchestrates AI agents from multiple providers to review code in parallel, cross-review each other's findings, and build accuracy profiles over time. Agents that catch real bugs get picked more often. Agents that hallucinate get deprioritized. MCP server for Claude Code, Cursor, and other IDEs.

- **Type:** MCP server
- **Install:** `agentstack add mcp-gossipcat-ai-gossipcat-ai`
- **Verified:** Pending review
- **Seller:** [gossipcat-ai](https://agentstack.voostack.com/s/gossipcat-ai)
- **Installs:** 0
- **Category:** [Integrations](https://agentstack.voostack.com/c/integrations)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [gossipcat-ai](https://github.com/gossipcat-ai)
- **Source:** https://github.com/gossipcat-ai/gossipcat-ai

## Install

```sh
agentstack add mcp-gossipcat-ai-gossipcat-ai
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

Multi-agent consensus code review. 3+ AI agents review your code independently, cross-check each other's findings against your actual source, and only surface what survives — and the system learns which agent to trust for what.

  
  
  
  
  
  
  
  

  Install ·
  First Run ·
  Daily Use ·
  Dashboard ·
  Chat Bridge ·
  Troubleshooting ·
  Config ·
  Tools

  
    
  
  
    Live dashboard at http://localhost:<port>/dashboard — fleet view, signal stream, skill-graduation grid, and consensus flow, all in real time.
  

## Why

A single AI reviewer will, with total confidence, report bugs that aren't there. You read the finding, you go look, you waste twenty minutes — the code was fine. There's no second opinion and no track record, so you can't tell a real catch from a hallucination until you've already spent the time.

Gossipcat runs **several agents in parallel**, has them **cross-check each other's findings against your actual `file:line`**, and only surfaces what survives. When an agent invents a finding, a peer catches it and the agent's accuracy score drops — so over time the system routes each kind of work to whoever is actually reliable at it. Cross-review catches hallucinations a solo reviewer would have shipped to you; that delta is the whole point.

It runs as an MCP server inside **[Claude Code](https://claude.com/claude-code)** and **[Cursor](https://cursor.com)**, ships a [live operator dashboard](#reading-the-dashboard), and lets you [drive the orchestrator straight from the browser](#drive-it-from-your-browser).

**The consensus tags you'll see** (this is your whole job — read these, ignore the rest):

| Tag | Means | What you do |
|-----|-------|-------------|
| **CONFIRMED** | Multiple agents found it and verified it against the code | Fix it |
| **UNIQUE** | One agent found it, cross-checked and held up | Fix it — high signal |
| **DISPUTED** | Agents disagreed; gossipcat re-checked the code | Trust the verdict |
| **UNVERIFIED** | Looks real but wasn't cross-checked yet | Glance, then verify |

## How it works

```mermaid
flowchart LR
    A([agent review]) -->|cites file:line| B([peer cross-review])
    B -->|verifies against code| C{verdict}
    C -->|confirmed| D[reward signal]
    C -->|hallucination| E[penalty signal]
    D --> F[competency score]
    E --> F
    F -->|steer dispatch| G([next agent pick])
    E -->|≥3 in category| H[auto-generate skill]
    H -->|inject into prompt| A
    G --> A
    style A fill:#0ea5e9,stroke:#0369a1,color:#fff
    style H fill:#f59e0b,stroke:#b45309,color:#fff
    style D fill:#10b981,stroke:#047857,color:#fff
    style E fill:#ef4444,stroke:#b91c1c,color:#fff
```

| Step | What happens |
|------|-------------|
| **Dispatch** | Tasks routed to agents by *dispatch weight* — each agent's measured accuracy in that category |
| **Parallel review** | Agents work independently, each producing findings with cited `file:line` |
| **Cross-review** | Each agent checks peers' findings against the real code: agree, disagree, unverified, or new |
| **Consensus** | Findings deduplicated and tagged CONFIRMED / DISPUTED / UNVERIFIED / UNIQUE |
| **Signals** | Verified findings (and caught hallucinations) become *reward signals* that update accuracy scores |
| **Skill development** | An agent that repeats a category of mistake gets a *skill file* — targeted instructions auto-generated from its own failure history — injected into future prompts |

The reward signal is **grounded in your source code, not a judge model's opinion.** Every finding cites a real `file:line`; peers verify the citation mechanically. That ground truth is what makes the loop trustworthy enough to automate. The "policy update" is a markdown file under `.gossip/agents//skills/` — no weights touched, no fine-tuning, no RLHF. (It's effectively in-context reinforcement learning at the prompt layer; the framing is deliberate, the mechanism is exactly the table above.)

> A small synthesis model (`consensus_judge`, configurable) merges and deduplicates the cross-review results — it does **not** grade quality. Verdicts come from citation checks against your code, never from one model judging another.

## Native vs Relay agents

Every agent has a **type** (where it runs) and a **preset** (what skills it starts with — `reviewer`, `implementer`, `researcher`, …). You mix them freely; a team of native reviewers and relay researchers is perfectly normal.

| | Native | Relay |
|---|---|---|
| **Runs as** | A host subagent — Claude Code `Agent()` / Cursor `Task()` | A WebSocket worker on the relay server |
| **Providers** | Your Claude Code / Cursor subscription — **no API key** | Google (Gemini), OpenAI, xAI (Grok), DeepSeek, OpenClaw, Ollama, any OpenAI-compatible endpoint |
| **API key** | None | Required per provider |
| **Defined in** | `.claude/agents/.md` | `.gossip/config.json` |
| **Consensus, memory, skills** | Yes | Yes |

Both participate equally in consensus and skill development. Relay workers get `file_read` + `file_grep` during cross-review so their verification parity matches natives.

## How Gossipcat compares

| | What you get | Filters hallucinations | Improves over time |
|---|---|---|---|
| **Gossipcat** | 3+ agents cross-review each other's findings; confirmed bugs only | **Yes** — peers catch and penalize hallucinations mechanically | **Yes** — accuracy signals steer dispatch; skill files fix repeat failures |
| **Single-agent review** (Claude Code / Cursor built-in) | One model reviews your diff | No — hallucinations ship as findings | No feedback loop |
| **Model-grades-model review** | One model scores another's output | Partial — the judge can hallucinate too; no ground truth | Scores aren't wired to dispatch |
| **Pattern-match tools** (lint-style PR bots) | Rules + one LLM pass | No | No |

The difference: gossipcat verifies findings against actual `file:line` citations in *your* codebase. That ground truth is what makes the reward signal trustworthy enough to automate.

  
    Runs in
    Full support
    Full support
    WindsurfPlanned
    VS CodePlanned
  

Native agents run on Claude Code Agent() and Cursor Task(). Other MCP hosts work in relay-only mode (no native subagents).

## Quickstart

**Requirements:** Node.js 22+ and either host below. Claude Code and Cursor are co-equal first-class hosts — pick the one you use; gossipcat auto-detects it and runs native agents either way.

**Fastest path (skills CLI):** one command installs the server and walks you through setup:

```bash
npx skills add gossipcat-ai/gossipcat-ai
```

This drops an installer skill into `.claude/skills/`; your agent runs the install and then hands off to `gossip_status()` for the live rules. Prefer it over the manual steps below if you use the [skills](https://github.com/vercel-labs/skills) CLI. The manual npm install is documented next.

Install the package once:
```bash
npm install -g gossipcat
```

Claude CodeCursor

Register the MCP server:
```bash
claude mcp add gossipcat -s user -- gossipcat
```
Restart Claude Code. Native agents dispatch via `Agent()`.

Add to `.cursor/mcp.json`:
```jsonc
{ "mcpServers": {
  "gossipcat": { "command": "gossipcat" }
} }
```
Reload Cursor. Native agents dispatch via `Task()`.

Then in any project, ask the orchestrator: *"Set up a gossipcat team for this project."*

Manual MCP config / alternative install paths

Add to `~/.claude/mcp_settings.json` (Claude Code) or project-local `.mcp.json`:
```json
{ "mcpServers": { "gossipcat": { "command": "npx", "args": ["gossipcat"] } } }
```

```bash
# Pin to a version
npm install -g gossipcat@0.6.5

# Pin to a GitHub release tarball (bypasses the npm registry)
npm install -g https://github.com/gossipcat-ai/gossipcat-ai/releases/download/v0.6.5/gossipcat-0.6.5.tgz

# Project-local (postinstall writes .mcp.json — open the IDE there, no `mcp add` needed)
cd your-project && npm install --save-dev gossipcat

# From source (contributors)
git clone https://github.com/gossipcat-ai/gossipcat-ai.git && cd gossipcat-ai
npm install && npm run build:mcp
claude mcp add gossipcat -s user -- node "$PWD/dist-mcp/mcp-server.js"
```

The install ships the MCP server binary, the prebuilt dashboard (`dist-dashboard/`, launches on a dynamic port), bundled skill templates + rules + project archetypes, and a postinstall wizard that writes `.mcp.json` with correct absolute paths.

**Upgrade:** `npm install -g gossipcat@latest`, or ask in-session *"check for gossipcat updates"* (the `gossip_update` tool applies it with your confirmation).

### API keys (relay agents only)

Native agents need **no key**. For relay agents, pass provider keys with `-e` at registration or set them in your shell:

| Provider | How | Notes |
|----------|-----|-------|
| Native (Claude Code / Cursor) | — | Runs through your subscription. No key. |
| Anthropic API | `ANTHROPIC_API_KEY` | Direct API access without the subscription path |
| Google Gemini | `GOOGLE_API_KEY` | Built-in 429 watcher falls back to native on cooldown |
| OpenAI / compatible | `OPENAI_API_KEY` (+ `OPENAI_BASE_URL`) | Point `BASE_URL` at Azure / Together / Groq / OpenRouter |
| xAI (Grok) | OS keychain via `key_ref` | No env var — store in keychain, set `key_ref` (default service `grok`) |
| DeepSeek | OS keychain via `key_ref` | No env var — keychain, `key_ref` default service `deepseek` |
| OpenClaw 🦞 | — (local gateway) | OpenAI-compatible at `http://127.0.0.1:18789/v1`, auth via the local daemon |
| Ollama (local) | — | `http://localhost:11434`. `ollama pull llama3.1:8b` first |

Keys are stored persistently and cross-platform — macOS Keychain, Linux Secret Service (`secret-tool`), or an AES-256-GCM encrypted file on Windows. Mixing providers is the common production shape: cheap Gemini reviewers + native heavy implementers, dispatched by category strength.

## First Run

The fastest path from "just installed" to "first useful review."

**1 · Open your IDE in a project and bootstrap once.** In Claude Code or Cursor, run:

> **Run gossip_status**

This loads gossipcat's operating rules into the session, creates `.gossip/` on first run, and prints the dashboard URL + auth key:

```
Status:
  Host: claude-code (native agents supported)   ← which IDE you're in
  Relay: running :49664                          ← background server for agents + dashboard
  Workers: 0                                     ← agents busy right now (rises during a round)
  Dashboard: http://localhost:49664/dashboard (key: c3208820…)  ← open it, paste the key
  Quota: google — OK                             ← provider rate-limit status (falls back to native on cooldown)
```

Open the dashboard URL, paste the key (it rotates each boot — re-run `gossip_status` for a fresh one).

**2 · Create your first team.** Tell the orchestrator what you're building:

> *"Set up a gossipcat team for this project — a TypeScript Next.js app with Postgres and Stripe."*

It proposes a team matched to your stack. **Smallest working team: `sonnet-reviewer` + `haiku-researcher` — both native, zero API keys.** Drop any relay agent whose provider key you don't have; add it later. Native agents (`native: true`) run on your subscription. Approve, and `.gossip/config.json` is written.

**3 · Run your first review** in a project with some changes:

> *"Do a consensus review of my recent changes"*

| Phase | Time | What you see |
|---|---|---|
| Decompose | ~1s | Orchestrator picks agents, dispatches in parallel |
| Independent review | 30s–2min | Each agent reads your diff and reports findings |
| Cross-review | 30s–1min | Each agent checks the others' findings against the code |
| Consensus report | 

## How to use it day-to-day

Each recipe: what to type, what you get, what to do with it.

**Review a diff before committing** → *"Review my staged changes."* Consensus report in 1–3 min; fix CONFIRMED + verified findings. For diffs under ~20 lines, skip consensus — ask `gossip_run` for a single fast agent (~10s) and save the round.

**Catch security issues** → *"Security audit `lib/stripe/webhook.ts`."* Each security agent reviews from a different angle (OWASP, validation, auth, secrets); real vulns survive cross-review, theoretical ones get dropped. Be specific about the file — "audit the codebase" is too broad.

**Understand code before changing it** → *"Research how the WebSocket lifecycle works before I touch it."* A research agent traces call paths and writes a summary into its cognitive memory, so next time it remembers — no re-discovery cost.

**Verify your own assumption** → *"I think there's a race in the tasks Map at server.ts:47 — check if I'm right."* Two agents independently confirm or push back. Author self-review is optimistic; this isn't.

**See which agents you can trust** → *"Show me agent scores."* Per-category accuracy + dispatch weights. If `gemini-reviewer` sits at 30% on `concurrency`, don't trust its concurrency findings solo.

**Improve a struggling agent** → *"gemini-reviewer keeps hallucinating about concurrency — develop a skill for it."* Gossipcat generates a targeted skill from its failure data and measures whether it works (z-test on post-bind signals). Then it's automatic.

> **Avoid:** "review the whole codebase" (too broad — scope to a file/module/diff); approving findings without reading the reasoning; running consensus for trivial questions (use a single `gossip_run` agent).

## Reading the dashboard

Open it once with the key from `gossip_status`; leave the tab open while you work. Every tool call pushes a live WebSocket update.

  

Skill-graduation grid — each card is one (skill × agent): post-bind effectiveness over a 7-day window vs threshold, with ±pp drift on graduated skills.

| Panel | What it shows |
|---|---|
| **Overview** | Active agents, dispatch weights, recent finding counts |
| **Team** | Agents sorted by reliability, with category breakdowns |
| **Tasks** | Live + historical tasks with agent, duration, status |
| **Findings** | Consensus reports by round, CONFIRMED/DISPUTED/UNVERIFIED breakdowns |
| **Agent detail** | Per-agent memory, skills, score history, task history |
| **Signals** | Raw signal feed (agreement / hallucination / unique_confirmed) |
| **Chat** | Live two-way bridge into the orchestrator (see below) |
| **Logs** | `mcp.log` (boot, errors, warnings) |

## Drive it from your browser

The dashboard's **Chat** page is a live, two-way bridge into the running orchestrator — type from the browser and your message lands in the active session; the orchestrator's dispatches, findings, and replies mirror back into the same thread in real time.

| Capability | What it does |
|---|---|
| **Multi-conversation tabs** | Several independent threads side by side — each its own `chat_id`, history, and live stream; per-tab unread, persisted across reloads |
| **Renamable tabs** | Double-click or **F2** to label a tab ("auth refactor", "perf audit") — survives reload |
| **Working-agents rail** | Live rail of who's dispatched and working right now — watch a round progress without leaving chat |
| **Structured questions** | When the orchestrator needs a decision, `gossip_ask` renders a single/multi-select card right in the chat; your pick flows back as a normal turn |

The `gossip_ask` answer boundary is fail-closed: only known options are accepted and "Other" free-text is sanitized before it reaches the orchestrator, so a dashboard answer can't smuggle instructions into the session. Launch with the `gossipcat code` wrapper (or ask the orchestrator to enable channel mode), then open the **Chat** tab.

## Host compatibility

Gossipcat auto-detects the host and adapts dispatch + the rules file it writes.

| Host | Native agents | Rules file |
|------|---------------|------------|
| **Claude Code** | Yes — `Agent()` | `.claude/rules/gossipcat.md` |
| **Cursor** | Yes — `Task(subagent_type, model, …)` | `.cursor/rules/gossipcat.mdc` |
| Windsurf | Relay-only (planned) | `.windsurfrul

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [gossipcat-ai](https://github.com/gossipcat-ai)
- **Source:** [gossipcat-ai/gossipcat-ai](https://github.com/gossipcat-ai/gossipcat-ai)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-gossipcat-ai-gossipcat-ai
- Seller: https://agentstack.voostack.com/s/gossipcat-ai
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.