Skip to content
BSWEN
Blog

What Are OpenAI Codex Plugins and How Do They Work?

Cowrie
Cowrie
Dev @ Bswen

Purpose

Every time I started a new project with Codex, I had to configure the same things: skills, MCP servers, integrations. It took 20 minutes each time, and I’d often forget a step.

OpenAI Codex Plugins fix this problem. They bundle everything you need for a specific workflow into one installable package.

This post shows what plugins are, what they include, and how to use them.

The Problem

Before plugins, setting up Codex for a new project meant:

  1. Adding skill files to ~/.claude/skills/
  2. Configuring MCP servers in ~/.claude/settings.json
  3. Setting up environment variables for integrations
  4. Documenting the setup for team members

I did this for every project. Sometimes I’d forget to add the right MCP server. Sometimes a team member couldn’t get their environment matching mine.

The process was error-prone and time-consuming.

What Are Codex Plugins?

Codex Plugins are installable packages that bundle three things:

  • Skills: Reusable prompt templates and workflows
  • MCP configurations: Model Context Protocol server settings
  • App integrations: Connections to external tools and services

Instead of configuring each piece separately, you install one plugin and get everything.

Here’s what a plugin structure looks like:

plugin-structure
my-plugin/
  plugin.json          # Plugin metadata and config
  skills/
    my-skill.md        # Skill definition
  mcp/
    servers.json       # MCP server configurations
  integrations/
    github.json        # App integration settings

What’s Inside a Plugin?

When I explored the plugin format, I found three main components:

Skills

Skills are prompt templates that Codex can invoke. I’ve used skills for tasks like code review, test generation, and documentation.

skills/code-review.md
---
name: code-review
description: Review code for security and quality issues
triggers:
  - "review this code"
  - "check for security issues"
---


You are a code reviewer. Analyze the provided code for:
1. Security vulnerabilities
2. Performance issues
3. Code style violations


Provide specific, actionable feedback.

MCP Configurations

MCP servers let Codex connect to external data sources. A plugin can include pre-configured MCP servers.

mcp/servers.json
{
  "mcpServers": {
    "github": {
      "command": "mcp-github",
      "args": ["--read-only"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "mcp-postgres",
      "args": ["--connection-string", "${DATABASE_URL}"]
    }
  }
}

App Integrations

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

integrations/github.json
{
  "name": "github",
  "type": "oauth",
  "scopes": ["repo", "read:org"],
  "baseUrl": "https://api.github.com"
}

How to Install a Plugin

I installed my first plugin using the Codex CLI:

Terminal
# Install a plugin from the registry
codex plugin install @openai/build-web-apps


# List installed plugins
codex plugin list

I got this output:

Output
Installed plugins:
  @openai/build-web-apps (v1.2.0)
    - Skills: scaffold-react, add-auth, deploy-vercel
    - MCP servers: context7
    - Integrations: vercel, github

After installation, all the plugin’s skills became available in Codex. The MCP servers were configured automatically.

Curated Plugins

OpenAI offers curated plugins for common workflows:

Build Web Apps

This plugin packages a complete web development stack:

Terminal
codex plugin install @openai/build-web-apps

It includes:

  • React/Next.js scaffolding skills
  • Context7 MCP for documentation access
  • Vercel integration for deployment

Data Science Workflow

For data analysis projects:

Terminal
codex plugin install @openai/data-science

It includes:

  • Jupyter notebook generation skills
  • Pandas/NumPy helper prompts
  • Database MCP connectors

API Development

For building and testing APIs:

Terminal
codex plugin install @openai/api-dev

It includes:

  • OpenAPI specification generation
  • Postman integration
  • PostgreSQL MCP server

Creating Your Own Plugin

I created a custom plugin for my team’s workflow using the @plugin-creator tool.

Step 1: Initialize the Plugin

Terminal
codex plugin create my-team-workflow


cd my-team-workflow

This created the plugin structure:

Output
my-team-workflow/
  plugin.json
  skills/
  mcp/
  integrations/

Step 2: Define Plugin Metadata

plugin.json
{
  "name": "my-team-workflow",
  "version": "1.0.0",
  "description": "Custom workflow for my team",
  "author": "your-name",
  "skills": ["skills/*.md"],
  "mcp": "mcp/servers.json",
  "integrations": "integrations/*.json"
}

Step 3: Add Skills

I added a skill for our code review process:

skills/team-review.md
---
name: team-review
description: Team-specific code review checklist
triggers:
  - "team review"
---


Review the code against our team standards:
1. Check TypeScript strict mode compliance
2. Verify error handling patterns
3. Confirm test coverage > 80%
4. Check for hardcoded values


Format feedback as GitHub PR comments.

Step 4: Add MCP Configuration

mcp/servers.json
{
  "mcpServers": {
    "team-docs": {
      "command": "mcp-context7",
      "args": ["--library", "/my-team/docs"]
    }
  }
}

Step 5: Test Locally

Terminal
codex plugin install ./my-team-workflow --local


# Test the plugin
codex skill run team-review

Step 6: Publish

Terminal
codex plugin publish my-team-workflow

Why This Matters

Plugins solve three problems I faced regularly:

Configuration drift: Different team members had different setups. Plugins ensure everyone uses the same configuration.

Onboarding time: New team members spent hours setting up their environment. Now they install one plugin.

Workflow consistency: Our code review process varied by person. The plugin skill ensures the same checklist every time.

Common Questions

How do plugins differ from skills?

Skills are single-purpose prompt templates. Plugins bundle skills with MCP configurations and integrations into a complete package.

Think of it this way: a skill is a tool, a plugin is a toolkit.

Can I share plugins privately?

Yes. You can publish plugins to a private registry:

Terminal
codex plugin publish my-plugin --registry https://my-company.com/registry

Do plugins require an internet connection?

Plugins install locally. Once installed, skills and MCP configurations work offline. App integrations may require internet for API calls.

Can I override plugin settings?

Yes. Local settings in ~/.claude/settings.json override plugin defaults:

~/.claude/settings.json
{
  "overrides": {
    "my-plugin": {
      "mcpServers": {
        "custom-server": {
          "command": "my-custom-command"
        }
      }
    }
  }
}

Summary

Codex Plugins bundle skills, MCP configurations, and app integrations into shareable packages. They solve the problem of manually configuring Codex for each project.

I showed what plugins include, how to install curated plugins from the registry, and how to create your own using the @plugin-creator tool.

For teams, plugins mean consistent environments and faster onboarding. For individuals, they mean less time configuring and more time building.

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:

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

Comments

Tags: