Skip to content
The AI Agent Factory

16.10 How today's tools realize it

Approved by
Panaversity ·
62 min read

In everyday life. A shipping container is built to one international standard, so every port's cranes can lift it. But ports still differ. One unloads the standard container straight onto a truck. Another also wants its own customs form stapled to the door. A third has no crane for containers yet, so you unpack the boxes inside and carry them off by hand. The boxes inside are the same everywhere.

What you will learn. The exact folder, file, setting and command for each idea in this chapter, in Claude Code, Codex and OpenCode. Also where each product follows the standards, adds to them or leaves them out, as of November 2, 2026.

Why it matters. Lessons 16.1 to 16.9 teach what is true everywhere. To do the work, you also need the exact step in the product you use. Each product keeps it in a different place.

How to use this page. This page is a reference, not a lesson. Each lesson's Try it links to the section here that has its tool's steps. Pick your tool in any set of tabs once, and every set on this page follows. The page ends with one table of all three products, the differences that change a decision, what each costs, and a reference. Menus and commands change. If a step does not match what you see, check the linked page.

Where each fact comes from. Each fact comes from the product's own page, read on November 2, 2026, unless it says tested. Tested means it was run for this book on that date, on Claude Code 2.1.316, Codex 0.166.0 or OpenCode 2.2.5. Every Claude Code exercise here was run as a single command, not in an open session, so a session's screens may look different. Codex and OpenCode were run with no model, so their other steps follow their pages. Write down what you see.

Practice: from a prompt to a skill

The steps are in 16.1, under Try it. Where each product reads skills, and how it treats the standard:

Your folder is .claude/skills. Claude Code also reads ~/.claude/skills, folders inside other folders, a plugin's skills/ and your claude.ai account. In a session, the skill shows as a Skill tool call with its name.

Claude Code follows the Agent Skills standard. It adds fields the standard does not define: who may start a skill, context: fork to run it in a separate context, arguments and others. It relaxes one rule: name defaults to the folder's name.1 Custom commands are merged into skills, so .claude/commands/x.md and .claude/skills/x/SKILL.md both create /x.

Skills uploaded to claude.ai are strict the other way: a skill with any field outside the six is refused.

For the exam. CCDV-F and CCAR-F ask about Claude Code's own skills: where they are kept, and its own fields. Those fields are right answers about Claude Code, even though the standard does not define them.

Your folder is .agents/skills. Codex also reads .agents/skills in each folder up to the repository's root, ~/.agents/skills and /etc/codex/skills. Codex skills "build on the open agent skills standard".2 To start one yourself, type $ and pick it. To find out whether one loaded, ask the agent: "Which skill did you use?"

OpenAI adds an optional agents/openai.yaml beside SKILL.md, for display names, invocation and tool dependencies, outside the shared file. To see your skills, open Skills in the sidebar. /skills is the command in the command-line tool and the IDE extension.

Your folder is .opencode/skills. OpenCode also reads .claude/skills and .agents/skills, and any folder listed in skills in opencode.jsonc.3 Before your first message, add this opencode.jsonc to the folder, so edits and commands wait for you:

{
  "$schema": "https://opencode.ai/config.json",
  "permissions": [
    { "action": "edit", "resource": "*", "effect": "ask" },
    { "action": "shell", "resource": "*", "effect": "ask" }
  ]
}

OpenCode's version 2 pages do not name the standard, though the standard's own list of clients, the products that follow it, names OpenCode.4 It relaxes the rules: it does not enforce the naming rules or limits, takes a skill's id from its path, and ignores license and compatibility. To load a skill yourself, mention it as @vendor-terms.

Practice: commands and who may start them

The steps are in 16.4, under Try it. This section has the setting each product uses to say that only a person may start a skill.

One shared skill, three places to say only a person may start this. At the top, the shared SKILL.md, six standard fields only, never edited per product. Three arrows lead down. OpenAI: a file beside the skill, agents/openai.yaml, with policy.allow_implicit_invocation false, outside the six fields. OpenCode: inside the standard's metadata field, opencode/autoinvoke false, inside a standard field. Claude Code: an extra frontmatter field, disable-model-invocation true, added by a build step, in Claude's built bundle only. A line at the bottom says claude.ai refuses a field outside the six in an uploaded skill, so the extra field never goes in the shared file.

Figure 16.14. The person-only setting, product by product. The shared file never changes. Each product's setting lives where that product reads it.

Each product's setting:

Add this line to the skill's frontmatter. Start the skill with /vendor-terms Great Lakes Freight. The words after the name reach the body as $ARGUMENTS.

disable-model-invocation: true

