Skip to main content
Glama

See it work

Two agents in different harnesses can discover each other, exchange messages, and divide work without a human relaying context between them:

Claude Code → Concord   Claim src/app/page.tsx
Codex       → Concord   Claim src/app/page.tsx
Concord     → Codex     Overlap: Claude Code already owns this file
Codex       → Claude    I'll take src/app/api instead. Does that work?
Claude      → Codex     Yes. I'll keep the page and use your API contract.

Run the real Claude Code ↔ Codex demo to watch both agents resolve an overlapping claim through a live prompt/reply, build a playable app, transfer ownership, and hand the result to an independent reviewer.

Related MCP server: ccg-mcp-tool

Quick start

npm install -g @concord-ai/concord-mcp
cd /path/to/your/repository
concord setup

No Node.js? On macOS or Linux, install a self-contained build instead:

curl -fsSL https://getconcord.ai/install.sh | sh

It bundles its own Node runtime under ~/.concord/standalone and puts the concord and concord-mcp launchers in ~/.local/bin (override with CONCORD_INSTALL_DIR / CONCORD_BIN_DIR; pin a release with CONCORD_VERSION).

Restart your agent clients, then ask two of them to work in the same repository. Concord gives them a shared workspace and makes reachable sessions available for direct prompts and replies.

concord setup creates the local .concord/ workspace, registers the MCP server for Claude, Cursor, Gemini, Grok, and Codex (.mcp.json, .cursor/mcp.json, .gemini/settings.json, .grok/config.toml, and ~/.codex/config.toml). For Goose, it registers the concord-relay extension in Goose's config.yaml when detected. For Antigravity, it writes .agents/mcp_config.json, .agents/hooks.json, and .agents/rules/concord.md. It also writes Concord's tool instructions into your client configs (CLAUDE.md, AGENTS.md, .codex/, .cursor/rules/). It merges into existing config rather than replacing it and is safe to re-run.

Setup also detects supported clients and attempts to install their global Concord adapters independently. Use --no-adapters to skip that step or --require-adapters in managed installs that should fail on degraded support. Pass --no-mcp to write only the workspace and instructions while managing MCP registration yourself.

With global mode on (see below), setup leaves the repository's instruction and MCP files alone, because the user-level registrations already cover them; pass --repo-files to write them anyway, for example to check them in for a team.

The first time you run concord setup interactively, it asks whether your agents should use Concord in repositories where setup was never run (default yes). Your answer is saved in ~/.concord/config.json; concord setup --global or --no-global changes it.

