ConnectOtherAIs

Your coding agent cannot see its own assumptions. This puts the plan and the diff in front of other vendors’ models — before either reaches you.

The value is not more review. It is review by a model that cannot see the author’s reasoning — the only kind that catches the author’s assumptions.

Every round, every finding, which vendor raised it, whether it was accepted or rejected and why — and what it cost. That table is the product.

The problem

You already review your agent’s work with your agent. It reads the diff it just wrote, with the reasoning that produced it still in the context, and agrees with itself.

What no other tool does

CodeRabbit, Greptile and Qodo review a pull request — after the code exists. Three things here are different:

1. The plan is gated before the code is written. review_code is refused until a plan round reached proceed. Skipping a stage is impossible, not discouraged:

open ─→ review_plan ─→ resolve ─→ (revise, repeat) ─→ PROCEED
                                                        │
   ┌────────────────────────────────────────────────────┘
   ▼
implement ─→ review_code ─→ resolve ─→ (fix, repeat) ─→ PROCEED ─→ ship

2. It lives in your agent’s loop, not in GitHub. Claude Code, Cursor and Codex call it themselves, over MCP, before a commit exists. Nothing to install into a repository, no bot on your pull requests.

3. It records the blind spots. Every finding, and every accept and reject with its reason, in a local SQLite database — grouped by category, by role and by vendor. Nobody else hands you the shape of your own agent’s blind spots.

What the measurements say

Numbers from this repository’s own campaigns, with their sample sizes, because a benchmark without one is an advertisement:

A second vendor is not a second opinion — it is different findings. Fourteen judged runs, three vendors, two cases: the overlap between vendors is 5–9 %. Three reviewers reading the same diff almost never name the same defect (RESULTS_vendor_overlap_2026-09-06.md).

The diff alone beats the whole checkout. Useful findings, and input tokens, on one commit with three hosted models (RESULTS_findings_that_are_worth_something.md):

One commit, three models, 19 findings — a single commit’s worth of evidence, and it is why Fast is the default rather than the only mode.

A local model earns its place per stage, not per repository. The same judged campaign: local was 19 % useful on a plan and 3 % on code — it writes more than codex and gemini together, and two of its seventy code-stage findings were worth having.

Reviewers you can use

• Codex CLI, Antigravity (Gemini / Claude / GPT-OSS) — signed in as themselves, no API key.
• Mistral Vibe — Mistral’s own CLI on your Mistral subscription, signed in as itself; added from the panel’s Add a model, whose ⤓ runs Mistral’s own installer for the side it is on. coai-mcp runs it on Windows only until Linux, WSL and macOS are measured, and needs coai-mcp 0.53.0.
• Kimi Code — Kimi’s own CLI on your Kimi Code plan, signed in as itself (kimi login). coai-mcp runs it on Windows only, in a home of its own that reaches your sign-in by a link (your ~/.kimi-code is never copied, edited or loaded for configuration), one review launch at a time. Added from the panel’s Add a model, whose ⤓ runs Moonshot’s own installer for the side it is on (on Windows it first installs Git, ripgrep and fd through winget when they are missing); needs coai-mcp 0.57.0.
• A model on your own machine — Ollama, vLLM, or any OpenAI-compatible endpoint (DeepSeek, vLLM, Ollama). Called directly with a strict json_schema, not through a vendor CLI that spends 20k tokens on a system prompt before it reads your diff.
• The model list is what your machine and your subscription actually have, asked for rather than shipped as a constant.

No ports, nothing listening

The server is a Native-AOT binary speaking MCP over stdio. Escalations to a person are atomic files in a local state directory. No daemon, no localhost port, no network listener on your machine. (A company-wide team server is a separate, opt-in deployment — that one is an HTTP service behind your own sign-in.)

Quickstart

code --install-extension remsoftdev.connect-other-ais

1. Install the server. Command Palette → ConnectOtherAIs: Install the MCP Server… — it downloads the Native-AOT binary for your platform into the extension’s own storage and copies a config block to your clipboard.

2. Paste the block into ~/.claude.json, .mcp.json or .vscode/mcp.json:

   {
     "mcpServers": {
       "coai": { "command": "/path/from/the/clipboard/coai-mcp", "args": [] }
     }
   }
   

3. Tell your agent the gate exists. Command Palette → Copy the CLAUDE.md snippet, paste it into CLAUDE.md, AGENTS.md or your rules file. That paragraph is what makes the agent call the gate on its own.

4. Pick your reviewers in the Settings tab — the gear in the panel’s title bar — and set what happens when the rounds run out.

The sidebar keeps only what is happening now: the gates running, the consultations being had, where each plan’s consultation cadence stands, your phrases and the bug corpus.

Everything has a ? beside it, and the help is a page of its own — in English, Russian, Ukrainian, German and Spanish.

Security lane

The optional Security lane adds reviewer/prompt pairs beside ordinary code and feature reviews. Every prompt is a card on Settings → Security lane, paired with a reviewer by a checkbox on the card: redteam-general comes first and runs on every code change while it is paired, and the conditional presets — authorization, SQL, concurrency, auth tokens, SSRF, webhooks, files, commands, deserialization, secrets, prompt injection and XSS — run when changed code matches their conditions. A shipped card is green, one you changed is orange with Restore default, and + New custom prompt adds a purple one of your own. Prompts are versioned under src_mcp/src/prompts/redteam-*.md; settings select when each runs and how much committed source it receives. Findings keep reproduction evidence and their reviewer identity in history. Missing lane answers are recorded explicitly. See the security lane module for configuration and limits.

When the rounds run out

Four honest answers, and you choose which one this repository gets: ask a human (the gate stops and puts the decision in front of you), continue anyway (it proceeds and says out loud that findings remain), good enough (the agent applies what is true, rejects the rest with reasons, and proceeds), or escalate (more reviewer effort, then a stronger model, then a stronger arbiter). A rejection needs a reason, and a reasoned rejection is discounted in later rounds unless a reviewer re-raises it with a genuinely new argument.

Deeper

Want the protocol as it is enforced, the prompt-shape measurements, the local-model path and the token accounting? → ARCHITECTURE.md.

• research/architecture.md — the system as it is, module by module
• research/module_tests.md — the harness, the flows it covers, and the gaps it does not
• research/ — every measurement campaign, with its raw data under research/data/
• todo/ — what is planned and not yet built

License

MIT.

Developing with shared instructions

Initialize the committed rules version before building:

git submodule update --init .agents/conventions
npm ci --ignore-scripts --prefix .agents/conventions
node .agents/conventions/tools/rules.mjs check --repo .
npm ci --prefix src_vs_code
npm test --prefix src_vs_code

Node 22 is used in CI. Claude Code and Codex enter through AGENTS and the shared ENTRY; project policy is in .agents/PROJECT.md and local rules in .agents/rules. Edit shared policy in the conventions repository, then review and pin its commit here. The extension prepares its gate text from that canonical source before compile/typecheck/bundle; missing, dirty or mismatched sources stop the build. Generated delivery is ignored and never edited.