How to Bundle Skills, MCP Config, and Integrations in Codex Plugins

Mar 27, 2026

Purpose

I used to spend 30 minutes configuring Codex for each new project. I’d add skills to one folder, set up MCP servers in a config file, and configure integrations separately. If I missed one step, nothing worked.

Codex Plugins bundle all three components together. When you install a plugin, you get skills, MCP configurations, and app integrations in one package.

This post shows how these components bundle together and why it matters.

The Problem Before Bundling

Before plugins, I configured each component separately:

1. Add skill files to ~/.claude/skills/
2. Edit ~/.claude/settings.json for MCP servers
3. Set environment variables for integrations
4. Document everything for the team

This caused issues:

I’d forget to configure an MCP server
Team members had mismatched environments
New projects required repeating the same setup
“Works on my machine” became a regular excuse

The components were related but configured independently.

What Gets Bundled

Plugins package three core components into a single unit:

Skills

Skills are reusable workflows. I use them for tasks like deploying code, running tests, or generating documentation.

---
name: deploy-web-app
description: Deploy a web application to Vercel
triggers:
  - "deploy this app"
  - "push to production"
---

You are a deployment assistant.

1. Run the build command
2. Execute tests
3. Deploy to Vercel
4. Report the deployment URL

When bundled in a plugin, skills install automatically. No manual file copying needed.

MCP Configurations

MCP servers connect Codex to external data sources like databases, APIs, or documentation.

{
  "mcpServers": {
    "context7": {
      "command": "mcp-context7",
      "args": ["--docs-path", "${DOCS_PATH}"]
    },
    "postgres": {
      "command": "mcp-postgres",
      "args": ["--connection-string", "${DATABASE_URL}"]
    }
  }
}

Inside a plugin, these MCP configurations apply when the plugin installs. Codex reads them from the plugin manifest rather than requiring manual entry in settings files.

App Integrations

Integrations connect Codex to external services like GitHub, Slack, or Vercel.

{
  "name": "vercel",
  "type": "oauth",
  "scopes": ["deployments:read", "deployments:write"],
  "baseUrl": "https://api.vercel.com"
}

When bundled, integrations include their OAuth configuration. Users authorize once instead of setting up each connection manually.

How Bundling Works

I explored a plugin’s internal structure to understand the bundling:

my-plugin/
  plugin.json           # Manifest listing all components
  skills/
    deploy-web-app.md   # Skill definition
    run-tests.md
  mcp/
    servers.json        # MCP server configs
  integrations/
    vercel.json         # Integration configs
    github.json

The manifest ties everything together:

{
  "name": "my-plugin",
  "version": "1.0.0",
  "description": "Web deployment workflow",
  "skills": ["skills/*.md"],
  "mcp": "mcp/servers.json",
  "integrations": "integrations/*.json"
}

When I install this plugin:

codex plugin install @my-org/web-deploy

Codex extracts each component and places them in the right locations:

Skills go to ~/.claude/skills/installed-plugins/my-plugin/
MCP configs merge with ~/.claude/settings.json
Integrations register in Codex’s integration store

All three components install together. No missing pieces.

Why Bundling Matters

Bundling solved three problems I faced:

Problem 1: Missing Dependencies

Before plugins, I’d install a skill and forget the MCP server it needed.

Example: A skill that queries my database required the Postgres MCP server. I’d run the skill and get an error because the MCP server wasn’t configured.

Solution: The plugin bundles both the skill and its MCP dependency. Installing the plugin sets up both.

Problem 2: Configuration Drift

My team had different versions of MCP servers and skills. We’d get different results from the same commands.

Example: My skill used context7 MCP v2.1, but my teammate had v1.9. The skill behaved differently.

Solution: Plugins version-lock their components. Everyone on the team installs the same plugin version and gets identical behavior.

Problem 3: Setup Time

New projects meant repeating the same 30-minute setup process.

Solution: One command installs everything:

codex plugin install @my-org/standard-workflow