Claude Code reads this setting only as an extra frontmatter field, and claude.ai refuses that field in an uploaded skill.1 No page says whether it refuses one inside an installed plugin. So a person-only skill for Claude gets the field from a build step that writes Claude's bundle, and the shared source stays at six fields.

user-invocable: false is the opposite: only Claude starts the skill.

Add agents/openai.yaml beside SKILL.md, with these lines. Start the skill with $vendor-terms, then the vendor's name.

policy:
  allow_implicit_invocation: false

The default is true. OpenAI states the effect for Codex, and no page states it for ChatGPT. So if you rely on it there, check it, and write the result in your notes.2

Add this to the skill's frontmatter, inside the standard's own metadata field, and this rule to opencode.jsonc, after the others. Start the skill with @vendor-terms, then the vendor's name.

metadata:
  opencode/autoinvoke: false
{ "action": "skill", "resource": "vendor-terms", "effect": "ask" }

The setting only hides the skill from the model's list, and it can still be loaded by its id. So the ask rule is what stops a load until you approve.3 OpenCode also follows disable-model-invocation, and when both are set, opencode/autoinvoke wins.

Practice: what a plugin bundles

The steps are in 16.5, under Try it. Your tool's tab below says how to load the plugin for one session, and how to check it.

One more thing to try: a mistake. Send: "Add a field named owner_note, with any text, to the manifest my tool reads." Run the check in your tool's tab, and read what it says. Then send: "Remove owner_note again." The unknown field is reported, and ignored when the plugin loads.

The core files follow Agent Plugins 1.0.0. plugin.json requires $schema and name. Its optional fields are version, description, author, homepage, repository, license, keywords and extensions.5 mcp.json has its own $schema, which must name the same version as plugin.json, and lists servers under mcpServers. A local server has "type": "stdio", a command and its args. A remote one has "type": "streamable-http" and a url. The specification forbids secrets in a remote server's headers.

{
  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
  "mcpServers": {
    "apdata": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem@2.1.0", "./data"]
    }
  }
}

With no cwd, the server's working directory, a conforming product starts this server in the plugin's root. So ./data here means a data folder inside the plugin. A cwd must stay inside that root. args, env and cwd can use ${PLUGIN_ROOT} and ${PLUGIN_DATA}.

How each product loads and checks a plugin:

Claude Code does not read the Agent Plugins core yet, and Claude products are not on the standard's list of compatible clients. It reads its own manifest, so send: "Add practice-plugin/.claude-plugin/plugin.json, with the same name, version and description, and no $schema."

Type this step yourself. This command starts the session the agent runs in, so you type it, in a terminal, from the repository's root. claude is a separate install, from Anthropic's quickstart. The --plugin-dir flag takes one folder or zip, and you can repeat it. A terminal session starts in Auto, so ask for Manual:

claude --permission-mode manual --plugin-dir ./practice-plugin

The plugin shows as brightline-practice@inline. Without .claude-plugin/plugin.json, its name is the folder's name.6 Start the skill with /brightline-practice:vendor-terms Great Lakes Freight.

If you use only the desktop app. Its Code tab runs its own copy of Claude Code, has no --plugin-dir, and does not offer /plugin. To load a folder there, add CLAUDE_CODE_PLUGIN_DIRS=/absolute/path/to/practice-plugin under Environment variables in a saved local environment, and start a new session from it. That variable was tested on the app's copy of Claude Code, but not through the app's own form.7 A plugin installed with claude plugin install also loads in the Code tab.

The check. Ask the agent to run these, and read what they print:

claude plugin validate ./practice-plugin
claude --plugin-dir ./practice-plugin plugin details brightline-practice@inline

Tested: validate warns "Unknown field 'owner_note'. Claude Code ignores it at load time." and passes. With --strict, the same warning makes it fail. It also lists what the plugin directory would refuse, such as a missing license, and says those checks do not change the result. details lists the skill, and the projected cost, about 60 tokens that are always loaded.

For the exam. A Claude Code plugin's manifest is .claude-plugin/plugin.json, and its connector file is .mcp.json.

Codex reads the core as it is: plugin.json at the plugin's root is its portable manifest, and connectors go in mcp.json.8 So you add no manifest. OpenAI's own settings go under extensions.com.openai in plugin.json. A .codex-plugin/plugin.json is a fallback, a second choice, that you do not need here. A plugin can also hold hooks, browser extensions and a connector's own interface, which ChatGPT shows using the open MCP Apps standard.

