Every tool in its place. On every agent.

Pegboard is Configuration as Code for coding agents. Declare your MCPs, skills, and context in one file, and it writes each agent's native config. You see the plan before anything changes.

curl -fsSL https://usepegboard.dev/install.sh | sh
Read the quick start

Runs on Linux and macOS, with binaries for Windows.

Every agent keeps its tools somewhere else. Claude Code uses JSON, Codex uses TOML, Hermes uses YAML. Pegboard translates one desired state into all of them with tested code, so neither you nor your agent has to do it by hand.

pegboard.yaml
version: 1
agents: [claude-code, codex, opencode]

mcps:
  github:
    command: npx
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_TOKEN: "${env:GITHUB_TOKEN}"
  notion:
    url: https://mcp.notion.com/mcp
    agents: [claude-code]

context:
  agents_md: true
What it would change
$ pegboard plan
claude-code · project
  + mcp github                       (.mcp.json)
  + mcp notion                       (.mcp.json)
codex · project
  + mcp github                       (.codex/config.toml)
opencode · project
  + mcp github                       (opencode.json)
agents.md · project
  + context AGENTS.md                (AGENTS.md)
claude-code · project
  + context @AGENTS.md in CLAUDE.md  (CLAUDE.md)
Plan: 6 create, 0 update, 0 remove, 0 conflicts.

Ask your agent. It runs Pegboard.

Install the built-in skill once, and any of your agents can add, remove, and move tools without rewriting config files itself. It shows you the plan first, and asks you about conflicts. How the skill works

Example session in an agent
> copy my Claude Code setup to Codex and opencode
$ pegboard replicate claude-code codex opencode --scope global --dry-run
warning: secrets were replaced with ${env:…}; export: GITHUB_TOKEN, LINEAR_TOKEN
codex · global
  + mcp github    (~/.codex/config.toml) [ad-hoc]
  + mcp linear    (~/.codex/config.toml) [ad-hoc]
opencode · global
  + mcp github    (~/.config/opencode/opencode.json) [ad-hoc]
  + mcp linear    (~/.config/opencode/opencode.json) [ad-hoc]
codex · global
  + skill review  (~/.agents/skills/review → ~/.config/pegboard/skills/review) [ad-hoc]
opencode · global
  + skill review  (~/.config/opencode/skills/review → ~/.config/pegboard/skills/review) [ad-hoc]
Plan: 6 create, 0 update, 0 remove, 0 conflicts.
● This adds 2 MCPs and 1 skill to Codex and opencode. Claude Code stays as it is.
● Export GITHUB_TOKEN and LINEAR_TOKEN so they can connect. Apply it?
> yes
$ pegboard replicate claude-code codex opencode --scope global -y
Wrote ~/.codex/config.toml (backup: ~/.local/state/pegboard/backups/20261103T162621Z/home%you%.codex%config.toml)
Wrote ~/.config/opencode/opencode.json
Wrote ~/.agents/skills/review
Wrote ~/.config/opencode/skills/review
● Done. Codex and opencode now have your MCPs and your skill.
"Add the Linear MCP to all my agents"
pegboard install mcp linear=…
"Install this skill everywhere"
pegboard install skill owner/repo@skill
"Remove Notion from my agents"
pegboard uninstall mcp notion
Terminal
pegboard skill install

See what moved. Put it back.

On a workshop shadow board, every tool has a painted silhouette, so an empty spot stands out. pegboard.yaml is your silhouettes, and it works the same way.

Someone edited .mcp.json by hand
$ pegboard drift --exit-code
Managed by pegboard:
  claude-code · project  mcp github  ok (.mcp.json)
  claude-code · project  mcp notion  edited manually (.mcp.json)
  codex · project  mcp github  ok (.codex/config.toml)
  opencode · project  mcp github  ok (opencode.json)
Drift: 1 entry.
Plan what changes
pegboard plan
Shows every create, update, removal, and conflict. It writes nothing.
Apply it
pegboard apply
Writes each agent's files, and a second run changes nothing.
Catch drift
pegboard drift --exit-code
Exits with 2 when a managed file was edited, so CI can catch it.

Copy between agents

Already set up in one agent? Name it, whichever it is, then the agents that should get the same MCPs and skills. You don't need a pegboard.yaml, and the first agent doesn't change. Secrets arrive as references, and you choose whether its context goes before, after, or in place of what each agent has. See what it copies

Terminal
pegboard replicate claude-code codex opencode
pegboard replicate codex gemini --context after

Safe on your config

It leaves your edits alone
Pegboard only touches the keys, files, and links it created. Everything else in the file stays as you wrote it.
It backs up before it writes
Every file it changes is written atomically, with a copy saved in ~/.local/state/pegboard/backups.
Secrets stay out of the YAML
Reference them with ${env:NAME} or ${file:path}. If an agent can only store plain text, the plan warns you first.
Skills stay pinned
pegboard.lock records the commit and hash of each git skill. If the content changes, apply fails.

Nine agents today

All of them get MCPs and skills, each in the place that agent expects. See every path

AgentGlobal MCP configContext
Claude Code~/.claude.jsonCLAUDE.md bridge
Codex~/.codex/config.tomlAGENTS.md
opencode~/.config/opencode/opencode.jsonAGENTS.md
Hermes~/.hermes/config.yamlSOUL.md (its persona)
Pi~/.pi/agent/mcp.jsonAGENTS.md
OMP (oh-my-pi)~/.omp/agent/mcp.json.omp/AGENTS.md
OpenClaw~/.openclaw/openclaw.jsonWorkspace AGENTS.md
Cursor~/.cursor/mcp.jsonProject AGENTS.md
Gemini CLI~/.gemini/settings.jsonGEMINI.md

Skip the YAML

When you need one tool right now, ad-hoc installs get the same plan, state, and backups. To keep them, pegboard adopt moves them into pegboard.yaml.

Terminal
pegboard install mcp notion=https://mcp.notion.com/mcp
pegboard install skill mattpocock/skills@tdd
pegboard uninstall mcp notion

Share it with a team

Commit pegboard.yaml and pegboard.lock. Everyone runs pegboard apply after cloning, the same way they'd run npm install. Set up CI and policies

Read the docs

From the first install to every flag and file path. Open the docs

Questions

Every tool in its place. On every agent.

curl -fsSL https://usepegboard.dev/install.sh | sh