marc

                     █████╗  ██████╗   ██████╗
                    ██╔══██╗ ██╔══██╗ ██╔════╝
        ██████████╗ ███████║ ██████╔╝ ██║
        ██║ ██║ ██║ ██╔══██║ ██╔══██╗ ██║
        ██║ ██║ ██║ ██║  ██║ ██║  ██║ ╚██████╗
        ╚═╝ ╚═╝ ╚═╝ ╚═╝  ╚═╝ ╚═╝  ╚═╝  ╚═════╝
   ▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖
        m u l t i · a g e n t · r e l a y · c o n t r o l
   ▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘▀▘

*** Now talking in #marc
*** Topic: turn a discussion into tracked, delegated, shipped work
--> `@techlead` has been given channel operator status
    `@techlead`: specialists, standby. i'll convene you when there's work.
    `@dev` `@sre` `@design` `@sec` `@rev` `@research`: ready.

mARC (Multi-Agent Relay Control) packages a full software-delivery agent team, dressed in a retro/vaporwave IRC console aesthetic. Rather than building separate agent systems for every platform, mARC defines a single core team in core/ and compiles it into plugins for different developer tools, which we call harnesses. Today, mARC ships four harnesses: Claude Code, OpenAI Codex, Google Antigravity, and GitHub Copilot CLI. It relies on the host tool to run and isolate subagents, providing a consistent team that you install once and reuse across your projects.

Try it in two minutes

Claude Code

Run these commands inside Claude Code to add the marketplace, install the plugin, and start:

/plugin marketplace add NexaDuo/mARC
/plugin install marc@nexaduo
/marc:tech-lead

Google Antigravity

Run these commands in your terminal to install the Google Antigravity CLI, install the plugin, and start:

