SkillAgentSearch skills...

amicus

MCP server that lets one coding agent consult, review with, or delegate to Codex, Kimi or Claude Code.

Install / Use

claude mcp add briandconnelly -- npx -y github:briandconnelly/amicus

If the server publishes to npm under a different name, use that package instead — check the repo README.

About this skill
🔌

MCP Server

Model Context Protocol server

Quality Score

80/100

Supported Platforms

Claude Code
Claude Desktop
OpenAI Codex

Our assessment of amicus

amicus scores 80/100 on our quality scale, 3558th of 4,698 Development & Engineering skills we index.

Its MCP Server is 12 KB long, well organised into 14 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.

It has 3 GitHub stars, so there is little community track record yet; judge it on its content.

Substance
30/30
Structure
20/20
Description
12/15
Adoption
3/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated today, so amicus is actively maintained.
  • Our last check on 2026-11-12 found the source still online.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 92/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-10. Automated pattern scan on 2026-11-09. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

amicus compared with similar skills

All 4 of these similar skills score higher than amicus; compare them before choosing.

SkillScoreStarsUpdatedFormat
amicus (this skill)by briandconnelly803todayMCP Server
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md

Frequently asked questions

How do I install amicus?
Run claude mcp add briandconnelly -- npx -y github:briandconnelly/amicus. The install tabs above show the steps for each supported agent.
Which AI agents does amicus work with?
It is written for Claude Code, Claude Desktop and OpenAI Codex, as a MCP Server file. Other agents that read the same format can often use it too.
Is amicus safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 92/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is amicus still maintained?
The repository was last updated today, so amicus is actively maintained.

amicus

Give your coding agent a second opinion from a different model.

amicus is one MCP server that fronts Codex, Kimi, Pi and Claude. The backend is a parameter, not a separate installation — so instead of running a server per model and learning a tool surface for each, you ask for a consult, a review, or a delegated task and say which model should answer.

  • Consult — a read-only second opinion on an approach, a bug, or a design.
  • Review — a structured review of changes gathered from git, with findings tied to evidence.
  • Delegate — a task implemented in a throwaway git worktree, returned as a diff you review. It is never applied to your working tree.
  • Adversarial review — a fixed critic aimed at a plan, claim, or decision.

Long-running calls can be started in the background and polled, so a broad review does not block your session.

Install

Claude Code

/plugin marketplace add briandconnelly/amicus
/plugin install amicus@amicus

Codex

codex plugin marketplace add briandconnelly/amicus
codex plugin add amicus@amicus

Start a new session afterwards so the host loads the bundled skill and tools.

Any other MCP client

The plugins launch the server from a published release tag, pinned in .mcp.json. Point your client at the same command:

{
  "mcpServers": {
    "amicus": {
      "command": "uvx",
      "args": ["--from", "git+https://github.com/briandconnelly/amicus.git@v0.13.0", "amicus-mcp"]
    }
  }
}

