FastMCP FastMCP
Sign In
Back to Blog

OpenAI Launches Agent Skills for Codex — A Direct Challenge to Anthropic's MCP

• 4 views

Folks, while we were all planning our holiday breaks, OpenAI quietly dropped a bombshell: Agent Skills for their Codex platform. And you know what? This looks like a direct response to Anthropic's Model Context Protocol (MCP). But here's the kicker — OpenAI's approach might be... simpler? Let's dig in and see what's really going on here.

What Are Agent Skills and Why Should You Care

Agent Skills are OpenAI's new way to extend Codex capabilities (you know, the system behind GitHub Copilot and other OpenAI coding tools). Essentially, these are packages of instructions and resources that teach AI how to perform specific tasks.

Think about it: instead of explaining to AI how to work with your project every single time, you create a "skill" once. Then AI figures out when to apply it on its own.

The structure is dead simple:

  • SKILL.md — main file with instructions and metadata
  • scripts/ — executable code (if needed)
  • references/ — documentation
  • assets/ — templates and resources

How It Actually Works

Here's where things get interesting. OpenAI implemented what they call "progressive disclosure." Codex doesn't load all skills at once — it only sees names and descriptions. Full instructions are loaded only when a skill is actually needed.

You can activate skills in two ways:

1. Explicit invocation via commands

# Use the slash command
/skills

# Or mention a skill with $
$skill-name

2. Implicit activation
Codex decides to use a skill on its own when your task matches its description. Pretty smart, right?

Where Skills Live (And Why It's Brilliant)

OpenAI came up with a multi-level priority system for skills:

  1. REPO level — .codex/skills in current directory
  2. REPO above — ../.codex/skills (for nested projects)
  3. REPO root — at the git repository root
  4. USER level — ~/.codex/skills (personal skills)
  5. ADMIN level — /etc/codex/skills (system-wide)
  6. SYSTEM level — built into Codex

Skills with the same names get overwritten by priority. Your local skill always beats the system one. This gives incredible flexibility in configuration!

Real-World Examples

Linear Integration

Say Mike from your dev team wants Codex to understand context from Linear tasks. Easy:

$skill-installer linear

Now AI can see your tickets, understand requirements, and even update task statuses.

Working with Notion

Sarah keeps all documentation in Notion? Let's install that skill:

$skill-installer notion-spec-to-implementation

And boom — Codex reads specs directly from Notion and turns them into code.

Creating Your Own Skills

The coolest part — creating skills is ridiculously easy. Use the built-in $skill-creator:

# Just describe what the skill should do
$skill-creator "Skill for automatic React component refactoring"

Codex will create the structure itself, write instructions, and even add necessary scripts.

MCP vs Agent Skills: The Protocol Wars

Now for the juicy part. If you've already worked with MCP (like we have at FastMCP.me), you'll notice key differences:

MCP (Model Context Protocol):

  • Universal protocol for any AI system
  • JSON-RPC communication
  • Requires running separate servers
  • Works with Claude, ChatGPT, and others through connectors

Agent Skills:

  • Tailored specifically for Codex
  • Markdown-based instructions
  • No servers needed — everything works locally
  • Currently only for OpenAI's ecosystem

What This Means for Developers

Honestly? OpenAI made a smart move. Instead of creating a universal protocol (like MCP), they focused on simplicity for their ecosystem.

Agent Skills pros:

  • Incredibly easy to create and share skills
  • No infrastructure needed — works out of the box
  • Excellent git-workflow integration
  • Progressive loading saves resources

Cons:

  • Locked into OpenAI's ecosystem
  • No real-time communication like MCP
  • Less flexibility for complex integrations

FastMCP.me and the Future of AI Integrations

At FastMCP.me, we continue developing the MCP server ecosystem because we believe in open standards. But Agent Skills is an important market signal.

We'll likely see convergence of approaches:

  • Simple tasks will be solved through Skills-like systems
  • Complex integrations will remain with protocols like MCP
  • Bridges between different systems will emerge

By the way, we're already thinking about creating an MCP → Agent Skills converter. Imagine taking any MCP server from FastMCP.me and automatically getting an Agent Skill for Codex. Pretty cool, right?

Practical Implementation Tips

If you decide to try Agent Skills today:

  1. Start with built-in skills — $plan and $skill-creator will give you a feel for what's possible
  2. Create a skill for your project — describe conventions, architecture, processes
  3. Use priority levels — store common skills in the repo root, specific ones in subdirectories
  4. Version your skills — add them to git, do code reviews
  5. Combine with MCP — for tasks requiring real-time data, use MCP servers from FastMCP.me

The Bottom Line

Agent Skills from OpenAI is an elegant solution for extending AI coding tools. Sure, it's not a universal protocol like MCP, but for many tasks, its simplicity will be enough.

The big question: is this the beginning of AI integration market fragmentation? Or are we moving toward a unified standard?

My take: the market is big enough for both approaches. MCP will remain the choice for cross-platform solutions (especially with the growing server library at FastMCP.me), while Agent Skills will fill the niche of quick integrations within OpenAI's ecosystem.

P.S. By the way, if you're already using MCP servers from our catalog at FastMCP.me, don't worry — they're not going anywhere. In fact, we're actively working on a new Skills section where we'll collect ready-made skills not just for Codex, but for other AI systems too. Stay tuned!