Codex loads an installed plugin, not a folder. So go to Practice: shipping a version, make its changelog and catalog with its Codex tab, and come back here. When you reach 16.6, start at its Predict step. Type $, and pick brightline-practice:vendor-terms (tested: Codex lists a plugin's skills with that prefix).

The check. Validate plugin.json against the published schema: ask the agent to fetch the $schema address and compare. Under the standard, a product reports an unknown top-level field and ignores it.

OpenCode does not implement Agent Plugins. An OpenCode plugin is code: an npm package or a folder of code that can add tools and commands and hook into tool calls.9 So here the "plugin" is a setup. Add the skills folder to the opencode.jsonc from the first practice, then restart OpenCode in the folder.

"skills": ["./practice-plugin/skills"]

The check. opencode debug config lists the sources it read (tested: it accepts this file). OpenCode has no manifest, so there is no field to add here. Say so in your notes.

Make a connector read-only

This is not an exercise. It is what you need when a plugin carries a connector. The lab does this with a published filesystem server, @modelcontextprotocol/server-filesystem, pinned at version 2.1.0 and limited to one folder. It has 14 tools, and four of them write: write_file, edit_file, create_directory and move_file.10 It has no read-only flag, and a plugin cannot remove the four tools. Each product's settings can. The server needs Node.js 24.

Where the connector is made read-only. At the top, the plugin's data connector, with a note that it has four write tools and the plugin cannot remove them. Arrows lead to four places, each with its own setting: Claude Code, deny rules in .claude/settings.json. Claude, Blocked in Customize, Connectors. Codex, disabled_tools in .codex/config.toml. OpenCode, deny rules in opencode.jsonc. A line at the bottom names the four write tools and says they are blocked in every place before the first request.

Figure 16.15. The same rule, set four ways. The plugin carries the connector, and each product makes it read-only.

Set the rule in each place before its first request. Then ask the connector which folders it may read, and check the answer, because each product starts a local server in a different folder.

Claude's connector file is .mcp.json, inside the plugin. It lists servers under mcpServers, as the core does. A local server starts in the folder where you started the session, so from the repository's root, ./data is the repository's data folder (tested). Start the session in another folder, and it is not.

Deny the four tools in .claude/settings.json. A plugin's own settings.json takes only agent and subagentStatusLine, so it cannot carry deny rules.11

{ "permissions": { "deny": [
  "mcp__plugin_brightline-ap_apdata__write_file",
  "mcp__plugin_brightline-ap_apdata__edit_file",
  "mcp__plugin_brightline-ap_apdata__create_directory",
  "mcp__plugin_brightline-ap_apdata__move_file"
] } }

A plugin's connector tool is named mcp__plugin_<plugin>_<server>__<tool>.12 A deny rule that names a tool removes it from what the agent sees, so the agent reports that it has no such tool (tested).13

If the connector is listed under Customize > Connectors, open it and set each write tool to Blocked under Tool permissions.14 A local connector may not list its tools there before it runs. If it does not, use Manual, and decline every write. A local connector is ignored in a browser chat.

Codex copies an installed plugin to a cache, a folder of its own, ~/.codex/plugins/cache/<catalog>/<plugin>/<version>/, and starts its local server there, as the standard says. So ./data in mcp.json finds nothing, and the server stops (tested). A full path in mcp.json works, on one computer. So does listing the server in the project's .codex/config.toml, where it starts in the project's folder (tested: the server then lists 10 of its 14 tools).

[mcp_servers.apdata]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-filesystem@2.1.0", "./data"]
disabled_tools = ["write_file", "edit_file", "create_directory", "move_file"]

For a server that stays in the plugin, the setting is this:15

[plugins."brightline-ap@brightline-openai".mcp_servers.apdata]
disabled_tools = ["write_file", "edit_file", "create_directory", "move_file"]

Both work only on local Codex hosts, in a project you trust. An untrusted project loses them without any warning.16

ChatGPT on the web does not read .codex/config.toml.17 No page shows that a ChatGPT task with no project reads a repository's file, so the write tools may still work there. Run the chat in the repository's local project, or put the same block in ~/.codex/config.toml.

Connectors go under mcp.servers in opencode.jsonc, with "type": "local" and a command list.18 "cwd": "." starts one in the project's folder. Use disabled: true to stop a server, not enabled: false.

Tested, without a model: OpenCode sends the server its own list of folders, called roots, and the server lets that list replace the folder on its command line. So here the connector can read the whole repository, not only data/, including any .env. Your write rules still stop writes. Its pages name no setting that narrows it, so write what you see in your notes.

After an allow for apdata_*, add one rule for each write tool. The last matching rule wins, so keep that order.19

{ "action": "apdata_*", "resource": "*", "effect": "allow" },
{ "action": "apdata_write_file", "resource": "*", "effect": "deny" },
{ "action": "apdata_edit_file", "resource": "*", "effect": "deny" },
{ "action": "apdata_create_directory", "resource": "*", "effect": "deny" },
{ "action": "apdata_move_file", "resource": "*", "effect": "deny" }

Practice: shipping a version

The steps are in 16.6, under Try it. Your tool's tab says how to make a catalog, install from it, and look at the installed copy again after the fix.

Claude Code calls a catalog a marketplace. Send: "Add a marketplace named practice at .claude-plugin/marketplace.json, at the repository's root, with exactly this." Then paste:

{
  "name": "practice",
  "owner": { "name": "Your name" },
  "plugins": [
    { "name": "brightline-practice", "source": "./practice-plugin", "description": "Practice plugin" }
  ]
}

Then ask the agent to run these, from the repository's root:

claude plugin marketplace add ./
claude plugin install brightline-practice@practice --scope local
claude plugin list

--scope is user (the default), project or local. Use local here: a user install turns the plugin on in every project, including ones with no deny rules for its connector.20 claude plugin details prints a plugin's projected token cost.21

Tested: list shows Version: 0.1.0 and Read from: your practice-plugin folder. After the fix it shows 0.1.1 at once. That is because a local catalog or --plugin-dir loads the current files at every session start, whatever the version says.22

A catalog in a Git repository is different. Each person stays on a cached copy until the version changes, so a pushed change with no new version never arrives. The copy moves when someone runs claude plugin update brightline-practice@practice, or when auto-update is on. Auto-update is off by default for your own catalog, and on for Anthropic's official marketplaces and for marketplaces added from claude.ai. An admin can set it for everyone.23 A running session keeps the version it loaded, until /reload-plugins or the next session.24

Values the plugin asks for. Claude Code asks for userConfig values when you install through /plugin in a session. --plugin-dir and claude plugin install do not ask, and an option's default applies. To see or change them later, use claude plugin configure brightline-ap@brightline (Claude Code 2.1.285 or later), or /plugin configure in a session.

Clean up. Ask the agent to run these (tested, and the scope is needed):

claude plugin uninstall brightline-practice@practice --scope local
claude plugin marketplace remove practice

A catalog on claude.ai is a GitHub repository, so you can do this exercise once you have pushed one. After a new version syncs from the source, it reaches your account automatically, with nothing to accept. You can also choose Check for updates, or turn on Sync automatically.25

An organization has its own way. Re-sync, or a push to the default branch with Sync automatically on, brings in a new version. Nothing syncs on a schedule, and a tag by itself releases nothing.26 Setting a plugin to Not available stops it for every member, including those who had it installed.27

OpenAI says to always include name, source, policy.installation, policy.authentication and category on an entry.8 Send: "Add a catalog named practice-openai at .agents/plugins/marketplace.json, at the repository's root, with exactly this." Then paste:

{
  "name": "practice-openai",
  "plugins": [
    {
      "name": "brightline-practice",
      "source": { "source": "local", "path": "./practice-plugin" },
      "policy": { "installation": "AVAILABLE", "authentication": "ON_INSTALL" },
      "category": "Productivity"
    }
  ]
}

These commands need the Codex command-line tool, which has its own install page.28 Ask the agent to run them, or type them yourself in a terminal, from the repository's root:

codex plugin marketplace add ./
codex plugin add brightline-practice@practice-openai
codex plugin list

Trust the project when Codex asks. Restart the ChatGPT desktop app, so it sees the catalog, and start a new chat.

Tested, without a model: list shows 0.1.0, and the copy it reads is in ~/.codex/plugins/cache/. After the fix it still shows 0.1.0, because Codex copied the plugin to that cache. Running codex plugin add again moves it to 0.1.1. Then restart the ChatGPT desktop app, as OpenAI says to do for a local catalog. For a catalog in a Git repository, run codex plugin marketplace upgrade.8

Codex also reads Claude's catalog path, which OpenAI calls legacy-compatible, so a repository that serves both keeps two catalog files, with different names. With both present, Codex uses .agents/plugins/marketplace.json (tested). With only Claude's, codex plugin marketplace list shows that catalog's name.

Clean up after the Try it in 16.7, which uses this catalog. Ask the agent to run these, or type them yourself (tested):

codex plugin remove brightline-practice@practice-openai
codex plugin marketplace remove practice-openai

A workspace admin imports a catalog from GitHub. New catalogs check for updates daily, and Sync now under Admin > Plugins > Marketplaces asks at once. A fixed commit keeps the version you selected. If an update is invalid, the plugin keeps its last working version.29

OpenCode has no catalog for a bundle like this one. Your skills list names a folder, so it reads that folder's current files, and a git pull is how a new version arrives. Nothing checks the version for you. Plugins, which are code, come from npm, Git or a local folder, and opencode plugin add, list, check, update and remove manage them. OpenCode can also read skills from an HTTP catalog, a base address with an index.json. You raise an entry's version so it refreshes its copy.3

Clean up after the Try it in 16.7, which uses it: remove the skills line from opencode.jsonc.

Practice: one skill, three bundles

The steps are in 16.7, under Try it. Choose one place below that you have not used yet. Plugins on claude.ai need a paid plan.

Use it as in Practice: what a plugin bundles. A plugin installed on claude.ai also downloads to Claude Code when you next start a session signed in to that account. Run /reload-plugins to load it. A coding agent in a folder loads nearly everything, as the table in Product reference shows.

  1. In claude.ai, open Customize > Plugins, then Add. Choose Add marketplace for a GitHub repository, or Upload plugin for a zip of the practice-plugin folder, which your agent can make. The folder must contain .claude-plugin/plugin.json, which the Claude Code tab in Practice: what a plugin bundles adds. It must not have a top-level bin/ folder.25 Connecting GitHub is needed only for a private repository.
  2. Install brightline-practice.
  3. Turn on Code execution and file creation in Settings > Capabilities, so a skill's scripts can run. In a chat, a skill's folder is copied into the code execution sandbox.30

Plugins on claude.ai need a Pro, Max, Ultra, Team or Enterprise plan.

On accounts with the new Claude experience, chat and tasks are one conversation, with no mode to choose, so the lab's six places are five there.31 A task can start a local connector only on your computer. Since October 6, 2026, new tasks on Pro, Max and Ultra run in the cloud, and no setting changes that. Anthropic's pages differ on whether a cloud task can reach a local connector, so keep the desktop app open, and record what happens. Team and Enterprise can run local sessions.32 Accounts not moved over still have a mode called Cowork. A task does not ask for userConfig values, so a folder option needs its default.

Use the catalog from Practice: shipping a version, and open the repository in the ChatGPT desktop app's Codex view, in Ask for approval mode. Type $, and pick brightline-practice:vendor-terms. $plugin-creator creates the first files of a new plugin, but it writes the .codex-plugin/ fallback, which you do not need here.8

  1. After adding a catalog on this computer, restart the ChatGPT desktop app. Open Customize > Plugins, in Work if you still see that switch, and choose your catalog as the source.33 A workspace admin can instead import a GitHub catalog: Admin > Plugins > Add > Import marketplace.29
  2. Install the plugin, and start a new chat. A plugin with a local connector needs a chat that runs locally.34
  3. Type @ to pick the skill.

OpenAI's pages say Work, its name for longer tasks, can run code and shell commands, so expect a skill's script to run in a task. No page says so for a quick answer. Plugin hooks do not run in a task in the cloud.35

Keep "skills": ["./practice-plugin/skills"] in opencode.jsonc, and restart OpenCode in the folder. A skill with an ask rule prompts you when it loads. Then send the request.

Practice: watching it run

The steps are in 16.8, under Try it. Your tool's tab says how to export telemetry for one run.

To read a connector's part of a trace, use OpenTelemetry's MCP conventions. At Development status on November 2, 2026, they name a connector call's span {mcp.method.name} {target}, such as tools/call list_directory. Its attributes include mcp.method.name and gen_ai.tool.name, and error.type when the call fails. Trace context travels as traceparent in the request's params._meta.36 No product here says it follows these conventions.

An interactive session prints none of this to its screen (tested), so use a one-shot run, and save what it prints to a file. A repository's settings cannot turn telemetry on, so set the variables for one command only.37 Send:

Run claude -p "What terms do we have with Scioto Office Products?" --plugin-dir ./practice-plugin --allowedTools "Bash(npm run vendors *)", and save everything it prints to out/telemetry-1.txt. Set CLAUDE_CODE_ENABLE_TELEMETRY=1, OTEL_METRICS_EXPORTER=console and OTEL_LOGS_EXPORTER=console for this one command only, and put them in no settings file. Then search the file for plugin_loaded, skill_activated, cost.usage and token.usage, and show me each record's plugin.name and skill.name, and the run's cost.

Every record carries your email address and account ids. out/ is ignored by git, so the file stays out of the repository. Do not share it. Then send the same request with OTEL_LOG_TOOL_DETAILS=1 added, saving to out/telemetry-2.txt. That setting also logs Bash commands and tool input, so use it only on made-up data. Never set the variables that log prompts, replies or tool content.

Tested: the events include claude_code.plugin_loaded, skill_activated, api_request, tool_decision and tool_result, with the metrics claude_code.cost.usage and claude_code.token.usage. The first run shows plugin.name: "third-party", and skill.name: "custom_skill" on skill_activated. The second shows brightline-practice and brightline-practice:vendor-terms, and plugin_loaded then also carries plugin.version, so the log says which version loaded.

Codex exports OpenTelemetry events, set in [otel] in your user config, never the project's, and log_user_prompt is off by default. They carry no plugin name. One metric, skill.injected, names the skill. The export does not cover ChatGPT tasks on the web.16

OpenCode's version 2 pages document no telemetry, so there is nothing to turn on. Write that in your notes.

Practice: installing is a trust decision

The steps are in 16.9, under Try it. Your tool's tab says how to list the plugins you have. Any hook, script or local connector in a plugin you did not write needs its own line in your notes.

claude plugin list shows each plugin and where it is read from. claude plugin details <plugin> lists its parts and its cost. Mods are plugins that change how Claude Code looks and behaves.38 Hooks, monitors, MCP and LSP servers, and mod processes run outside the sandbox, with your rights.39

Marketplaces come in three levels: official, community and third-party. To publish in the directory, use claude.ai/directory/manage, Submit new, Plugin bundle, on a paid plan. Every version gets automated validation and a security scan, and a person reviews each new listing. The source repository must be public.40 Review does not cover a marketplace address or an upload. An organization Owner can make each plugin unavailable, available, installed by default or required.27

codex plugin list shows each plugin. An installed copy is under ~/.codex/plugins/cache/. To publish, use OpenAI's plugin submission portal, after verification. Every plugin must complete OpenAI's review. Remote connectors need a stable public HTTPS address, and plugins with lifecycle hooks are not accepted.41 A workspace admin can import plugins from a GitHub catalog and control their install settings.29

opencode plugin list shows plugins, and .opencode/plugins/ holds local ones. An OpenCode plugin runs inside OpenCode with your rights, and its pages describe no sandbox for it. Treat installing one as running a stranger's program.42 Its version 2 pages name no curated directory.

The three products at a glance

Four open standards are behind this table. Agent Skills was first developed by Anthropic and released as an open standard.43 Agent Plugins is at version 1.0.0, and people from Amazon, Cursor, Microsoft, OpenAI and Vercel steer it.44 ChatGPT and Codex are on its list of compatible clients, and so is OpenClaw, another open-source agent this book covers.45 OpenTelemetry defines how running software reports what it did, and the Model Context Protocol (MCP) defines connectors, which Chapter 17 teaches in full.

AnthropicOpenAIOpen source (OpenCode version 2)
Reads Agent SkillsYes. Claude Code adds its own fields. An upload to claude.ai may use only the sixYes. Adds an optional agents/openai.yaml beside SKILL.mdYes, loosely. Does not enforce the rules, and adds settings inside metadata
Person-only settingdisable-model-invocation: true in the frontmatterpolicy.allow_implicit_invocation: false in agents/openai.yaml, stated for Codexmetadata.opencode/autoinvoke: false, with a skill rule of ask to stop a load by id
Reads the Agent Plugins coreNo support found. Uses its own .claude-plugin/plugin.jsonYes. plugin.json at the root is its portable manifestNo support found. A plugin is code, so you use settings in opencode.jsonc
Connector file.mcp.jsonmcp.json, from the coremcp.servers in opencode.jsonc
Makes a connector read-onlyDeny rules in .claude/settings.json, or Blocked in claude.ai's connector settingsdisabled_tools in .codex/config.toml, on local hosts in a trusted projectdeny rules in opencode.jsonc
Catalog.claude-plugin/marketplace.json.agents/plugins/marketplace.jsonnpm, Git or a local folder for plugins, and an HTTP catalog for skills
Where it runsClaude Code, and the Claude app's conversation, where chat and tasks may be oneChatGPT and CodexOpenCode, in the terminal and on the desktop
How a new version reaches an installed copyClaude Code: claude plugin update, or auto-update, off by default for your own catalog. A local catalog loads the current files. claude.ai: synced automatically once the source updatescodex plugin marketplace upgrade, and a restart for a local catalog. A workspace checks daily, and has Sync nowA skills list reads the current folder. An HTTP catalog refreshes when version rises
Curated directoryYes. Reviewed, with a security scanYes. Reviewed, and refuses plugins with hooksNone found
TelemetryOpenTelemetry metrics and events, with plugin and skill names. Traces in betaOpenTelemetry events, with no plugin names found, and one metric that names the skillNone documented

Each cell comes from the product's own page, as the start of this page says. "No support found" and "None found" mean a search of those pages found nothing, not that the feature is impossible.

The differences that change a decision

Measured against the standards, not against each other.

  1. The skill travels and the bundle does not, yet. All three read Agent Skills, with claude.ai the strictest and OpenCode the loosest. Only OpenAI reads the Agent Plugins core today. So you keep one set of skills and, for now, a Claude manifest beside the core and an OpenCode setup beside that.
  2. Each product keeps its person-only setting in a different place. OpenAI reads it from a file beside the skill, and OpenCode from inside the standard's metadata field, so the shared SKILL.md keeps its six fields. Claude Code reads it only as an extra frontmatter field, so that field comes from a build step.
  3. Hooks and local connectors travel least. Claude chat runs neither, a cloud ChatGPT task runs no plugin hooks, and OpenAI's directory refuses plugins with hooks. A plugin with no hooks, whose skills carry their own scripts, works in the most places.
  4. The product makes a connector read-only, never the plugin. All three do it in their own settings, in their own syntax.
  5. A local connector reads a different folder in each product. Claude Code starts it in your session's folder. Codex starts it in its cached copy of the plugin. OpenCode gives it the whole project. So the same relative path can reach your data in one, nothing in another, and more than you meant in the third.
  6. A new version reaches each place differently. claude.ai syncs it for you, Claude Code and Codex wait for an update or a restart, and Claude Code reads a local catalog's current files at the next session. So nobody can assume two copies match. A copy has to say which version it is.
  7. Only the curated directories are reviewed. A catalog file in your own repository, and an npm package, are reviewed by no one but you.
  8. Telemetry differs most. Only Claude Code names the plugin in its records, and hides third-party names until you ask. None says it follows OpenTelemetry's MCP conventions.

What stays the same on every product?

Three things do not change, whichever product you use.

  1. A skill is plain instructions and files you can read. Whichever product loads it, its numbers come from tested code, and what it may do is set by the product's permissions, not by its words.
  2. A bundle written to an open standard moves to any product that implements it. Each product's extras stay in its own extension, or in its own files beside the core.
  3. Telemetry exported to the open standard can go to any collector, and it shows what ran, never whether it was right.

What it costs

Claude Code comes with the Pro, Max, Ultra, Team and Enterprise plans, or a Console account. The Free plan does not include it.46 Plugins on claude.ai need one of the same five plans.47 claude plugin eval runs count toward your plan or API bill.

Codex comes with a ChatGPT plan. The plugin directory is on every plan. Installing or using a plugin depends on plan, workspace, role and surface.48 OpenAI's plan table shows plugins on Plus, Pro, Business and Enterprise or Education.49

OpenCode is free under the MIT license, at version 2.2.5 on October 30, 2026.50 The tool is free, but you pay for the model you connect. Install version 2 with npm install -g @opencode/cli, or from https://opencode.ai/v2/install. The older opencode-ai package is still version 1.

Product reference

The detail behind the table above. You do not need it for a Try it. Keep it for when a step in the lab names a field, a command or a limit.

Skills. Frontmatter fields beyond the six: disable-model-invocation (only you start it), user-invocable: false (only Claude does), arguments, context: fork, hooks and paths. Skills also have dynamic context injection. name defaults to the folder's name. Skills are kept in ~/.claude/skills/, .claude/skills/, folders inside other folders, plugins (started as /plugin-name:skill-name) and your claude.ai account. Each skill's description plus when_to_use is cut at 1,536 characters in the skill list. ${CLAUDE_SKILL_DIR} is the skill's folder.1

Plugin manifest. .claude-plugin/plugin.json, optional. Fields include name, version, description, author, homepage, repository, license, keywords, dependencies and userConfig. Components include skills, commands, agents, hooks, .mcp.json, LSP servers, output styles, themes, monitors, workflows and mods. A userConfig option has a type (string, number, boolean, directory, file), a title and a description, and may have required, default, sensitive and limits. Sensitive values go to the system's secure credential store.11

Commands. claude plugin init, install, uninstall, enable, disable, update, list, details, configure, prune, eval, tag, test, validate, and marketplace add, list, remove, update.6 claude plugin eval runs test cases in isolated sessions with only the plugin loaded, and compares them with a run without it. It needs Claude Code 2.1.269 or later, and it runs from the plugin's root.51 Claude Marketplace at claude.com/marketplace is a different place from these catalogs.

Telemetry. Events: claude_code.plugin_installed, plugin_loaded, skill_activated, hook_registered, hook_execution_start, hook_execution_complete, hook_plugin_metrics (official marketplace only) and mcp_server_connection. Metrics include claude_code.cost.usage and claude_code.token.usage. Attributes include skill.name, plugin.name, plugin.version and marketplace.name (official only on cost and token records). Telemetry for tasks on Team and Enterprise is set in the admin console.37

What each surface loads.52

ComponentChatA task (Cowork)Claude Code
SkillsLoadsLoadsLoads
CommandsLoads as a skillLoads, as /plugin-name:commandLoads
Agents and hooksIgnoredLoadsLoads
Remote connectorWorks once connectedConnect it from the Connectors tabLoads
Local connectorIgnoredLoads when the session runs on your computerLoads
Connector using ${user_config.*}Ignored when the address holds itIgnored when an option has no defaultLoads, with the option's default
A top-level bin/ folderPlugin cannot be installedCannot be installedLoads
LSP servers, output styles, themes, settingsIgnoredIgnoredLoads

On Pro, Max and Ultra, new tasks run in the cloud (October 6, 2026), so check the local connector row on your own account. Limits: 25 added marketplaces, 5,000 files and 200 MB per plugin.

Plugin layout. plugin.json (Agent Plugins) at the root, skills/<name>/SKILL.md, mcp.json with a type per server, .app.json for registered connectors, hooks/hooks.json, assets/. .codex-plugin/plugin.json is a fallback, and extensions.com.openai replaces it when present. $plugin-creator in Codex, or @plugin-creator in ChatGPT, creates the first files of a plugin and writes the fallback file.8

Skills. agents/openai.yaml holds interface (display name, icons), policy.allow_implicit_invocation (default true) and dependencies.tools.2 In .codex/config.toml, disabled_tools is applied after enabled_tools.

Skills. From .opencode/skills, .claude/skills and .agents/skills, in the project and globally, plus a skills list. A skill permission rule allows, asks or denies each one.

Plugins. The plugins list in opencode.jsonc, .opencode/plugins/, and opencode plugin add, list, check, update, remove. A plugin can hook tool calls, permission checks and shell commands, add tools and commands, and change agents.42

Connectors. Under mcp.servers, with "type": "local" and a command list, or "type": "remote" and a url, and disabled to stop one.18

Building Skills and Plugins with Coding Agents

Question 1 / 8

0 answered

In Claude Code, which frontmatter field makes a skill start only when a person invokes it?

  1. Extend Claude with skills, Anthropic.↑↑2↑3
  2. Build skills, OpenAI.↑↑2↑3
  3. Skills, OpenCode.↑↑2↑3
  1. Agent Skills, Client Showcase.↑
  2. Agent Plugins, Specification.↑
  3. Plugin commands reference, Anthropic.↑↑2
  4. Desktop application, Anthropic.↑
  5. Package your plugin, OpenAI.↑↑2↑3↑4↑5
  6. Plugins, OpenCode.↑
  7. @modelcontextprotocol/server-filesystem 2.1.0 README, npm.↑
  8. Plugin manifest reference, Anthropic.↑↑2
  9. Connect Claude Code to tools via MCP, Anthropic.↑
  10. Configure permissions, Anthropic.↑
  11. Get started with connectors, Anthropic.↑
  12. Configuration reference, OpenAI.↑
  13. Advanced configuration, OpenAI.↑↑2
  14. Model Context Protocol, OpenAI.↑
  15. MCP servers, OpenCode.↑↑2
  16. Permissions, OpenCode.↑
  17. Install and manage plugins, Anthropic.↑
  18. Measure plugin cost and usage, Anthropic.↑
  19. Host and maintain a marketplace, Anthropic.↑
  20. Manage Claude Code plugins for your organization, Anthropic.↑
  21. Plugin loading reference, Anthropic.↑
  22. Plugins, Anthropic.↑↑2
  23. Roll out a plugin to your whole organization, Anthropic.↑
  24. Manage plugins for your organization, Anthropic.↑↑2
  25. Codex CLI, OpenAI.↑
  26. Import and sync plugins from GitHub, OpenAI.↑↑2↑3
  27. Create custom skills, Anthropic.↑
  28. Claude Cowork and chat are one Claude, Anthropic.↑
  29. Use Claude Cowork on web, desktop, and mobile, Anthropic.↑
  30. Get started with ChatGPT Work, OpenAI.↑
  31. Submit desktop-only plugins, OpenAI.↑
  32. Plugins, OpenAI.↑
  33. OpenTelemetry, Semantic conventions for MCP.↑
  34. Monitoring, Anthropic.↑↑2
  35. Mods, Anthropic.↑
  36. Plugin security and trust, Anthropic.↑
  37. Publish to the directory, Anthropic.↑
  38. Upload and submit your plugin, OpenAI.↑
  39. Server plugins, OpenCode.↑↑2
  40. Agent Skills, home page.↑
  41. Agent Plugins, home page.↑
  42. Agent Plugins, Compatible clients.↑
  43. Advanced setup, Anthropic.↑
  44. Use plugins in Claude, Anthropic.↑
  45. Plugins in ChatGPT, OpenAI.↑
  46. Pricing, OpenAI.↑
  47. Changelog, OpenCode.↑
  48. Test plugins with evals, Anthropic.↑
  49. Plugin feature support across platforms, Anthropic.↑
Owner
Panaversity