bash <(curl -fsSL https://antigravity.google/cli/install.sh)
git clone https://github.com/NexaDuo/mARC.git
agy plugin install ./mARC/harnesses/antigravity/marc
agy /marc:tech-lead

Note that the binary is installed to ~/.local/bin/agy, so the path should be in $PATH. agy plugin install takes a local directory, so the repository is cloned first and the plugin is installed from its harness subdirectory.

GitHub Copilot CLI

Run these commands in your terminal to add the marketplace, install the plugin, and start:

copilot plugin marketplace add NexaDuo/mARC
copilot plugin install marc@nexaduo
/marc:tech-lead

OpenAI Codex

From the repository root, run these commands to register the local marketplace, install the plugin, and start Codex:

codex plugin marketplace add .
codex plugin add marc@nexaduo
codex

Then invoke /marc:tech-lead in Codex. The marketplace file lives at .agents/plugins/marketplace.json; the selected marketplace root must therefore be the repository root, not the .agents/plugins subdirectory. Codex installs the local plugin under the marc@nexaduo identifier.

Initial support is verified with CLI 0.156.1 for marketplace installation and bundled-helper execution from a fresh consumer without team.toml. Writers use codex exec --worktree --sandbox workspace-write. All read-only roles route to Claude Code and fail closed if unavailable: a filesystem sandbox alone does not prove tool restrictions. Native agent TOMLs are templates; automatic plugin-agent discovery is not yet verified. Startup commands are compiled, but real hook trust/event delivery still needs validation. Codex read-guard is disabled and telemetry/sentinel tools report unavailable without reading transcripts or writing telemetry. To intentionally process Claude data, pass --harness claude-code. Detailed tech-lead procedures load on demand from references to keep the initial skill prompt small.

The metaphor: one channel, one op, a bench of specialists

Think of your project as an IRC channel. @techlead holds channel-operator status. It listens to the discussion, compiles it into well-specified, tracked work on your GitHub Project board, and then pings the right specialist to do it.

handle	role	pings for
@techlead	channel operator	convene, spec, record on the board, dispatch, track
@dev	engineer	app/service code, IaC, deploy scripts, schema, tests
@sre	reliability	deploys, observability, incidents, backups/DR, cost
@design	front-end	UI screens and overall web flows
@sec	security (read-only)	pre-merge diff review; one half of the mandatory merge gate
@rev	review (read-only)	pre-merge correctness review; the other half of the mandatory merge gate
@research	researcher (read-only)	external evidence (such as benchmarks or documentation) as a cited brief

@techlead is a skill (/marc:tech-lead), while @dev, @sre, @design, @sec, @rev, and @research are subagents that it dispatches. @techlead is the first of several planned leader skills, including founder and eng-director, which will convene the same shared specialist bench.

Generic by design: repository configuration

The team carries no hardcoded stack facts. When running in a repository, the agents discover details dynamically at runtime:

• They read the repository's AGENTS.md or CLAUDE.md to learn about the architecture and any lessons from previous issues.
• They check the repository configuration file (.agents/team.toml) for settings like the GitHub organization, repository name, project number, source paths, and validation commands. See docs/team.toml.example for an example.
• If the configuration file is missing, @techlead automatically queries GitHub using gh commands to locate the correct repository and project board.

A SessionStart hook outputs the active team.toml configuration into the context at the beginning of each session. If the configuration is missing, it prints a friendly note. If it finds a legacy team.config file, it prompts you to migrate by running /marc:init.

Receipts: this repo runs on mARC

mARC is built by the team it ships. Every spec, dispatch, security review, and decision that produced this repo is public, so you can audit the process before trusting it:

• the Project board, where @techlead records and tracks every task,
• the issues and pull requests, with inline spec details and security reviews,
• docs/marc/, the durable decision records and research briefs.

Install

The quick-start block above covers the interactive path: /plugin marketplace add and /plugin install run inside a Claude Code session. If you are using Claude Code, you can also run the installer script, which does the same two steps non-interactively:

./install.sh

Non-interactive install (CLI)

Claude Code also exposes the marketplace-add and plugin-install steps as shell commands, useful for scripting or for onboarding a machine without an interactive session:

claude plugin marketplace add NexaDuo/mARC
claude plugin install marc@nexaduo

claude plugin install installs to user scope by default; pass --scope project to share the install with collaborators via the repo's .claude/settings.json, or --scope local to keep it local to your checkout only. This requires Claude Code 2.0.0 or later (the minimumVersion declared in harnesses/claude-code/marc/.claude-plugin/plugin.json).

Zero-command install (declarative, for teams)

To have mARC install itself for every collaborator with no command at all, declare the marketplace and the plugin in the project's .claude/settings.json:

{
  "extraKnownMarketplaces": {
    "nexaduo": {
      "source": {
        "source": "github",
        "repo": "NexaDuo/mARC"
      }
    }
  },
  "enabledPlugins": {
    "marc@nexaduo": true
  }
}

When a team member trusts the repository folder, Claude Code prompts them to install the declared marketplace and plugin; from then on mARC loads automatically in that repo, with no /plugin or claude plugin install step required on their part.

After installation, @techlead is available as /marc:tech-lead (or agy /marc:tech-lead under Google Antigravity) in any repository, and it dispatches the specialist subagents on demand.

Update

For Claude Code, enabling auto-update for the nexaduo marketplace is recommended. When auto-update is active, Claude Code pulls new plugin versions automatically. You can manage this setting by going to /plugin and finding the nexaduo marketplace.

To update Claude Code manually at any time:

claude plugin update marc@nexaduo

Or run these commands inside Claude Code:

/plugin marketplace update nexaduo
/reload-plugins

For Google Antigravity, pull the latest sources and re-run the install from the local directory:

git -C mARC pull
agy plugin install ./mARC/harnesses/antigravity/marc

For GitHub Copilot CLI:

copilot plugin update marc@nexaduo

Update notifications: mARC ships a SessionStart hook that checks whether your installed version is behind the version on main once per session. If a new major or minor version is available, it prints a one-line update reminder. This check is silent and does not block the session if you are offline or if the check times out.

Bind mARC to a repo (optional but recommended)

Run /marc:init in the consuming repo. It scaffolds the repository configuration (.agents/team.toml). This config pins the GitHub org and repo, the Project number, key source paths, and the validation command so @techlead and the specialists do not have to guess. It shows you every file before writing anything. If you prefer to set it up by hand, copy docs/team.toml.example and fill it in. Note that a repository's local .agents/ configuration folder overrides the plugin, which in turn overrides user config. For backward compatibility, a pre-existing .claude/team.toml is still read as a fallback if .agents/team.toml is absent (harness-dependent legacy path; see each harness's COMPATIBILITY.md).

Harness Architecture & Compatibility

To support multiple host tools, mARC uses a harness-based architecture. A single core team of agents is defined under core/ and compiled into platform-specific plugins located in the harnesses/ directory.

Currently, mARC ships four harnesses: Claude Code (plugin under harnesses/claude-code/marc/), OpenAI Codex (plugin under harnesses/codex/marc/), Google Antigravity (plugin under harnesses/antigravity/marc/), and GitHub Copilot CLI (plugin under harnesses/copilot/marc/).