Environment variables go wherever your client sets them for a stdio server (most accept an "env" object beside "command"; check your client's documentation). A first session from a client that has no notion of a working directory looks like this:

  1. Set AMICUS_BACKENDS to the backends you have installed and logged in to.
  2. Call amicus_backends with detail: "full". It is free, and it reports each enabled backend's installed and authenticated state plus the disclosures you should read before spending; a backend you did not enable is listed with status: null.
  3. Call amicus_consult with backend, question and an absolute workspace_root. Every paid tool needs workspace_root from such a client; the three free discovery tools reject it.
  4. If a result has ok: false, branch on error.code and, when present, follow error.repair: its next_step says what to do, and when one call recovers, its tool and arguments name that call.

Requirements

  • macOS or Linux: amicus refuses to start on a non-POSIX platform, because its background-job safety layer depends on POSIX process semantics.
  • Python 3.11 or newer, and uv.
  • The CLI for each backend you enable, installed and authenticated: codex, kimi, pi, claude. amicus drives those CLIs; it does not talk to the providers itself, and it stores no credentials.

Using it

Choose which backends are available with AMICUS_BACKENDS — a comma-separated list of codex, kimi, pi and claude (case-sensitive). Unset, all four are enabled; set, only the backends you name are. An enabled backend whose CLI is missing or not logged in still appears in amicus_backends, with status.installed and status.authenticated saying so.

pi has no default model. Set AMICUS_PI_MODEL to an exact provider/id, as pi --list-models prints it, or pass model on each call; a call with neither is refused before it spends. Pi authenticates either from credentials saved by its interactive /login <provider>, which need nothing more, or from the provider's API-key environment variable (for OpenRouter, OPENROUTER_API_KEY), which has to reach the amicus server's environment: the plugin's .mcp.json does not forward it, so your host must. If you set PI_CODING_AGENT_DIR, make it an absolute path (or ~/…): a relative one is refused before any spend and reported on amicus_backends, because pi would resolve it against a different directory for amicus's free probes than for a paid run. A pi delegate runs shell commands with no sandbox, and a command it starts (a hung or backgrounded process) can outlive the run, because amicus cannot yet find and stop it.

Then just ask, in your own words:

  • "Get a second opinion on this approach from another model."
  • "Have another model review my current changes."
  • "Delegate this task to another model and show me the proposed diff."

In Claude Code there are also slash commands:

| Command | What it does | | --- | --- | | /amicus:consult | Ask another model for a read-only second opinion | | /amicus:review | Have another model review your git changes | | /amicus:delegate | Delegate a coding task; get back a reviewable diff | | /amicus:delegate-async | Delegate a long coding task in the background; get a job id to poll with /amicus:jobs | | /amicus:adversarial | Run a fixed adversarial critic against a plan, claim, or decision | | /amicus:dry-run | Preview what a review or delegate call would send — free, no model call | | /amicus:jobs | Poll, fetch, list, or cancel a background job | | /amicus:status | Check which backends are enabled, installed, and authenticated |

Start with /amicus:status — it tells you which backends are actually usable before you spend anything.

The tools

Eighteen tools, in five groups. Discovery, previews and job management are free; the verbs and their background twins invoke the selected backend and spend its quota.

| Group | Tools | | --- | --- | | Discovery — free | amicus_backends, amicus_capabilities, amicus_models | | Verbs — paid | amicus_consult, amicus_review_changes, amicus_delegate, amicus_adversarial_review | | Previews — free | amicus_review_changes_dry_run (review), amicus_delegate_dry_run | | Background twins — paid | the four verbs again, each with an _async suffix | | Jobs — free | amicus_job_status, amicus_job_result, amicus_job_consume_result, amicus_job_list, amicus_job_cancel |

Not every backend does everything:

| Verb | Codex | Kimi | Pi | Claude | | --- | --- | --- | --- | --- | | consult, review_changes | yes | yes | yes | yes | | delegate | yes | yes | yes | no | | adversarial_review | no | no | no | yes |

Kimi is deprecated in favour of Pi, since 0.13.0, and is removed in 0.15.0 or later; it works until then. The deprecation marker on its amicus_backends entry says how to move.

A no is amicus's routing policy, not a model limitation. Claude is review-only, and the dedicated adversarial-review verb is scoped to Claude. To ask Codex, Kimi or Pi for an adversarial review, use consult or review_changes and supply the stance yourself; the dedicated verb adds a fixed critic stance and the target and evidence inputs.

Asking a tool for a backend outside its backend enum, in-tree or not, is rejected before any spend as an invalid_arguments error whose details.allowed_values lists the backends that tool accepts (the enum is that set). feature_unsupported is only a defensive check: it is returned if the named backend's declared features lack the verb, which no backend a tool's enum accepts does today.

Safety

  • A delegated diff is never applied. It runs in a throwaway git worktree and comes back for you to read and apply yourself.
  • Every verb call spends the selected backend's quota. The dry runs and the discovery and job tools do not.
  • Enabling a backend that can write makes the tool surface carry that backend's approval annotations — see docs/MIGRATION.md.
  • Your prompts go to whichever provider you selected, through that provider's own CLI. Each backend discloses how it carries your text — visible on amicus_backends.
  • A paid call's whole answer stays on disk in the job record under AMICUS_STATE_DIR, whatever detail delivered it and after only best-effort secret redaction, until it expires (AMICUS_JOB_TTL, default 24h; an expired record is removed on a later job call, not by a daemon), amicus_job_consume_result removes it or, once amicus has returned it, the per-workspace cap evicts it. The cap never evicts a result nobody has fetched that was recorded since delivery tracking (#244), whichever release recorded it. When only running jobs and such results remain, a new paid call is refused with job_cap_reached instead (ADR 0038). It can quote what you sent. Your inputs themselves are never written there (ADR 0035).
  • Kimi keeps its own copy. The kimi CLI writes its own session files (observed under ~/.kimi-code/sessions), which can hold the whole prompt and any answer produced. amicus found no documented way to switch that off and does not delete them, and none of the retention controls above reach it; Codex, Pi and Claude run with their session persistence disabled.

Configuration

AMICUS_BACKENDS is the one most people set. Beyond it, each backend takes an optional model, reasoning effort, and binary path (AMICUS_CODEX_MODEL, AMICUS_KIMI_REASONING_EFFORT, AMICUS_CLAUDE_BIN, and so on), and there are limits for timeouts, job retention and payload sizes. Every variable, what it does and its default is in docs/CONFIGURATION.md, rendered from the declarations in the code.

Logging goes to stderr, and AMICUS_LOG_FILE mirrors amicus's own records to a file. To reduce the risk of prompt text leaking through dependency logs, fastmcp and mcp records are limited to WARNING or higher on stderr, reduced to non-message diagnostics, and never written to that file (ADR 0023).

Coming from codex-in-claude, moonbridge, or claude-in-codex

amicus replaces all three. docs/MIGRATION.md maps the old tool names onto the new ones.

Status and known limits

0.13.0 is the current release. It adds a pi backend, for the pi coding-agent CLI, which runs any provider's model named by an exact provider/id in AMICUS_PI_MODEL or a call's model, and deprecates kimi in its favour, for removal in 0.15.0 or later. The discovery surface moves to amicus/0.1/schema-63, and RESULT_FORMAT did not move, so a job result 0.12.0 stored can still be read. docs/MIGRATION.md explains how to upgrade, and moving from kimi to pi, and CHANGELOG.md lists every user-visible change.

Two known limits: a third-party backend distribution can load through the amicus.backends entry-point group, but cannot yet be enabled or called, since AMICUS_BACKENDS and the backend parameter accept only the four in-tree ids; and a shell command a pi delegate leaves running in the background can outlive the run (#424).

Development

uv sync
uv run prek install --prepare-hooks   # one-time local hooks

The gate is defined once, in AGENTS.md (Rules, item 2); CI runs it on every supported Python version.

| Question | Read | | --- | --- | | What is being built and why | docs/superpowers/specs/2026-09-04-amicus-design.md; for M8, docs/superpowers/specs/2026-09-15-amicus-M8-sdk-in-tree-design.md | | How milestones are executed by agents | docs/superpowers/plans/2026-09-04-amicus-execution-model.md | | Architecture decisions | docs/adr/ | | How a release is cut | docs/RELEASING.md | | How a new codex minor becomes supported | docs/UPGRADING-CODEX.md | | How new kimi, pi, claude, fastmcp and mcp releases become issues | docs/WATCHING.md | | How a FINGERPRINT bump regenerates its test pins | scripts/regenerate_fingerprint_pins.py (its docstring) | | Every environment variable, its meaning and default | docs/CONFIGURATION.md | | The router skill an agent loads to call amicus | skills/collaborating-with-amicus/ | | Host captures and CLI evidence |

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars3
CategoryDevelopment
Updated4h ago
Forks0

Languages

Python

Trust signals

92/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 low
amicus — MCP Server: Install & Safety Check | SkillAgent