With global mode on, Concord registers itself at user level for each installed agent and adds a short Concord section to their user instruction files (~/.claude/CLAUDE.md, ~/.codex/AGENTS.md, ~/.gemini/GEMINI.md, Goose's .goosehints, ~/.copilot/copilot-instructions.md; Cursor receives it from its global session hook). Nothing is written into those repositories: their work is kept in ~/.concord/global.db, one project per repository, named by its git remote as Concord Cloud names it. Sessions outside any repository share the general project. A repository you did set up keeps everything in its own .concord/; concord setup there writes no instruction or MCP files while global mode is on unless you pass --repo-files. Turning global mode off removes exactly what it added.

concord cloud login signs this machine in to Concord Cloud and links it. A linked machine works through the cloud in every folder, so its agents reach agents on any machine. No repository keeps local state while the machine is linked; a repository with a git remote is that remote's project, one without a remote is a project of its own on this machine, and anything outside a repository is general.

concord cloud unlink switches the whole machine back to local Concord while keeping the login, and concord cloud link switches it back on. concord cloud status says which applies, and concord doctor checks the link, and lists local state the machine no longer uses, with the commands to move it aside once no session started before the link is running (nothing is deleted).

Supported agents

Agent

Integration guide

Claude Code

Setup and delivery

Codex

Setup and delivery

Cursor

Setup and delivery

Gemini CLI

Setup and delivery

Grok Build

Setup and delivery

Goose

Setup and delivery

Google Antigravity

Setup and delivery

GitHub Copilot CLI

Setup and delivery

OpenCode

Setup and delivery

Devin CLI

Project-level setup via concord setup

Conductor (Claude Code, Codex)

Setup and delivery

Any other MCP-capable coding agent

Manual setup

There is no universal /concord slash command — commands are client-specific. Concord works through MCP tools plus the installed instructions on any MCP-capable client.

Live delivery depends on the receiving harness and session state. Run concord adapters status to see which installed agents are reachable and how messages will be delivered.

Communication is the starting point

Messaging gets agents talking. Concord's shared work-state keeps the resulting collaboration reliable after the message is delivered.

Without Concord

With Concord

Agents cannot contact peers in another harness

Agents send direct, replyable prompts across supported clients

Agents discover collisions after editing

Agents claim files and modules before work begins

Context disappears when a session ends

Decisions, assumptions, and findings stay attached to the task

Ownership is implied by chat history

Assignments and handoffs are explicit and acknowledged

Humans reconstruct progress from branches and diffs

Review packets arrive with scope, tests, risks, and provenance

Concord is not another autonomous agent or orchestrator. It is the shared layer around your agents: presence, messaging, task memory, ownership, handoffs, and review state through one small MCP server.

The tools

Tool

Purpose

start_work

registers presence, claims or accepts one task, and reports scope overlaps before editing

inspect_work

reads workspace/task state, an agent inbox/outbox, or a durable prompt/reply thread

update_work

records task context or immediately prompts/replies to another promptable workspace agent

transfer_work

assigns, accepts, declines, releases, reassigns, offers handoffs, or reopens versioned work

finish_work

records evidence and optionally marks a task review-ready, complete, or closed

Writes accept an agent_id, which keeps presence live just by working. inspect_work shows who is here with three separate signals — heartbeat, last activity, and the status the agent reported (writing never changes the reported status) — and flags stale claims: work whose owning agent has gone away without handing off, an assignment nobody accepted, or in-progress work with no owning agent at all.

For live agent-to-agent communication, run concord setup, then restart existing client sessions once. A prompt uses update_work with operation: "prompt", the target to_agent_id, content, and an idempotency_key; a reply uses operation: "reply" and reply_to_message_id. A receipt-bearing adapter steers a busy turn or starts an idle turn. Hook-only integrations leave a durable pull message and state that limitation in the result. Delivery fails immediately when the named agent has no reachable endpoint; Concord does not silently reroute it.

concord adapters status reports each harness separately, including its monitor/controller kind, verified reachability, required action, and version probe result. concord adapters install, doctor, and uninstall provide the same global lifecycle outside repository setup.

Concord resolves the repository workspace automatically. Operations return its workspace_id and repository root so a client can detect a misrouted call; the id can be passed explicitly when one server is coordinating multiple roots.

Lifecycle-changing operations use the task's monotonic version as expected_version. If two agents act on the same version, only the first transition succeeds. Assignment leaves work in assigned until the named agent uses transfer_work with action: "accept"; a handoff offer likewise keeps ownership with the sender until the recipient accepts. Every ownership change is retained in an append-only audit history.

What you get

SQLite is the local source of truth, kept in the .concord/ at the root of the repo the work is happening in. The MCP server resolves that root from CONCORD_REPO_ROOT if set, then Claude Code's CLAUDE_PROJECT_DIR (which Claude Code sets automatically, even for a user-scoped server), then its working directory — so every agent in one repo shares one store. Set CONCORD_REPO_ROOT when running the server somewhere its working directory is not inside the repo.

Linked Git worktrees follow Git's commondir metadata to the primary checkout, so the main checkout and all linked worktrees intentionally share one Concord database and workspace id.

To restrict explicit workspace selection, set CONCORD_ALLOWED_ROOTS to a path-delimited list of allowed repository roots. Without an allowlist, decoded roots must still exist and be directories.

concord setup writes a .concord/.gitignore containing *, so the generated workspace ignores itself and stays local without editing the repository's shared .gitignore. Teams that want selected artifacts in PRs can add negation rules to that file (setup keeps existing rules, only ensuring the * catch-all) or force-add the human-readable files. Repositories set up by Concord 0.10.5 or earlier also have a .concord/ rule in the root .gitignore; remove it before negations in .concord/.gitignore can take effect.

.concord/
├── .gitignore          ignores the whole directory
├── concord.db          local source of truth
├── HANDOFF.md          human-readable handoff
├── REVIEW_PACKET.md    review-ready evidence
├── events.jsonl        chronological tool events, one JSON object per line
└── WORK_STATE.json     generated work-state export

CLI

Concord supports both typed MCP tools and a regular CLI. MCP-capable agents can call the tools directly; humans and CLI-oriented agents can work with the same shared workspace through concord commands.

concord setup                # set up local state, instructions, and MCP clients
concord status               # roster, active work, overlaps, stale claims, review-ready
concord dashboard            # live, keyboard-driven view of agents, tasks, alerts, and activity
concord who                  # which agents are present and what they are working on
concord tasks                # list all tracked tasks
concord handoff <task-id>    # print the latest handoff
concord review-packet <id>   # print the latest review packet
concord export markdown      # regenerate .concord/ artifacts
concord check <files...>     # check exact-file overlaps with active tasks (for hooks/CI)
concord watch                # print work-state whenever .concord changes (Ctrl-C to stop)
concord doctor               # workspace checks + per-task tool adoption
concord adapters status      # global harness delivery capability matrix

concord --repo ../project status        # select by repository path from anywhere
concord --workspace ws_... status       # select an id returned by a Concord operation

To block conflicting edits in a pre-commit hook or CI, run concord check src/file.ts (or concord check --task <id> src/file.ts to exclude your own task). The command exits with status 1 when an active task claims the same file, and 0 when there is no overlap. Claude Code PreToolUse hooks treat exit code 2 as a denial, so use concord check src/file.ts || exit 2 in that hook.

--repo and --workspace are global, mutually exclusive options. The CLI uses the same CONCORD_REPO_ROOT → CLAUDE_PROJECT_DIR → working-directory priority and the same linked-worktree canonicalization as MCP.

concord dashboard is a read-only, full-screen local TUI. It refreshes from the shared SQLite workspace every second while keeping agents, tasks, alerts, context, and timeline inside a fixed terminal viewport. Use Tab to change panes, j/k or the arrow keys to select work, / to filter, ? for help, and q to quit.

Upgrade

npm install -g @concord-ai/concord-mcp@latest
concord --version

Rerun the curl … | sh installer to upgrade a self-contained install.

Concord checks daily and surfaces available updates in the CLI, MCP tools, and dashboard; concord setup can install one with confirmation (with npm or the installer, whichever you used), and CONCORD_NO_UPDATE_CHECK=1 disables checks.

What this is / is not

Shared work-state and task memory for coding agents using the same local checkout. Not an orchestrator, code reviewer, hosted sync service, memory vector DB, or autonomous coding agent.

See also: Why not just use markdown?

Contributing

See CONTRIBUTING.md and CLAUDE.md. This repo is strictly typed (no any, no typecasts) and modular. Good first issues are labelled good first issue.

Star History

Privacy & telemetry

Concord sends product and coordination telemetry to getconcord.ai. It includes random installation/invocation identifiers; irreversible per-install workspace and task-flow pseudonyms; Concord/Node/platform versions; normalized client metadata; operation names, outcomes, and durations; aggregate overlap/edit-guard results; message delivery stages and latencies; task lifecycle transitions and elapsed time; and explicitly reported acceptance, integration, human-intervention, and rework outcomes.

Concord never sends code, raw file or repository paths, remotes, usernames, raw task or agent identifiers, message identifiers or content, command arguments, tool inputs/outputs, or task content. The receiving server stores the request IP address and derives/stores a country code. Those server-side fields currently have no automatic expiry. Set CONCORD_TELEMETRY_DISABLED=1 (or DO_NOT_TRACK=1) to disable telemetry. Delivery is best effort and can never make a Concord operation fail.

License

MIT

Available Tools

5 tools
finish_workFinish workB

Record completion evidence and atomically leave the task active as a handoff, mark it review-ready, or close it with a complete/closed outcome.

Inputs: task_id (required), what_changed (required), expected_version (required), reason, +15 more.

inspect_workInspect workA
Read-onlyIdempotent

Read the workspace, one task, one agent communication inbox/outbox, or one durable prompt/reply thread by supplying at most one selector.

Inputs: task_id, agent_id, message_id, workspace_id.

start_workStart workA

Enter one task before editing: register or refresh this agent, accept addressed work when needed, claim the declared scope, and return actionable overlap warnings.

Inputs: kind (required), title (required), task_id (required), cwd, +14 more.

transfer_workTransfer workC

Apply one versioned ownership action: assign, accept, decline, release, reassign, offer an evidence-bearing handoff, or reopen terminal work.

Inputs: action (required), task_id (required), expected_version (required), force, +15 more.

update_workUpdate workC

Record task context or deliver a live prompt/reply to another promptable workspace agent.

Inputs: content (required), kind, task_id, agent_id, +6 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.7/5.0

    Scored across 5 tools

    Disambiguation5/5

    Each tool targets a distinct phase of the work lifecycle: starting, inspecting, updating, transferring ownership, and finishing. The actions are clearly separated with no overlap or ambiguous boundaries.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern with 'work' as the noun, using only snake_case and imperative verbs (start, inspect, update, transfer, finish). The pattern is fully uniform.

    Tool Count5/5

    Five tools is well-scoped for a workflow management server. Each tool covers a necessary stage without redundancy or bloat, making the set easy to navigate.

    Completeness5/5

    The tool set covers the entire task lifecycle: start, inspect (read), update (modify/communicate), transfer (ownership changes), and finish (close/handoff). It handles all major operations including reopening via transfer_work, so no critical gaps are apparent.

    Maintenance

    ActivityActive
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      This is a powerful Model Context Protocol (MCP) server that integrates multiple AI coding agents—Anthropic Claude Code, OpenAI Codex, and Google Gemini—directly into your workflow. It enables seamless cross-provider analysis, leveraging Gemini's massive token window, Codex's specialized coding capabilities, and Claude's advanced reasoning.
      10
      10 npm
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables MCP clients like Claude Code and Cursor to use multiple AI models (Gemini, GPT, Grok, DeepSeek, Kimi, Ollama) via a unified chat tool with conversation memory.
      3
      150 PyPI
      1
      Apache 2.0