█████╗  ██████╗   ██████╗
                    ██╔══██╗ ██╔══██╗ ██╔════╝
        ██████████╗ ███████║ ██████╔╝ ██║
        ██║ ██║ ██║ ██╔══██║ ██╔══██╗ ██║
        ██║ ██║ ██║ ██║  ██║ ██║  ██║ ╚██████╗
        ╚═╝ ╚═╝ ╚═╝ ╚═╝  ╚═╝ ╚═╝  ╚═╝  ╚═════╝
   ▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖▄▖
        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 three harnesses: Claude Code, 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

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 three harnesses: Claude Code (plugin under harnesses/claude-code/marc/), Google Antigravity (plugin under harnesses/antigravity/marc/), and GitHub Copilot CLI (plugin under harnesses/copilot/marc/).

Because each host tool provides different agent execution APIs, the subagent dispatch mechanism varies between harnesses. Claude Code uses the native Agent tool to dispatch subagents, Google Antigravity uses invoke_subagent, and Copilot uses the task tool with plugin custom agents (marc:*).

The leader skill @techlead dynamically inspects the available tools and maps its requests to the appropriate dispatch tool. For detailed mapping notes, refer to:

• Google Antigravity compatibility tracker
• GitHub Copilot compatibility tracker

Layout

core/                            # core specialist agent templates and leader skills
harnesses/
  claude-code/
    marc/                        # compiled Claude Code plugin
      .claude-plugin/plugin.json # plugin manifest
      skills/tech-lead/          # `@techlead` leader skill (/marc:tech-lead)
      skills/init/               # `/marc:init`, opt-in per-repo onboarding
      agents/                    # `@dev`, `@sre`, `@design`, `@sec`, `@research` shared specialist bench
      hooks/hooks.json           # SessionStart hook to inject `.agents/team.toml`
  antigravity/
    marc/                        # compiled Google Antigravity plugin
      plugin.json                # plugin manifest
      skills/                    # symlinked leader skills (e.g. `/marc:tech-lead`, `/marc:init`)
      agents/                    # symlinked specialist agents
      COMPATIBILITY.md           # compatibility tracker for Google Antigravity
  copilot/
    marc/                        # compiled GitHub Copilot CLI plugin
      plugin.json                # Copilot plugin manifest
      skills/tech-lead/          # `@techlead` leader skill
      skills/init/               # `/marc:init`, Copilot config flow
      agents/                    # `@dev`, `@sre`, `@design`, `@sec`, `@research` bench
      hooks/hooks.json           # Copilot `version: 1` hooks config
      COMPATIBILITY.md           # compatibility tracker for GitHub Copilot
docs/
  ARCHITECTURE.md                # growth model covering the different roles and harnesses
  marc/                          # durable team artifacts like decision records and research briefs
  team.toml.example
install.sh                       # installer for Claude Code

The plugin is structured so that the core logic under core/ compiles into platform-specific configurations in the harnesses/ directory. This allows the project to grow sideways into new harnesses or upward into new leader skills like founder and eng-director without restructuring the repository. Detailed growth plans are documented in ARCHITECTURE.md.

License

MIT, see LICENSE.

*** `@techlead` sets mode +v on your next idea