Setup time dropped from 30 minutes to 30 seconds.

Example: A Complete Bundled Plugin

I created a plugin for my team’s web deployment workflow:

plugin.json
skills/
  deploy-production.md
  deploy-staging.md
  rollback.md
mcp/
  servers.json
integrations/
  vercel.json
  github.json

{
  "name": "deploy-workflow",
  "version": "2.3.0",
  "description": "Production deployment workflow with Vercel and GitHub",
  "skills": ["skills/*.md"],
  "mcp": "mcp/servers.json",
  "integrations": "integrations/*.json"
}

When my team installs this plugin, they get:

Three deployment skills (production, staging, rollback)
MCP servers for context access
Pre-configured Vercel and GitHub integrations

No separate configuration steps. No missing components.

Component Relationships

The three components work together:

Skill triggers
    -> Needs MCP server for data
    -> Uses Integration for action
    -> Returns result to user

Example: My “deploy-production” skill:

Uses the skill prompt to understand what to deploy
Queries MCP server (context7) for deployment documentation
Uses integration (Vercel) to execute the deployment

If any piece is missing, the workflow breaks. Bundling ensures all pieces arrive together.

Installing Bundled Components

I install a plugin once:

codex plugin install @openai/build-web-apps

Output shows what was bundled:

Installed @openai/build-web-apps v1.2.0

Skills:
  - scaffold-react-app
  - add-auth
  - deploy-vercel

MCP Servers:
  - context7

Integrations:
  - vercel
  - github

Everything the plugin author bundled is now available. I don’t check if the MCP server is configured or if the integration exists. The bundle handles it.

Creating Your Own Bundle

I created a custom plugin to bundle my team’s workflow:

Step 1: Create the Structure

codex plugin create team-workflow
cd team-workflow

Step 2: Add Skills

---
name: review-pr
description: Review pull requests against team standards
triggers:
  - "review this pr"
---

Review the PR for:
1. Test coverage
2. TypeScript strict mode
3. Security issues
4. Documentation updates

Step 3: Add MCP Configuration

{
  "mcpServers": {
    "team-docs": {
      "command": "mcp-context7",
      "args": ["--library", "/my-org/wiki"]
    }
  }
}

Step 4: Add Integrations

{
  "name": "github",
  "type": "oauth",
  "scopes": ["repo", "pull_requests:write"]
}

Step 5: Define the Manifest

{
  "name": "team-workflow",
  "version": "1.0.0",
  "skills": ["skills/*.md"],
  "mcp": "mcp/servers.json",
  "integrations": "integrations/*.json"
}

Step 6: Test and Publish

# Test locally
codex plugin install ./team-workflow --local

# Publish to registry
codex plugin publish team-workflow

My team now installs one package instead of configuring three separate components.

Common Questions

Can I use a plugin skill without the MCP server?

Technically yes, but the skill may not work properly. If a skill expects an MCP server for data, running it without that server causes errors.

This is why bundling matters: the plugin author ensures compatible versions of all components.

Can I override bundled components?

Yes. Local settings override plugin defaults:

{
  "overrides": {
    "my-plugin": {
      "mcpServers": {
        "custom-server": {
          "command": "my-custom-command"
        }
      }
    }
  }
}

Use this for local development or custom configurations.

Do all three components need to be present?

No. A plugin can include any combination:

Skills only (no MCP or integrations)
MCP only (skills defined elsewhere)
All three components

Most plugins I’ve seen include all three for complete workflows.

Summary

Codex Plugins bundle skills, MCP configurations, and app integrations into a single installable package. This solves the problem of configuring each component separately.

Key points:

Skills provide reusable workflows
MCP configs connect Codex to data sources
Integrations link to external services
Bundling ensures all components arrive together

For teams, bundling means consistent environments. For individuals, it means faster setup. For plugin authors, it means delivering complete, working solutions.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 OpenAI Codex Documentation
👨‍💻 Model Context Protocol Specification

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!