WordPress 7.0 and 7.1 do not ship an MCP server in core. What core gives you is the Abilities API (added in WordPress 6.9) and an AI Client. The MCP part comes from the official MCP Adapter plugin (version 0.7.1 at the time of writing), and for local work from two Playground and Studio tools: the Playground MCP server and the WordPress Studio MCP server. This guide shows how to wire an AI coding agent to each of them, and how to keep the agent on a throwaway site instead of your production one.
We checked every command, version and flag below on 15 November 2026 against the project repositories, the npm registry and the WordPress.org plugin API. We did not run the npx and install commands on a test machine for this refresh, so treat the setup lines as verified against documentation, not as a recorded run. Where the guide gives a number or a version, it names the source.
Correction to the earlier version of this post. It named two packages, @wp-playground/mcp-server and @wordpress/plugin-directory-mcp, and a set of tools called playground_create, playground_install_plugin, playground_run_cli and playground_screenshot. We checked the npm registry on 15 November 2026 and neither package exists (both return 404), and none of those tool names appear in the Playground source. The real package is @wp-playground/mcp. If you copied the old config, replace it with the one below.
Does WordPress 7 have an MCP server?
No. We listed the WordPress 7.1 source tree (src/wp-includes in the wordpress-develop repository) and found the Abilities API and the AI Client files, with no MCP code, and a code search for the adapter’s main class returned nothing. WordPress 7.0 “Armstrong” came out on 20 May 2026 and 7.1 “Mary Lou” on 19 August 2026; the current stable release is 7.1.4. A proposal to merge adapter code into core is under discussion in the adapter repository, but nothing is scheduled that we could confirm.
The pieces fit together like this:
Piece | What it is | Where it runs | Status on 15 Nov 2026 |
|---|---|---|---|
Abilities API | Core functions such as | Inside WordPress | In core since 6.9; a |
MCP Adapter | A plugin and Composer package that turns public abilities into MCP tools, over HTTP or STDIO | Inside WordPress | Version 0.7.1 (16 Oct 2026), requires WordPress 6.9 and PHP 7.4 |
Playground MCP server | A Node process, | Your computer plus a browser tab | Version 3.1.64 on npm (modified 10 Nov 2026) |
Studio MCP server | The | Your computer | Studio CLI package |
If you only want an agent to read and change a live site, the adapter is the route, and we cover its ways of connecting in Four Ways to Connect an AI Agent to WordPress, and How to Pick One. This post is about the other half: doing the risky work somewhere that does not matter.
What is a safe loop for an AI agent working on WordPress?
A safe loop keeps the agent on a disposable copy until a human has read the result. The agent never holds credentials for production, and anything it produces reaches production only as a diff you review and deploy yourself.
- Start from a disposable site. A Playground site, a Studio site or a wp-env site. Pick one that you can delete without a backup.
- Give the agent only that site. Connect the MCP server for the sandbox. Do not add an Application Password for a live site to the same agent session.
- Let it write and test there. It edits the plugin or theme, runs WP-CLI or PHP in the sandbox and reports what it saw.
- Gate the code. Run PHPCS, PHPStan and your tests outside the agent’s say-so. We describe that gate in WordPress + Claude Code: A Real Developer’s Workflow.
- Review and ship by hand. You read the diff and deploy through your normal route. The agent has no deploy key.
Two details make this hold in practice. First, most MCP clients prompt before each tool call; keep those prompts on for any tool that writes, and read the tool name before you approve. Second, a sandbox that is easy to rebuild removes the temptation to “just try it on staging”. A Blueprint (below) makes rebuilding a one-line command.
How do I connect an AI coding agent to WordPress Playground with MCP?
Add the Playground MCP server to your agent, then open the Playground URL the agent gives you. The server talks to your agent over STDIO and to a Playground tab in your browser over a local WebSocket, so the site you are driving is a real, visible Playground site, not a headless one.
For Claude Code, the Playground docs give this command:
# checked on 15 Nov 2026 against the WordPress Playground docs (not run here)
claude mcp add --transport stdio --scope user wordpress-playground -- npx -y @wp-playground/mcpFor Codex the equivalent is codex mcp add wordpress-playground -- npx -y @wp-playground/mcp. If you prefer a config file, the same server entry works in a project .mcp.json for Claude Code, or in claude_desktop_config.json for Claude Desktop:
{
"mcpServers": {
"wordpress-playground": {
"command": "npx",
"args": ["-y", "@wp-playground/mcp"]
}
}
}Then connect:
- Restart the agent if it does not pick up the new server.
- Ask it: “Open WordPress Playground and connect it to the MCP server.”
- Open the URL it returns in your browser. The URL carries an
mcp-portparameter that tells the tab which local port to dial. - Ask the agent to list the connected sites and tell you the active one before it changes anything.
Playground’s documentation says the default URL starts a temporary site. To attach to a saved site such as Personal Playground, pass --url=https://my.wordpress.net/ as an extra argument after @wp-playground/mcp.
What can the agent do once it is connected?
The tool list in the Playground source (checked on 15 November 2026) is smaller and more concrete than most write-ups suggest. It covers running PHP, making authenticated requests, working with files and managing which site is active:
Group | Tools | Use it for |
|---|---|---|
Run code and requests |
| Run PHP inside the site, or call a page or REST route as the logged-in admin |
Browse |
| Open an admin screen, follow a redirect, report where the tab ended up |
Files |
| Edit a plugin or theme inside the virtual filesystem |
Sites |
| Pick the site, name it, save it to browser storage |
| Check what the site tried to send |
There is no tool to create a WordPress instance with a chosen version, no plugin installer and no screenshot tool in that list. For versions and plugin installs you pass a Blueprint in the URL or use the CLI, covered next. Inside a running site the agent can still run PHP with playground_execute_php, including code that installs or changes plugins, which is exactly why that site should be disposable.
A related feature is worth knowing: the Playground website also supports WebMCP, a browser proposal that exposes tools through document.modelContext. A plugin running inside Playground can register its own tools there, and Playground re-advertises them. The README marks WebMCP as a draft that is not widely supported, and tools vanish on every navigation unless you register them on both wp_head and admin_head. We cover the concept in webMCP: When Your Website’s Next Visitor Is an AI Agent.
When should I use the Playground CLI instead of the MCP server?
Use the CLI when the job is automation: mounting your plugin from disk, rerunning the same Blueprint, or testing a version matrix. The Playground documentation says as much: MCP is best when the site and browser state matter, and the CLI is simpler for terminal agents that need local automation.
The CLI package is @wp-playground/cli, version 3.1.64 on npm (modified 10 November 2026). It needs Node.js 20.18 or newer and defaults to the latest WordPress and PHP 8.3. These are the commands from its README, checked on 15 November 2026:
# checked on 15 Nov 2026 against the @wp-playground/cli README (not run here)
# Start a site for the project in the current folder; detects plugin, theme or wp-content,
# keeps the site between runs and opens the browser
npx @wp-playground/cli@latest start
# Pin versions
npx @wp-playground/cli@latest start --wp=6.8 --php=8.4
# Low-level server: mount the current plugin or theme automatically
npx @wp-playground/cli@latest server --auto-mount
# Or mount a folder by hand
npx @wp-playground/cli@latest server --mount=.:/wordpress/wp-content/plugins/my-plugin
# Run a Blueprint
npx @wp-playground/cli@latest server --blueprint=./blueprint.json
# Run a Blueprint without starting a web server, or build a site snapshot ZIP
npx @wp-playground/cli@latest run-blueprint --blueprint=./blueprint.json
npx @wp-playground/cli@latest build-snapshot --blueprint=./blueprint.jsonstart and server differ in who is in control. start detects your project and persists the site. server uses temporary directories unless you mount storage yourself, which is what you want in CI or for an agent that should leave nothing behind. The default port is 9400 when it is free.
A Blueprint is a JSON file that describes the site. This small one logs in, installs the MCP Adapter plugin from WordPress.org and lands on the plugins screen. We kept it to steps that appear in the Playground Blueprint docs, but we did not run it for this refresh:
{
"$schema": "https://playground.wordpress.net/blueprint-schema.json",
"landingPage": "/wp-admin/plugins.php",
"preferredVersions": { "php": "8.3", "wp": "latest" },
"steps": [
{ "step": "login" },
{
"step": "installPlugin",
"pluginData": { "resource": "wordpress.org/plugins", "slug": "mcp-adapter" },
"options": { "activate": true }
}
]
}The adapter’s own README links a one-click Playground demo built from a Blueprint, which is a fast way to see the adapter’s tools without installing anything on your machine.
How do I connect an agent to WordPress Studio with MCP?
Install the WordPress Studio CLI, then add studio mcp as an MCP server. Studio is a free desktop app and CLI from Automattic that runs local sites on a native PHP runtime, and its MCP server lets an agent create, start, stop and inspect those sites. The agent can also work with WordPress.com sites if you are logged in, so check which site it targets before you let it write.
# checked on 15 Nov 2026 against the WordPress Studio docs (not run here)
# Install the CLI (any one of these)
npm install -g wp-studio
curl -fsSL https://wordpress.studio/install.sh | bash # macOS and Linux
# Verify
studio --help
# Connect an agent
claude mcp add wordpress-studio -- studio mcp
codex mcp add wordpress-studio -- studio mcpThe JSON form for other clients is a server entry with command set to studio and args set to ["mcp"]. Studio’s Settings screen also has an MCP page with a Connect button for Claude Code, ChatGPT, Cursor and Grok Build, and a plugin route for Claude Code and Codex (claude plugin marketplace add Automattic/studio-plugins then claude plugin install wp-studio@studio). Claude Code runs that plugin on Node.js 22 or later.
Two Studio behaviours are worth knowing. The agent calls a studio_instructions tool before its first WordPress task, so Studio’s rules load on demand instead of filling every conversation. And Studio tags tools as read-only or local-only so clients like Codex skip approval prompts for them. The second point saves clicks and removes a safety net, so check which tools now run without a prompt. Also note that the older studio site create form is deprecated in favour of studio create.
Studio suits an agent that builds a whole site or a theme from scratch. Playground suits quick, disposable checks. wp-env suits a team that wants Docker and PHPUnit. We compare the three as local runtimes in the Claude Code workflow post linked above.
How does the MCP Adapter expose a live WordPress site to an agent?
The MCP Adapter bridges the Abilities API and the Model Context Protocol. It is a WordPress.org plugin and a Composer package. On WordPress.org it shows version 0.7.1, last updated 16 October 2026, more than 70,000 active installs, tested up to 7.1.4, requiring WordPress 6.9 and PHP 7.4. It has a single rating at the time of writing, so there is not enough review data to judge from stars.
Abilities are private by default. You opt one in with meta.public set to true (an explicit meta.mcp.public overrides it for MCP only). A client then reaches public abilities through the default server’s three meta-tools: mcp-adapter/discover-abilities, mcp-adapter/get-ability-info and mcp-adapter/execute-ability. Here is a read-only ability that follows the core registration rules. We ran php -l on it (PHP 8.5.5); it needs a WordPress install to execute:
<?php
// checked on 15 Nov 2026 against wp-includes/abilities-api.php (WordPress trunk)
add_action( 'wp_abilities_api_categories_init', function () {
wp_register_ability_category(
'site-reading',
array(
'label' => __( 'Site reading', 'my-plugin' ),
'description' => __( 'Read-only abilities for agents.', 'my-plugin' ),
)
);
} );
add_action( 'wp_abilities_api_init', function () {
wp_register_ability(
'my-plugin/count-drafts',
array(
'label' => __( 'Count draft posts', 'my-plugin' ),
'description' => __( 'Returns how many draft posts exist.', 'my-plugin' ),
'category' => 'site-reading',
'output_schema' => array(
'type' => 'object',
'properties' => array(
'drafts' => array( 'type' => 'integer' ),
),
),
'execute_callback' => function () {
$counts = wp_count_posts( 'post' );
return array( 'drafts' => (int) $counts->draft );
},
'permission_callback' => function () {
return current_user_can( 'edit_posts' );
},
'meta' => array(
'public' => true,
'annotations' => array(
'readonly' => true,
),
),
)
);
} );
Three points about that code come straight from the core docblocks. The category must be registered on wp_abilities_api_categories_init before the ability that uses it, or registration fails. Abilities register on wp_abilities_api_init. And meta.public only exists from WordPress 7.1; on 6.9 and 7.0 the adapter still honours it for MCP, but REST access needs meta.show_in_rest set separately.
There are two ways in. Over STDIO, WP-CLI serves the default server for a local agent:
# checked on 15 Nov 2026 against the adapter CLI usage guide (not run here)
wp mcp-adapter list
wp mcp-adapter list --protocol=2026-07-28
wp mcp-adapter serve --user=adminOver HTTP, point a client at /wp-json/mcp/mcp-adapter-default-server on the site, with an Application Password for a user you chose. Do this on a sandbox first. A live site should get a dedicated low-privilege user and only the abilities you meant to publish. Adapter 0.7.1’s release notes describe a fix that caps per-session initialization data at 4 KiB, so if you run an older 0.7.x or 0.6.x copy, update (0.6.2 is the matching release for the 0.6 series, distributed through GitHub and Composer, not WordPress.org). We found no published advisory ID for it, so we make no claim beyond the vendor’s notes.
For a fuller walkthrough of building your own server instead of using the adapter, see Build a WordPress MCP Server in 20 Minutes, and for where core is heading with MCP, abilities and OAuth, see WordPress for the Agentic Web.
What changed in the MCP specification dated 2026-07-28?
The 2026-07-28 revision makes MCP stateless. We read the official changelog on 15 November 2026. The adapter’s CLI already lets you count components per revision (2025-11-25 or 2026-07-28), which tells you the adapter supports both. The changes that matter for WordPress setups:
- No sessions. Protocol-level sessions and the
Mcp-Session-Idheader are gone from Streamable HTTP, and theinitializehandshake is removed. Each request carries its protocol version and client capabilities in_meta. - Discovery. Servers must implement
server/discoverto advertise versions, capabilities and identity. - Subscriptions.
subscriptions/listenreplaces the HTTP GET endpoint and resource subscribe calls. - Input mid-call. Multi Round-Trip Requests replace server-initiated requests: a server returns an
input_requiredresult and the client retries with the answers. Every result now has aresultType. - Tasks moved out of the core protocol into an official extension.
- Caching hints. List and read results must carry
ttlMsandcacheScope. - Deprecated: Roots, Sampling and Logging, the old HTTP+SSE transport, and OAuth Dynamic Client Registration in favour of Client ID Metadata Documents. Deprecated features stay for at least twelve months under the new lifecycle policy.
What this means for you in practice: nothing breaks today, because clients and servers still speak older revisions. Do not hard-code session handling in your own MCP code, and expect adapter issues about protocol versions to keep appearing as clients move (issue 411 in the adapter repository, an HTTP 400 when the protocol-version header is missing, is one open example).
Which agent skills should I install for WordPress work?
The WordPress/agent-skills repository holds portable instruction bundles for AI assistants. At the time of checking (repository updated 9 November 2026) it lists skills for plugin development, blocks, block themes, the REST API, the Interactivity API, abilities (three of them: development, audit and verify), WP-CLI, performance, PHPStan, Playground, Blueprints and wp-env. Install one with:
# from the repository README, checked 15 Nov 2026 (not run here)
npx skills add WordPress/agent-skills --skill wp-plugin-developmentFor this post’s loop the useful ones are wp-playground (routing between CLI runs, browser previews and snapshots), blueprint and wp-env. The repository carries an AI authorship disclosure: the skills were generated with a coding model from official docs and then edited by contributors, and its authors call it a first version. Treat them as a starting checklist and read a skill before you install it.
Which setup fits which job?
Job | Best tool | Why |
|---|---|---|
Click through an admin screen with an agent watching | Playground MCP | Real browser tab, logged-in session, visible result |
Test a plugin on PHP 8.3 and 8.4, or WordPress 6.8 and latest | Playground CLI | Flags and Blueprints are scriptable; nothing to click |
Have an agent build a theme or full site locally | Studio MCP | Creates and manages sites, with screenshots and WP-CLI |
PHPUnit against a real database, Xdebug, team parity | wp-env | Docker setup shared in the repo |
Let an agent read or edit a live site | MCP Adapter on that site | Abilities, permissions and an Application Password you control |
Common mistakes people report
These come from the issue trackers and from our own error, checked on 15 November 2026. Issue numbers are on the WordPress GitHub repositories named.
- Using package names that do not exist. Search results and older write-ups (including the first version of this post) cite
@wp-playground/mcp-server. The registry returns 404 for it. Use@wp-playground/mcp. - Expecting a connected tab and finding zero. Playground issue 3651 (open, filed May 2026 against version 3.1.33) describes the MCP server accepting WebSocket connections while
playground_list_sitesreturns no tabs, with version skew between server and website as the suspected cause. Use the URL the agent returns, keep the package current, and ask for the site list before any change. - Letting a long STDIO session read stale data. Adapter issue 409 (open) reports that
wp mcp-adapter servekeeps WordPress’s in-memory object cache for the whole session, so an edit made in wp-admin never reaches the agent. Restart the serve process after outside changes, or use HTTP, where each call is its own request. - Approving a destructive prompt for every read. Adapter issue 431 (open) notes that
execute-abilityis annotated as destructive, so clients that prompt from annotations ask for approval even on read-only abilities. Approving it once also approves destructive calls routed through it, so do not set it to always allow on a live site. - Passing arguments to discovery. Adapter issue 381 (open) reports that
discover-abilitieshas no input schema, so a client that sends arguments gets anability_missing_input_schemaerror. Call it with no arguments. - Getting a 404
rest_no_routeon the endpoint. Adapter issue 367 (open) covers it. Check the adapter is active, the default server is enabled, and the abilities you expect are marked public.
Frequently asked questions
Is there a WordPress 7 MCP server I can turn on?
Not in core as of WordPress 7.1.4. Install the MCP Adapter plugin and mark abilities public, or use the Playground and Studio tools for local work.
Can an agent create a Playground site with a specific WordPress version through MCP?
Not through a dedicated tool in the current tool list. Pass a Blueprint, or use the Playground CLI with --wp and --php, then attach the agent to that site.
Does the Playground MCP server need a WordPress.com account?
The documentation lists Node.js, an MCP client with STDIO support and a browser on the same machine. It does not list an account.
Can I test a premium plugin zip?
Yes through the CLI: mount the folder that holds it with --mount. Keep paid code out of public Blueprint URLs.
Is it safe to point an agent at production?
Only with a dedicated low-privilege user, a short list of public read-only abilities, approval prompts left on and a backup. Do your experiments in a sandbox first.
Do these tools work with Cursor, Codex and Copilot?
Any client that supports local STDIO MCP servers can run the Playground and Studio servers. Studio lists Claude Code, Codex, Cursor and Grok Build as one-click targets. Config file locations differ per client, so use that client’s MCP documentation.
Sources checked on 15 November 2026
- Playground MCP package README and tool definitions and Playground CLI README
- WordPress Studio repository and its MCP and CLI docs
- WordPress/mcp-adapter, its 0.7.1 release notes and the WordPress.org plugin page
- MCP specification 2026-07-28, key changes
- WordPress/agent-skills
- Abilities API on developer.wordpress.org and the registration docblocks in WordPress core





No comments yet