Connect AI Coding Agents to WordPress Playground with MCP

WordPress 7 has no core MCP server. Connect AI coding agents to Playground, Studio and the MCP Adapter with a safe sandbox loop. Checked 15 Nov 2026.

Diagram of a safe loop for AI coding agents: sandbox site, quality gate, human review, then deploy

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 wp_register_ability() that declare what a site can do, with schemas and permission checks

Inside WordPress

In core since 6.9; a public meta flag was added in 7.1

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, @wp-playground/mcp, that lets an agent drive a Playground site open in your browser

Your computer plus a browser tab

Version 3.1.64 on npm (modified 10 Nov 2026)

Studio MCP server

The studio mcp command, which lets an agent create, start and inspect local Studio sites

Your computer

Studio CLI package wp-studio 2.2.0

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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/mcp

For 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:

  1. Restart the agent if it does not pick up the new server.
  2. Ask it: “Open WordPress Playground and connect it to the MCP server.”
  3. Open the URL it returns in your browser. The URL carries an mcp-port parameter that tells the tab which local port to dial.
  4. 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

playground_execute_php, playground_request

Run PHP inside the site, or call a page or REST route as the logged-in admin

Browse

playground_navigate, playground_get_current_url

Open an admin screen, follow a redirect, report where the tab ended up

Files

playground_read_file, playground_write_file, playground_list_files, playground_mkdir, playground_file_exists, playground_delete_file, playground_delete_directory

Edit a plugin or theme inside the virtual filesystem

Sites

playground_list_sites, playground_get_site_info, playground_rename_site, playground_save_in_browser, playground_open_site_in_new_tab, playground_get_website_url

Pick the site, name it, save it to browser storage

Mail

playground_list_emails

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.json

start 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 mcp

The 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=admin

Over 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-Id header are gone from Streamable HTTP, and the initialize handshake is removed. Each request carries its protocol version and client capabilities in _meta.
  • Discovery. Servers must implement server/discover to advertise versions, capabilities and identity.
  • Subscriptions. subscriptions/listen replaces the HTTP GET endpoint and resource subscribe calls.
  • Input mid-call. Multi Round-Trip Requests replace server-initiated requests: a server returns an input_required result and the client retries with the answers. Every result now has a resultType.
  • Tasks moved out of the core protocol into an official extension.
  • Caching hints. List and read results must carry ttlMs and cacheScope.
  • 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-development

For 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_sites returns 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 serve keeps 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-ability is 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-abilities has no input schema, so a client that sends arguments gets an ability_missing_input_schema error. Call it with no arguments.
  • Getting a 404 rest_no_route on 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

Varun Dubey

Written by

Varun Dubey

Varun Dubey runs Wbcom Designs, the WordPress studio he founded in India in 2009. He has spent sixteen years building on WordPress and BuddyPress, shipping client work and products such as Reign, BuddyX, Jetonomy and MediaVerse, and has been putting Claude and OpenAI workflows into production since 2023. He writes up what the studio learns along the way.

More about Varun

No comments yet