Jason Adams @jason_the_adams (Team RepTeam RepA Team Rep is a person who represents the Make WordPress team to the rest of the project, make sure issues are raised and addressed as needed, and coordinates cross-team efforts.) – Automattic
This week’s meeting focused on a significant step toward making Model Context Protocol (MCP) a native part of the WordPress experience, following approval to move forward with the initiative. Contributors discussed how MCP should be delivered, early agent benchmarking results, authentication and security requirements, and the balance between seamless user experiences and modular development. The team also identified maintenance bottlenecks affecting the PHPPHPPHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/index.php AI Client and related components.
MCP as Part of the WordPress Experience
@jason_the_adams shared that Matt has approved moving forward with making MCP a de facto part of the WordPress experience, recognizing the growing adoption of AI agents and the importance of making WordPress accessible through agent-driven workflows.
The discussion clarified that this does not necessarily mean moving the entire MCP AdapterMCP AdapterTranslates WordPress abilities into Model Context Protocol format, allowing AI assistants like Claude and ChatGPT to discover and invoke WordPress capabilities as tools, resources, and prompts. into WordPress coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress.. Options include bundling the pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. with WordPress, enabling it through existing core interfaces, or incorporating specific capabilities directly into core.
@bacoords highlighted existing WordPress patterns, such as importers and connectors, where plugins can be installed behind the scenes without introducing complexity for users. @jorgefilipecosta emphasized defining the desired user experience first, then selecting the appropriate implementation.
@ovidiu-galatan advocated for preserving the MCP Adapter as a modular plugin, allowing it to evolve independently of WordPress core release cycles as the protocol continues to change.
The team found common ground around making MCP part of the default WordPress experience, while leaving the technical implementation open for further discussion.
Early testing found that agents completed 0% of the benchmarked tasks using the MCP Adapter alone, primarily because the adapter does not currently bundle the abilities needed to perform common WordPress operations. Agents using alternative methods, including REST APIREST APIThe REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”)
https://developer.wordpress.org/rest-api/ access, achieved higher success rates, although some approaches introduced security concerns.
The discussion distinguished between two related challenges:
Agent capability: Whether an agent can successfully complete tasks using WordPress tools. Adding standardized core abilities to the MCP experience can directly improve these results.
Agent selection: Whether an agent recommends or chooses WordPress in the first place. This depends on broader discoverability, product positioning, and model behavior, making it a longer-term challenge.
Contributors emphasized that the benchmarks demonstrate the importance of delivering a complete MCP experience rather than simply providing a connection mechanism.
Default Enablement and Agent-First User Experience
@apeatling raised concerns about requiring users to visit WP Admin and manually install or enable the MCP Adapter before connecting an AI agentAI AgentAn AI system that autonomously performs tasks and interacts with systems through available tools and resources..
For users interacting with existing WordPress websites through tools such as Claude or other personal agents, this additional setup could become a significant barrier.
The team explored whether MCP should be bundled and available by default, allowing agents to initiate authentication without requiring users to first configure the integration manually.
@jorgefilipecosta noted that bundling could also avoid filesystem restrictions that prevent plugin installation on some hosting environments. WordPress 7.3 was discussed as a possible target for deeper integration, though no release commitment was made.
The discussion also touched on creating a complete agent-driven experience for users starting without an existing WordPress website. @jason_the_adams noted that a broader proposal addressing hosting environments and agent-first site creation is being developed with @apeatling.
OAuth Authentication and Security
The team discussed the need for OAuth authentication to make MCP connections more accessible and secure for everyday WordPress users.
@jorgefilipecosta suggested that OAuth should be part of the default MCP experience, reducing reliance on application passwords and providing a familiar authorization flow.
@ovidiu-galatan raised concerns about introducing additional security-sensitive functionality into WordPress websites without sufficient review and auditing.
@justlevine emphasized that authentication is a broader WordPress architectural concern rather than something exclusive to MCP. Contributors discussed whether OAuth infrastructure should be implemented centrally in WordPress core, potentially leveraging the new Secrets APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. to secure tokens.
The team also highlighted the importance of separate credentials for individual clients and integrations to limit the impact of compromised access.
No final implementation decision was reached, with additional exploration needed around the appropriate architecture and security requirements.
PHP AI Client Maintenance and Streaming Support
@laurisaarni raised concerns about the pace of development for the PHP AI Client and whether core development processes can keep up with rapidly evolving AI providerProviderAn AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI). APIs.
@jason_the_adams acknowledged that limited maintainer availability has become a bottleneck and proposed formally recruiting additional contributors willing to take ongoing responsibility for maintaining the library.
The discussion also identified a dependency affecting streaming support. Work in the PHP AI Client is currently blocked by an outstanding pull request in the WordPress Requests library, which itself has limited maintainer availability.
@whyisjake volunteered to help move the request forward, with coordination needed from an appropriate core committer to review and merge the changes.
The discussion reinforced the importance of sustainable maintenance across the AI building blocks and their underlying dependencies.
Next Steps
MCP integration proposal:@jason_the_adams will draft a post outlining the proposed direction for MCP in WordPress, including potential implementations and outstanding questions.
Agent benchmarking: Continue evaluating agent task completion, MCP capabilities, and WordPress discoverability to help guide implementation priorities.
OAuth architecture: Explore authentication requirements and whether shared OAuth infrastructure should be considered for WordPress 7.3.
PHP AI Client maintenance:@jason_the_adams will solicit additional maintainers to help reduce development bottlenecks.
Streaming support:@whyisjake will coordinate with a core committer to advance the outstanding Requests library pull request.
Upcoming Meetings
Contributors are welcome to join the weekly AI contributor call. All team meeting schedules are published on the WordPress Meeting Calendar.
AI Team Office Hours: Thursday, October 29, 2026 at 17:00 UTC.
This week’s meeting focused on finalizing coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. abilities ahead of WordPress 7.2 BetaBetaA pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. 1, improving schema compatibility across AI providers, and integrating the new Secrets APIAPIAn API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways. with WordPress connectors. Contributors also discussed early benchmarking results for AI agents interacting with WordPress, the balance between core functionality and ecosystem innovation, and emerging protocols for agent-based interactions.
Core Abilities: Schema Refinements and WordPress 7.2
The team refined the input and output schemas, separating abilities that query collections from those retrieving individual items. This simplifies the schemas, strengthens type definitions through nested objects, and improves compatibility with AI providers that have limitations around certain schema structures.
The settings abilityAbilityA registered, self-documenting unit of WordPress functionality that can be discovered and invoked through multiple contexts (REST API, Command Palette, MCP). Includes authorization and input/output specifications. remains ready, while the users and content abilities are undergoing final reviews ahead of Beta 1. Additional single-item and write abilities remain under development and may follow after the initial release.
@jeffpaul suggested prioritizing the core implementations until Beta 1, then returning to the remaining abilities in the AI pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party.. The team agreed this would avoid duplicating work while the schemas are still changing, with the goal of making a broader set of abilities available through the plugin ahead of WordPress 7.3.
The discussion also highlighted workflows as an important non-AI use case for abilities. @nikskyverge noted that workflows provide a useful way to test whether abilities are sufficiently predictable, composable, and reusable beyond AI agents.
AI ProviderProviderAn AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI). Schema Compatibility
@gziolo reported discovering compatibility issues with Gemini’s tool-calling implementation during testing. Certain schema constraints, including validation keywords such as minimum and maximum, are not consistently supported across providers.
@jorgefilipecosta recommended maintaining broadly useful validation rules in core while allowing individual provider integrations to remove or adapt unsupported keywords. This would avoid weakening core schemas to accommodate limitations in individual AI providers.
The team discussed potential improvements to the PHPPHPPHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/index.php AI Client that would allow providers to transform schemas automatically, improving compatibility for third-party plugins that may not test against every available provider.
@gziolo will file issues documenting the Gemini incompatibilities, with additional testing planned during the WordPress 7.2 beta period.
Secrets API and Connector Integration
@whyisjake shared details about the newly merged Secrets API, which introduces support for securely storing encrypted values in WordPress core.
The API includes a migrationMigrationMoving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. mechanism that allows developers to convert existing plaintext options into encrypted secrets, providing a path for existing integrations to adopt the new functionality without requiring users to re-enter credentials.
@gziolo and @jorgefilipecosta discussed integrating the Secrets API directly with WordPress connectors so provider API keys can benefit from encrypted storage. @whyisjake agreed to open a tracking ticket and begin work, with timing dependent on the upcoming GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc.
https://wordpress.org/gutenberg/ code freeze.
The team also discussed compatibility with encryption functionality already implemented in the AI plugin, including the existing migration issue.
The Secrets API is part of a broader WordPress security initiative, although secure storage of AI provider credentials remains a key use case.
AI AgentAI AgentAn AI system that autonomously performs tasks and interacts with systems through available tools and resources. Benchmarking and MCP Effectiveness
@apeatling shared preliminary results from benchmarking AI agents against typical WordPress editing tasks. The benchmark includes approximately 50–60 prompts tested across different models and environments, comparing the MCP AdapterMCP AdapterTranslates WordPress abilities into Model Context Protocol format, allowing AI assistants like Claude and ChatGPT to discover and invoke WordPress capabilities as tools, resources, and prompts., third-party integrations, and setups without dedicated connectors.
Early results suggest that agents can sometimes complete tasks more successfully without an MCP connector than with the current implementations. @apeatling emphasized that these findings are preliminary, with additional runs needed before drawing conclusions.
The benchmarking intentionally uses default environments without assuming tools such as WP-CLIWP-CLIWP-CLI is the Command Line Interface for WordPress, used to do administrative and development tasks in a programmatic way. The project page is http://wp-cli.org/https://make.wordpress.org/cli/ are already installed, providing a closer representation of the experience for everyday WordPress users rather than developers with customized setups.
@apeatling plans to share more comprehensive results and expand testing to include personal agents and environments such as Muse and Grok Bot.
WordPress Core, MCP, and Ecosystem Strategy
The team discussed whether WordPress should take a more opinionated approach to providing a consistent foundation for AI agents.
@apeatling raised concerns that multiple independently developed MCP servers could create fragmented experiences, inconsistent security practices, and confusion for both users and AI agents. A standardized entry point could provide a more reliable foundation while allowing hosts and plugins to extend functionality.
@nikskyverge drew parallels to WooCommerce, where extensions initially drive innovation before common capabilities are incorporated into the platform. Contributors generally recognized the value of allowing ecosystem experimentation while identifying opportunities to standardize successful approaches.
The discussion also explored how AI agents may increasingly become an entry point for discovering and interacting with websites, raising questions about how WordPress sites, hosts, and services remain discoverable through emerging agent platforms.
@jorgefilipecosta highlighted WebMCP as a promising direction for exposing WordPress functionality directly to browser-based agents, potentially allowing them to interact with forms, content, and editing interfaces without requiring separate connection setup.
No specific architectural changes were agreed upon, but the discussion reinforced the importance of a consistent, extensibleExtensibleThis is the ability to add additional functionality to the code. Plugins extend the WordPress core software. foundation for future agent interactions.
Next Steps
Core abilities:@jorgefilipecosta and @gziolo will continue finalizing the users and content abilities ahead of WordPress 7.2 Beta 1.
AI plugin abilities: Resume work on the remaining ability implementations after Beta 1, incorporating the updated core schemas.
Provider compatibility:@gziolo will document Gemini schema compatibility issues and investigate provider-level transformations.
Secrets API:@whyisjake will create a tracking ticket for connector integration and share demonstration videos with @jason_the_adams.
Beta 1 communication:@jason_the_adams will prepare a post summarizing the AI-related work included in WordPress 7.2 Beta 1.
Agent benchmarking:@apeatling will continue testing across models and environments, expand coverage to additional agent platforms, and share results with the team.
Upcoming Meetings
Contributors are welcome to join the weekly AI contributor call. All team meeting schedules are published on the WordPress Meeting Calendar.
AI Team Office Hours: Thursday, October 15, 2026 at 17:00 UTC.
This week’s meeting focused on preparing coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. abilities for WordPress 7.2 BetaBetaA pre-release of software that is given out to a large group of users to trial under real conditions. Beta versions have gone through alpha testing in-house and are generally fairly close in look, feel and function to the final product; however, design changes often occur as part of the process. 1, including the status of settings, content, and user abilities, architectural decisions around REST APIREST APIThe REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”)
https://developer.wordpress.org/rest-api/ independence, and naming conventions. Contributors also discussed the recent MCP AdapterMCP AdapterTranslates WordPress abilities into Model Context Protocol format, allowing AI assistants like Claude and ChatGPT to discover and invoke WordPress capabilities as tools, resources, and prompts. release, improvements to abilityAbilityA registered, self-documenting unit of WordPress functionality that can be discovered and invoked through multiple contexts (REST API, Command Palette, MCP). Includes authorization and input/output specifications. exposure controls and connection management, and the longer-term goal of making AI integration with WordPress easier for everyday users.
Core Abilities: WordPress 7.2 Readiness
@jorgefilipecosta provided an update on the core abilities targeted for WordPress 7.2. The settings ability has received approval from a core reviewer, content abilities have incorporated recent feedback, and user abilities are undergoing another iteration. Additional abilities for updating content, media, and comments are also progressing through the AI pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party..
@gziolo emphasized the importance of reviewing the broader set of abilities together to ensure consistent naming, functionality, and compatibility. He suggested prioritizing read-only abilities for content and users, which would provide immediate value and allow developers to begin testing integrations while more complex write operations continue to evolve.
@jason_the_adams supported moving forward with the ready abilities rather than treating the broader catalog as an all-or-nothing release. He committed to reviewing the settings, content, and user implementations, with a follow-up discussion planned if outstanding issues could not be resolved through code review.
@jorgefilipecosta will also update the draft merge proposal to reflect the current implementation status and release timeline.
Core Abilities Architecture and Security
The team discussed whether core abilities should proxy existing REST API functionality or operate through an independent implementation.
@gziolo outlined trade-offs between the two approaches, including implementation complexity, compatibility with existing plugins, and the potential for unintended behavior when REST API filters affect exposed data.
@jorgefilipecosta clarified that the current implementation uses a parallel mechanism rather than routing ability execution through REST. Post types must explicitly opt in using show_in_abilities, independently of their REST API visibility. This prevents accidentally exposing content that plugins may have restricted through REST-specific filters.
The team generally supported maintaining this separation, recognizing that explicit opt-in introduces additional work for developers but provides a safer foundation for exposing WordPress functionality, including through AI tools.
Ability Naming and Categorization
@justlevine raised questions about the proposed noun-verb naming convention, including names such as settings/get and content/query.
@jorgefilipecosta explained that placing the entity name first groups related abilities together when sorted alphabetically and aligns with conventions already used by WooCommerce. The distinction between get and query reflects whether an ability retrieves a specific value or supports more complex filtering and searches.
@raftaar1191 also proposed allowing abilities to belong to multiple categories rather than a single required categoryCategoryThe 'category' taxonomy lets you group posts / content together that share a common bond. Categories are pre-defined and broad ranging..
@jason_the_adams explained that ability categories were originally introduced to help AI agents and other consumers narrow down large collections of available tools. Allowing multiple categories could weaken that filtering behavior, so the team encouraged documenting concrete use cases before reconsidering the existing design.
A tracking issue will be opened to explore the proposal further.
MCP Adapter Release and Improvements
@jason_the_adams highlighted the positive community response to the recent release of the MCP Adapter on WordPress.orgWordPress.orgThe community site where WordPress code is created and shared by the users. This is where you can download the source code for WordPress core, plugins and themes as well as the central location for community conversations and organization. https://wordpress.org/.
@ovidiu-galatan shared ongoing work to improve the adapter, including breaking down an issue related to displaying connection information and server status into smaller tasks. A maintenance release addressing outstanding issues was planned for the following week.
The team also discussed compatibility concerns when different versions of shared functionality are bundled across plugins and WordPress core. Further investigation is needed to clarify version conflicts and how implementations should interact when multiple versions are present.
Ability Exposure Controls and User Experience
@andrei shared progress on an experimental interface in the AI plugin for controlling which abilities are exposed through MCP integrations. The implementation uses WordPress DataViews and could provide an initial interface for users to manage exposed capabilities.
@dkotter recommended continuing with the implementation in the AI plugin rather than delaying it to move the functionality into the MCP Adapter. Because it is experimental, the interface can be refined or relocated as the integration matures.
@jason_the_adams noted that the MCP Adapter is increasingly reaching users beyond its original developer audience, making clearer onboarding and management interfaces important. @nikskyverge is preparing a release post that explains the adapter’s development history and current capabilities.
Looking further ahead, @apeatling emphasized that the ideal experience should require minimal configuration, allowing users to connect AI tools to WordPress without needing to understand the underlying protocols or infrastructure. The discussion highlighted the importance of balancing secure, flexible controls with an experience that feels seamless for everyday users.
Next Steps
Core abilities reviews:@jason_the_adams will review the settings, content, and users query implementations, with contributors regrouping if significant blockers remain.
WordPress 7.2 merge proposal:@jorgefilipecosta will update the proposal to reflect the current scope and timeline.
Ability categorization:@raftaar1191 will open a tracking issue exploring support for multiple categories per ability.
MCP Adapter:@ovidiu-galatan will continue work on connection management improvements and prepare a maintenance release.
Version compatibility: Contributors will investigate conflicts when multiple versions of shared functionality are bundled across plugins.
MCP Adapter communication:@nikskyverge will continue drafting the release post outlining the adapter’s capabilities and intended audience.
Upcoming Meetings
Contributors are welcome to join the weekly AI contributor call. All team meeting schedules are published on the WordPress Meeting Calendar.
AI Team Office Hours: Thursday, October 15, 2026 at 17:00 UTC.
This week’s meeting focused on the roadmap for bringing coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. WordPress abilities into future releases, the role of the AI pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. and Model Context Protocol (MCP) Adapter in validating and distributing those abilities, and outstanding technical considerations around schema design and compatibility. The team discussed a potential timeline for WordPress 7.2 and 7.3, with an emphasis on balancing faster adoption against long-term architectural stability.
Core Abilities Roadmap and WordPress 7.2
@jorgefilipecosta shared a draft proposal outlining a path for developing and validating core WordPress abilities ahead of their inclusion in WordPress core. The proposal calls for making a broader set of abilities available through the AI plugin by the WordPress 7.2 release, with the goal of including ready abilities in 7.2 and targeting broader core adoption in 7.3.
The discussion focused on content-related abilities, including querying and managing posts, as initial candidates. Contributors emphasized that these are fundamental capabilities for a content management system and that a shared implementation would reduce duplication across plugins and integrations.
@gziolo noted that existing core pull requests have undergone security reviews and REST APIREST APIThe REST API is an acronym for the RESTful Application Program Interface (API) that uses HTTP requests to GET, PUT, POST and DELETE data. It is how the front end of an application (think “phone app” or “website”) can communicate with the data store (think “database” or “file system”)
https://developer.wordpress.org/rest-api/ compatibility testing, providing confidence in their readiness. @jorgefilipecosta also confirmed that earlier feedback on naming conventions has been addressed, though additional validation against real-world implementations and AI clients remains valuable.
The team generally supported using the AI plugin to validate abilities before core inclusion, while recognizing that neither WordPress 7.2 nor 7.3 should become a hard deadline for functionality that has unresolved technical concerns or lacks consensus.
MCP AdapterMCP AdapterTranslates WordPress abilities into Model Context Protocol format, allowing AI assistants like Claude and ChatGPT to discover and invoke WordPress capabilities as tools, resources, and prompts. and Abilities Distribution
@justlevine proposed using the MCP Adapter as an additional distribution channel for MCP-specific abilities, allowing integrations to move forward without requiring every capability to be immediately included in WordPress core.
The approach would separate immediate MCP integration needs from the longer-term work of establishing reusable, protocol-independent abilities in core. This would allow MCP-specific implementations to evolve independently while reducing pressure to finalize core interfaces prematurely.
@gziolo, @jason_the_adams, and others emphasized that the MCP Adapter should not become a substitute for bringing foundational abilities into core. Standardized core abilities would reduce ecosystem fragmentation, improve consistency across plugins, and establish examples of secure implementation practices for developers.
The discussion also highlighted that abilities serve more than MCP integrations, with WebMCP and the WordPress AI Client representing additional consumers.
The general direction was to continue prioritizing core adoption while allowing the MCP Adapter to address immediate, protocol-specific needs independently.
AbilityAbilityA registered, self-documenting unit of WordPress functionality that can be discovered and invoked through multiple contexts (REST API, Command Palette, MCP). Includes authorization and input/output specifications. Schemas, Compatibility, and Deprecation
@justlevine raised concerns about the long-term flexibility of flat input schemas, particularly as abilities expand to support more sophisticated filtering, sorting, and pagination. Nested input objects, following patterns established by GraphQL, were suggested as a way to improve extensibility and reduce future compatibility challenges.
@jorgefilipecosta noted that the current schemas follow established WordPress REST API and WooCommerce conventions and have not demonstrated significant compatibility issues in existing testing.
@jason_the_adams requested side-by-side examples of the different schema approaches to help distinguish necessary changes from potential future improvements. The team emphasized identifying concrete blockers rather than delaying progress in pursuit of an ideal design.
@justlevine also reported progress on ability deprecation support, with a pull request already submitted and additional work underway to support deprecating individual ability arguments. This work could help abilities evolve without introducing unnecessary breaking changes.
Schema examples:@justlevine will share side-by-side examples of flat and nested input structures to clarify the compatibility concerns.
Ability development: Continue work on core ability candidates, including schema validation, deprecation support, and testing across MCP and other consumers.
Slug fragments:@justlevine will continue work to unblock the slug fragments implementation.
Release planning: Continue refining the proposed WordPress 7.2 and 7.3 roadmap, identifying remaining technical blockers and opportunities for real-world validation through the AI plugin.
Upcoming Meetings
Contributors are welcome to join the weekly AI contributor call. All team meeting schedules are published on the WordPress Meeting Calendar.
AI Team Office Hours: Thursday, October 1, 2026 at 17:00 UTC.
The WordPress CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. AI team is excited to share the public release of the MCP Adapter as a canonical pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. on the WordPress Plugin Directory. The MCP AdapterMCP AdapterTranslates WordPress abilities into Model Context Protocol format, allowing AI assistants like Claude and ChatGPT to discover and invoke WordPress capabilities as tools, resources, and prompts. plugin provides the default MCP serverMCP ServerExposes tools, resources, and prompts according to Model Context Protocol specification. WordPress can run multiple MCP servers with different configurations. architecture for all WordPress sites and its release on the plugin repository is a big milestone. This release simplifies installation and gives developers a more reliable way to build your own MCP functionality on top of shared canonical architecture.
What is MCP Adapter?
MCP Adapter provides a way for WordPress sites to expose site functionality to AI agents and harnesses via the Model Context Protocol.
Provides a default MCP server – the plugin ships with a default MCP server (endpoint: /wp-json/mcp/mcp-adapter-default-server) that includes three fundamental MCP tools. This serves as a common model for the ecosystem to extend and build upon, with options for developers to register your own tools, resources, and prompts.
Bridges WP Abilities to MCP – the plugin bridges WordPress’s Abilities APIAbilities APIA core WordPress API (introduced in 6.9) that creates a central registry of capabilities, making WordPress functions discoverable and accessible to AI agents, automation tools, and developers. Transforms WordPress from isolated functions into a unified system. with the MCP specification, providing a standardized way for AI agents to interact with WordPress functionality. Any publicly exposed WordPress Abilities on your site are automatically discoverable and executable via the default server’s tools. You can read more about abilityAbilityA registered, self-documenting unit of WordPress functionality that can be discovered and invoked through multiple contexts (REST API, Command Palette, MCP). Includes authorization and input/output specifications. exposure via MCP in these plugin docs.
Enables the creation of custom MCP servers – MCP Adapter enables developers to build custom MCP Servers for WP sites or plugins. Developers can hook into mcp_adapter_init to create their own custom server for more direct or explicit integrations. See the plugin docs for guidance on when to use a custom server versus extending the default server.
The plugin is focused on providing server infrastructure for MCP connections, so it does not currently include an MCP clientMCP ClientAI agents, IDEs, or assistants that connect to MCP servers to access capabilities. or UIUIUI is an acronym for User Interface - the layout of the page the user interacts with. Think ‘how are they doing that’ and less about what they are doing. for a full, end-to-end, user-facing agentic workflow. Please leave feedback in the GitHub issues if you’d like to see this (or other functionality) added in a future release.
Why a canonical plugin?
Earlier versions of the MCP Adapter were managed exclusively through the GitHubGitHubGitHub is a website that offers online implementation of git repositories that can easily be shared, copied and modified by other developers. Public repositories are free to host, private repositories require a paid subscription. GitHub introduced the concept of the ‘pull request’ where code changes done in branches by contributors can be reviewed and discussed before being merged by the repository owner. https://github.com/ repository and required users to either manually download and install the plugin, or bundle it as a Composer dependency in their own code. This allowed early-adopters to experiment and iterate alongside the Core AI team’s work, but kept installation out of reach for most WordPress users and required plugin developers to handle dependency updates and cross-plugin conflicts themselves.
On the other end of the spectrum, building a piece of shared canonical infrastructure like this naturally raises the question: Why isn’t this part of core WordPress? At the time of writing, the MCP specification itself is still in flux, with a major breaking update having shipped less than three months ago. This volatility makes MCP a poor fit for inclusion in the core WordPress package at this time, which has massive, often automated distribution, it’s own independent release cadence, and a strong commitment to backwards-compatibility.
Keeping MCP Adapter outside of WordPress Core allows the plugin to iterate rapidly and stay in sync with the fast pace of change in the MCP specification itself and the broader AI ecosystem. As a canonical plugin on WordPress.org, end-users and plugin developers can rely on MCP Adapter without worrying about multiple conflicting, outdated copies. Core WordPress features, such as plugin dependencies and conditional autoinstall from WordPress.org allow plugins to still treat MCP Adapter as a dependency with the added benefit of keeping AI-related functionality transparent and auditable, in line with the Core AI Team’s “Building Blocks” approach.
What’s new in 0.7.0?
Added support for the new, stateless 2026-07-28 MCP spec. Clients that request 2025-06-18 or 2024-11-05 still connect, and are served through the 2025-11-25 schema.
Direct callable tools can request elicitation input under 2026-07-28 with McpInputRequired.
Default abilities register even when another plugin initializes the Abilities API first.
If you were already using an older version of the plugin through GitHub or Composer, check out the 0.7.0 Migration Guide to see if you need to make any changes to your integration.
What’s next?
MCP Adapter is still experimental, and the current focus is on providing key infrastructure while gathering feedback from developers to reach a stable v1.0 release.
AI 1.4.0 has been released and is available for download! “What’s new in AI…” posts (labeled with the #ai-release tag) are posted following every AI pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party. release, showcasing new features included in each release
We’re pleased to announce the release of AI 1.4.0, the latest update to the canonical plugin powering AI-powered features in WordPress. This release introduces Markdown feeds for making WordPress content easier for AI systems and other Markdown consumers to access, expands the Embeddings infrastructure, and adds a new Comment Value score to Comment Moderation. It also improves Content Translation, Type Ahead, Alt Text Generation, AI Request Logging, and several existing developer tools.
What’s new in 1.4.0?
New Experiment: Markdown Feeds
The new Markdown Feeds experiment provides Markdown-formatted versions of WordPress content alongside the existing HTMLHTMLHTML is an acronym for Hyper Text Markup Language. It is a markup language that is used in the development of web pages and websites. and feed formats.
When enabled, sites gain a Markdown feed at /feed/markdown/, including the equivalent feed URLs for other WordPress feed contexts. Individual posts and pages can also be requested as Markdown by adding ?output_format=markdown to their URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org. This provides a cleaner, structured representation of published content for AI agents, language models, developer tools, and other systems that can work more efficiently with Markdown than rendered HTML. The implementation converts WordPress content to Markdown while preserving common structures such as headings, links, images, lists, blockquotes, and code. Post titles, excerpts, and other feed content are also normalized to avoid leaking HTML entities into the Markdown output.
Comment Moderation adds a value score
Comment Moderation now evaluates how substantive and relevant a comment is to the post where it was submitted.
When moderation runs, each analyzed comment receives a value score between 0 and 1. The score is displayed as a new column on the Comments screen alongside the existing moderation signals. The goal is to provide an additional signal beyond toxicity and sentiment. A comment can be perfectly civil while still adding little to the discussion, while another may contain substantial information or meaningfully engage with the post. Bulk comment analysis has also been updated to limit the size of the moderation queue, helping avoid unnecessarily large processing requests.
Expanded embeddings and vector infrastructure
AI 1.4.0 significantly expands the embeddings foundation introduced in the previous release.
The plugin now includes a storage and CRUD layer for embedding vectors using a new wpai_embeddings database table. Stored vectors can include information about the providerProviderAn AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI). and model used to generate them, providing a common foundation for future semantic search, retrieval, recommendations, and other vector-based features.
The release also introduces Vector_Math and Vector_Ranker classes for calculating vector similarity and ranking results.
These additions are primarily developer infrastructure rather than a new end-user experiment today, but they establish reusable building blocks for future AI features that need to understand the semantic relationship between content. Embedding generation has also been updated to use the latest implementation from the PHPPHPPHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/index.php AI Client.
The generate_embeddings helper now requires callers to specify an embedding model. Developers should pass either a model ID or a ModelInterface instance. When passing a model ID, the provider offering that model must also be specified. This is a breaking change for third-party code that began using the embedding helper introduced in earlier versions.
Content Translation improvements
Content Translation gains several workflow and language improvements in 1.4.0.
Nine additional default target languages are now available, and the underlying Content Translation abilityAbilityA registered, self-documenting unit of WordPress functionality that can be discovered and invoked through multiple contexts (REST API, Command Palette, MCP). Includes authorization and input/output specifications. can incorporate relevant WordPress editorial guideline categories when generating translations. If a translation request fails, editors can now retry it directly rather than closing and restarting the workflow. The translation interface also better preserves existing text and background colors while content is being processed. Title translation is disabled with an explanatory notice when the title is too short to provide enough useful context.
Alt Text Generation understands decorative images
Alt Text Generation now integrates with the Image blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience.’s decorative-image setting. Images explicitly marked as decorative are treated accordingly rather than being presented as candidates for generated alternative text. This brings the AI workflow into closer alignment with the accessibilityAccessibilityAccessibility (commonly shortened to a11y) refers to the design of products, devices, services, or environments for people with disabilities. The concept of accessible design ensures both “direct access” (i.e. unassisted) and “indirect access” meaning compatibility with a person’s assistive technology (for example, computer screen readers). (https://en.wikipedia.org/wiki/Accessibility) semantics already available in the editor.
Type Ahead workflow improvements
Type Ahead now provides a visible loading indicator while a suggestion is being generated, making it clearer when the feature is processing a request. The editor also reserves space for suggestions when the caret is positioned at the end of a paragraph, reducing layout and text-placement issues while ghost text is generated.
AI Request Logging improvements
AI Request Logging now handles provider errors more accurately.
HTTPHTTPHTTP is an acronym for Hyper Text Transfer Protocol. HTTP is the underlying protocol used by the World Wide Web and this protocol defines how messages are formatted and transmitted, and what actions Web servers and browsers should take in response to various commands. 4xx and 5xx responses from providers are recorded as errors with their status code and message rather than being incorrectly recorded as successful requests. Gemini text-generation requests are also categorized correctly rather than appearing as metadata operations. These changes should make the request log more useful when troubleshooting provider configuration or failed generations.
Updated Abilities
Several of the general-purpose WordPress abilities introduced in earlier releases have been renamed to better describe their behavior:
core/read-content is now core/content-query
core/read-users is now core/users-query
core/read-settings is now core/settings-get
The previous names continue to work as deprecated aliases for now, giving existing integrations time to migrate. The ai/get-post-details ability is also deprecated. Developers should use the single-post mode of core/content-query instead.
The global “Enable AI” setting has been removed
The “Enable AI” toggle previously displayed at the top of the AI settings screen has been removed. Features and experiments continue to be controlled individually from the AI settings interface, eliminating the additional global toggle.
Accessibility and workflow improvements
The release includes several fixes across existing experiments and interfaces:
Content Resizing now moves keyboard focus to the Accept button after content generation completes.
Content Classification suggestion pills use focus styles aligned with WordPress coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. components.
Suggest Reply is hidden when a comment is being edited using Quick Edit.
Editorial Notes correctly analyzes template blocks when the editor’s “Show template” mode is enabled.
Generated summaries are inserted correctly when working in “Show template” mode.
Abilities Explorer no longer crashes when an ability input property supports multiple data types.
Content normalization better preserves HTML entities and text surrounding shortcodes.
Saving general WordPress settings no longer produces validation errors when the plugin’s abilities are active.
The release also includes several compatibility and performance improvements, including cached detection of active SEO plugins and improved handling of connector approval checks.
Minimum WordPress version is now 7.0.3
AI 1.4.0 increases the minimum supported WordPress version to 7.0.3. Sites running an earlier WordPress release should update WordPress before upgrading the AI plugin.
Security improvements
AI 1.4.0 includes several additional security hardening changes. Bulk Comment Moderation now verifies that the current user has the moderate_comments capability before processing a request and checks the edit_comment capability for each individual comment. The release also hardens JSONJSONJSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. data parsing within admin screens and improves the security of the WordPress Playground preview publishing workflow by deriving pull request and commit metadata directly from the triggering workflow run.
Sites using the AI plugin are encouraged to update promptly.
What’s next?
Work is already underway on additional Features, Experiments, Developer Tools, and Abilities planned for 1.5.0 and future releases, including:
As always, we welcome feedback, testing, and contributions from the community. Whether you are interested in editor UXUXUX is an acronym for User Experience - the way the user uses the UI. Think ‘what they are doing’ and less about how they do it., APIs, accessibility, performance, or AI ethics and policy, there are many ways to participate.
This week’s meeting covered the markdown feeds experiment for the AI pluginPluginA plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party., PHPPHPPHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/index.php AI Client 1.5.0 progress (embedding validation and closing out the embeddings tracking issue), outstanding PHP AI Client web search issues with the Anthropic providerProviderAn AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI)., an MCP AdapterMCP AdapterTranslates WordPress abilities into Model Context Protocol format, allowing AI assistants like Claude and ChatGPT to discover and invoke WordPress capabilities as tools, resources, and prompts. update, and facilitator coverage for this week’s office hours.
AI Plugin: Markdown Feeds Experiment
@dkotter reopened work on markdown support for the AI plugin after an earlier attempt stalled. The current approach supports both dedicated markdown URLs/feeds and content-negotiation headers, so AI clients can request a markdown version of a post either way. @jeffpaul and @jason_the_adams agreed the decision carries little risk, since it targets AI consumers rather than end users and remains easy to adjust later. The team aligned on matching WordPress.orgWordPress.orgThe community site where WordPress code is created and shared by the users. This is where you can download the source code for WordPress core, plugins and themes as well as the central location for community conversations and organization. https://wordpress.org/’s existing URLURLA specific web address of a website or web page on the Internet, such as a website’s URL www.wordpress.org format where practical.
PHP AI Client 1.5.0 and Embeddings
Embedding Validation: A PR from @htperkins adds a type/finite check to guard against invalid values passed into embeddings. @dkotter flagged that iterating every array item could add processing overhead at scale (e.g., generating embeddings across 100,000 posts); the team agreed the check should fold into the existing is_embedding_list validation rather than run as a separate pass.
Embeddings Tracking Issue:@jeffpaul reviewed the original embeddings epic to confirm nothing critical is missing ahead of 1.5.0. Provider implementations, CLICLICommand Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress. support, and integration test coverage are already accounted for. @laurisaarni noted he has an in-progress Mistral provider PR for embeddings, currently blocked pending the 1.5.0 release. The team agreed to close the tracking issue alongside the release, with any remaining work split into separate follow-up issues.
PHP AI Client Web Search / Anthropic Provider Issues
@laurisaarni shared feedback from building with the Anthropic provider’s web search support, having documented several issues in SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/: message parts can’t represent source annotations, citation URLs returned by the provider are difficult to retrieve, and there’s no way to limit the number of searches per round trip. @jason_the_adams suggested adding a formal “max searches” property to the web search tool DTO if it’s a common pattern across providers, otherwise falling back to a generic key/value passthrough for provider-specific options. @laurisaarni volunteered to open PRs to address these.
Model Context Protocol (MCP) Development
@ovidiu-galatan gave a progress update on reworking the PHP-MCP schema to version 0.2.0 to support the newer MCP protocol while preserving backward compatibility through client/server version negotiation. Three PRs are in progress and under review with @justlevine. @laurisaarni reported building a developer MCP serverMCP ServerExposes tools, resources, and prompts according to Model Context Protocol specification. WordPress can run multiple MCP servers with different configurations. on the adapter that’s running smoothly in production, working around a GutenbergGutenbergThe Gutenberg project is the new Editor Interface for WordPress. The editor improves the process and experience of creating new content, making writing rich content much simpler. It uses ‘blocks’ to add richness rather than shortcodes, custom HTML etc.
https://wordpress.org/gutenberg/blockBlockBlock is the abstract term used to describe units of markup that, composed together, form the content or layout of a webpage using the WordPress editor. The idea combines concepts of what in the past may have achieved with shortcodes, custom HTML, and embed discovery into a single consistent API and user experience.-validation limitation by pairing a Node-based MCP adapter with the PHP adapter over REST.
Upcoming Meetings
Contributors are welcome to join the weekly AI contributor call. All team meeting schedules are published on the WordPress Meeting Calendar.
AI Team Office Hours: Thursday, September 17, 2026 at 17:00 UTC. Facilitator: @nikskyverge.
You must be logged in to post a comment.