Share your ideas about AI in WordPress – we want to hear from you
This is just the beginning. Whether you’re an engineer, designer, researcher, or just curious about AI, we’d love to have you involved as we shape the future of AI in WordPress.
What’s Next
Over the next few weeks, we’ll be sharing: meeting schedules and format, the initial team roadmap, contribution guidelines, and more.
Team Members
Felix Arntz @flixos90 (co-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.) – Google
James LePage @isotropic (co-Team Rep) – Automattic
This summary covers the key discussion points from the last bi-weekly AI chat in the Make WordPress SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.. This week, the discussion focused on 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/preface.php. AI Client SDK.
1. PHP AI Client SDK – Project Status and Discussion
@flixos90 started the chat with a discussion on the PHP AI Client SDK, recognized as the most concrete project currently.
2. Defining User Audiences: Extenders vs. Implementors
@jason_the_adams highlighted a distinction regarding the SDK’s users and its impact on design:
Extenders: Highly technical users who will extend the client by adding providers and models. The APIs for this group will be technical to ensure well-defined integrations.
Implementors: Developers who want to use the client for features like generating alt text without needing deep knowledge of AI models. The goal for this 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. surface is ease of use and simplicity, minimizing the need to understand underlying AI complexities.
@flixos90 clarified that the implementor API would still allow granular customization, but such advanced options would not be mandatory.
@jeffpaul also noted that some users might operate at the intersection of both roles.
The overall idea to “make the easy things easy, and the hard things possible” was reiterated as a guiding principle.
A significant part of the discussion revolved around the proposed shift to a Fluent API for the implementor surface, contrasting it with the traditional method call pattern inspired by the Vercel AI SDK.
Fluent API Advocates:@jason_the_adams and @flixos90 provided code examples demonstrating the cleaner, more declarative, and readable nature of a Fluent API (e.g., `Ai::prompt(…)->generateImage();`).
They agreed it would reduce errors and typos associated with nested arrays in traditional approaches.
@borkweb later echoed strong support, noting its discoverability in IDEs.
Proposed Approach:@flixos90 suggested updating the proposed architecture to prioritize the Fluent API while allowing the traditional method-based API as a wrapper.
@jason_the_adams advised starting with the Fluent API first, as it’s easier to add the traditional API later than to remove it.
4. Token Usage and Response Metadata
@dunhakdis raised the importance of standardizing token-usage data exposure, suggesting that the SDK should consistently provide metadata regardless of the AI provider.
Result object: Contains comprehensive data and is synchronously returned.
Operation object: For asynchronous, long-running requests.
Ease-of-use method: Directly retrieves the intended value from the Result object.
5. Open Floor: Researching Triage Opportunities
@karmatosed inquired about collaborating on research into AI systems for easing CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress./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/ ticket triage.
@flixos90 suggested using 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 be the repository owner. https://github.com/ discussions for these asynchronous conversations, a proposal @karmatosed welcomed.
@isotropic outlined 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 be the repository owner. https://github.com/ project setup to coordinate WordPress AI efforts.
Plans for related repos for other “building 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.” focuses such as MCP and unified tool registry.
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/preface.php. AI Client SDK
TL;DR: The php-ai-client SDK will be a vendor-neutral PHP foundation, extended by a WordPress-specific layer.
A platform-agnostic PHP SDK for connecting to AI models.
Designed to be extensibleExtensibleThis is the ability to add additional functionality to the code. Plugins extend the WordPress core software. and vendor-neutral.
@isotropic noted a WordPress-specific layer would build on this foundation.
@dan2k3k4 mentioned external contributions from amazee.ai aiming to integrate AI provider support.
Provider Inclusion, Structure, and Extensibility
TL;DR: Provider support will be modular and extensible, starting with initially identified vendors. Proxy architecture and advanced features like cost management are key priorities.
Highlighted difficulty of setting unbiased, verifiable inclusion rules.
Suggested a stakeholder approval process for new providers.
Recommended starting with “big 3” providers (OpenAI, Anthropic, Google) in separate branches.
Preferred eventual migrationMigrationMoving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. of providers to separate repositories.
Bundling widely adopted providers with stable APIs.
Documenting unofficial provider modules with potential promotion based on usage.
@jason_the_adams and others discussed monorepo versus multiple repositories for managing provider modules.
Proxy provider and hosting integration emphasized by @jason_the_adams and @isotropic, with @flixos90 adding SDK architectural support for proxying.
Advanced feature support discussed by@zhendershot and @flixos90 including cost management, model routing handled at WordPress-specific layer with extensibility.
Roadmap outlined for integrating AI features into WordPress with no near-term coreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. merge planned.
Proxy Providers and Hosting
TL;DR: Hosting providers may bundle AI capabilities via proxies. Integration with hosts like amazee.ai is underway to drive adoption.
@jason_the_adams detailed proxy use cases where hosts bundle AI credits and monitor usage.
SDK’s capability to route requests via proxy endpoints.
@dan2k3k4 shared amazee.ai’s intent to be a provider and collaboration efforts with WordPress agencies.
@jason_the_adams emphasized hosting adoption is key for WordPress AI success.
Repository Architecture
TL;DR: Monorepo favored for adaptability, but some prefer modular repos for clearer issue and project management.
@jason_the_adams advocated for monorepo structure for flexibility and version management.
@karmatosed preferred separate repositories for better project and issue management.
@isotropic supported monorepo approach for adaptability and hosting flexibility.
Roadmap and Core Integration
TL;DR: Project will roll out as a Canonical/Feature PluginFeature PluginA plugin that was created with the intention of eventually being proposed for inclusion in WordPress Core. See Features as Plugins. first, with no immediate plans to merge into WordPress core.
@sirlouen asked whether the project aligns more with a Feature Plugin than Core at this stage.
WordPress-specific code expected to ship initially as a Feature Plugin.
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/. Handling
TL;DR: REST API specs may live in the SDK repo, but broader design and GraphQL parity are being considered. Further discussion will continue on GitHub.
WPGraphQL aims to offer 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. parity.
Theme: Next Steps After WordCampWordCampWordCamps are casual, locally-organized conferences covering everything related to WordPress. They're one of the places where the WordPress community comes together to teach one another what they’ve learned throughout the year and share the joy. Learn more. Europe + Building Blocks for AI in WordPress
Meeting Overview
The AI Team discussed strategic next steps following WordCamp Europe and recent Hallway Hangouts. The focus was on identifying foundational building blocks to support AI development in WordPress, while balancing innovation with long-term maintainability and backward compatibility.
Foundational Strategy & Technical Architecture
CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. Building Blocks for AI in WordPress
TLDR:Foundational technical architecture to enable flexible AI development.
The AI Team outlined a three-part “Building Blocks” strategy for AI in WordPress:
Provider-Agnostic LLM Client Abstraction – A shared 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/preface.php. abstraction layer for interacting with different LLM providers.
Tool & Resource Definition / Registration – A system to register site features (“abilities”) that LLMs can understand and interact with.
Integration Bridges (e.g., MCP) – Support for protocols like MCP to connect WordPress to external AI tools and ecosystems.
A showcase 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 is also planned to demonstrate these concepts working together and help developers build on top of the stack.
Shared LLM Abstraction Layer
TLDR:A PHP package to enable provider-agnostic LLM support across plugins and frameworks.
PHP lacks a shared LLM abstraction; most WP plugins today hard-code provider-specific integrations.
@flixos90 shared ai-services, a plugin that abstracts LLM provider access, with plans to extract it into a PHP-agnostic package.
@isotropic confirmed similar needs exist in Laravel and other PHP projects.
@swissspidy noted this as a leadership opportunity for WordPress within the PHP ecosystem.
@schnitzel86 (Drupal) expressed interest in collaborating on shared tooling.
@johnbillion added that Laravel/Symfony contributors likely face the same challenges.
Tool & Resource Registry + MCP Integration
TLDR:Defining features that AI can understand and interact with, using standards like MCP.
MCP (Model Context Protocol) allows LLMs to connect with tools across software platforms.
Tools like data fetching, publishing, and media access can be exposed via MCP or standalone.
@isotropic noted MCP is maturing rapidly and may signal converging best practices around tools/resources.
@flixos90 suggested MCP integration could support both external use (e.g. desktop clients) and internal use (e.g. admin-side agents).
@swissspidy highlighted WordPress media handling as an ideal “resource” use case.
AI Feature Registration and Cross-System Integration
TLDR:Inspired by the Feature 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.: registering “abilities” LLMs can use via protocols like MCP.
Inspired by the Feature API, the team envisions a system for registering “abilities” that LLMs can query.
Enables workflows from simple button-triggered AI actions to multi-tool agents.
Protocols like MCP act as bridges, exposing these capabilities to other systems or importing tools from platforms like 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 be the repository owner. https://github.com/.
Early prototypes include AI-Command and WordPress MCP.
Sustainable Development and Tech Debt Strategy
TLDR:Avoiding early lock-in by using canonical plugins and adapter-based architecture.
AI tech is evolving rapidly; WordPress must guard against locking into unstable patterns.
The team favors:
Canonical plugins as the main innovation space.
WordPress-first adapters to shield internal APIs from volatile protocols.
Keeping most work Core-adjacent unless clearly stable.
@isotropic emphasized an “adapter-style” approach.
@flixos90 added that AI is still early and most tooling doesn’t belong in Core yet.
@jeffpaul supported this modular approach as a way to iterate quickly and responsibly.
Implementation Focus: Use Cases & Experiments
AI-Powered Triage for Plugins, Themes, and Tickets
TLDR:Exploring how AI can assist with reviews and moderation across 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/.
Triage (plugin/theme/ticket review) is a prime use case for AI.
@karmatosed: wants to apply AI to triage but with “just enough structure.”
Unattributed: many OSS projects are already experimenting here.
@SirLouen: cautioned against skipping over simple automation.
@flixos90 noted traditional tools may be more effective for well-defined tasks.
@justlevine: urged reinforcing static analysis and quality tooling first (e.g. PHPStan).
AI for Documentation and Contributor Support
TLDR:Generating user-facing docs with LLMs and streamlining onboarding materials.
@estelaris is testing LLMs (e.g. ChatGPT) to generate user-facing docs using the WordPress glossary and style guide.
Current content is inaccurate or off-tone, but long-term goal is full automation from feature videos or releases.
@jeffpaul confirmed AI Team support for helping Make teams adopt AI — especially #docs.
RAG and Vector Support in WordPress
TLDR:Future consideration for retrieval-augmented generation and vector-based search as MySQLMySQLMySQL is a relational database management system. A database is a structured collection of data where content, configuration and other options are stored. https://www.mysql.com/. evolves.
@pbiron: asked about support for RAG workflows and vector-based search.
Suggested future support for vector/hybrid search in WP_Query or 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/..
@jeffpaul: emphasized exploring early so the community is informed when it’s time to act.
Governance, Culture & Infrastructure
Culture of Collaboration, Governance, and Experimentation
TLDR:Creating a space for decentralized innovation, sharing results, and team autonomy.
@isotropic: proposed a collaborative “opportunity areas” list for AI across teams.
@isotropic: proposed publishing it on Make/Core to help teams self-organize vs needing AI team ownership.
@estelaris: encouraged publishing experiments and results on Make blogs.
@flixos90: urged matching the right tool to the job — not every problem needs an LLM.
@justlevine: emphasized we need stronger foundations before layering AI on top.
Technical Planning: GitHub Strategy and Infra
TLDR:Deciding between monorepo vs multi-repo setups to support scalable collaboration.
Discussed whether to use a monorepo or individual GitHub repos.
This will impact collaboration, package structure, and release processes.
Team will aim for clarity by mid-next week via async discussion.
Philosophy: Canonical First, Core When Ready
TLDR:A clear development ethos: iterate fast in plugins, stabilize before touching Core.
WordPress’s long-term success with AI depends on:
Starting with canonical plugins and packages.
Building adapter-style architecture to insulate Core from churn.
Encouraging a culture of open experimentation, documentation, and shared learning.
Letting the best ideas bubble up through real-world usage and community support.
Open Next Steps & To-Dos
Decide GitHub Repo Structure Async discussion this week to determine whether to use a monorepo or split repositories for AI-related work. Target: Clarity by mid-next week (June 19–20).
Extract ai-services into Shared PHP Package @flixos90 shared an early version. Action needed to extract and formalize this for community use.
Prototype Showcase Plugin A new plugin is planned to demonstrate how LLM client abstraction, tool registration, and MCP integration work together. Contributors welcome.
Document AI Opportunity Areas @isotropic suggested publishing a public list of cross-team AI opportunities (e.g. Docs, Design, Triage). Goal: Help Make teams self-organize without AI team bottlenecks.
Encourage Make Team Experiments Encourage publishing early use cases and learnings (e.g., Docs experiments from @estelaris) on Make/Core or respective team blogs.
Explore RAG + Vector Support Path Initial interest flagged around integrating MySQL 9 vector types and reviving the wpvdb prototype. More research needed.
Continue Triaging AI in Contributor Workflows Discussion to continue on how to balance static analysis tools (e.g., PHPStan) with LLM-based systems like dosu.dev.
This is a summary of a Hallway Hangout that was first announced on Make AI. The aim was to have a shared space where we could chat about the new AI team, learn about the current team members, hear about current projects, and start to get community input. Thank you to the nearly 30 people who joined, including the AI team (@jeffpaul@swissspidy@isotropic@flixos90).
Video Recording:
Notes
Team Introductions
Jeff Paul: Director of Open SourceOpen SourceOpen Source denotes software for which the original source code is made freely available and may be redistributed and modified. Open Source **must be** delivered via a licensing model, see GPL. at Fueled; longtime WordPress contributor since 2016; focused on product leadership and practical AI integrations like the ClassifAI 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.
Pascal Birchler: CoreCoreCore is the set of software required to run WordPress. The Core Development Team builds WordPress. contributor and committer, sponsored by Google; expertise in internationalization, performance, and client-side AI; exploring privacy-focused, on-device AI implementations.
Felix Arntz: Core contributor for 10 years with a focus on 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. design; created the AI Services plugin to abstract AI provider APIs; sponsored by Google.
James LePage: AI Lead at Automattic; previously ran WPAI, developing AI solutions like CodeWP and AgentWP; extensive experience in WordPress development and AI integration.
Team approach
Transparency
Conduct open discussions via the make.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//AI, 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 be the repository owner. https://github.com/, and SlackSlackSlack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/..
Publish clear roadmaps, documentation, and updates to keep the community informed.
Focus on Canonical Plugins
Prioritize building foundational tools and plugins outside of core to enable rapid iteration and experimentation.
Avoid premature core integration to maintain flexibility and adaptability.
Community-First Collaboration
Foster regular engagement through hallway hangouts, Slack discussions, and blog posts.
Encourage widespread community involvement to shape AI initiatives and contributions.
Developer Enablement
Build APIs, services, tools, and guidelines that empower developers to create AI-enhanced features.
Provide abstraction layers to support multiple AI providers and avoid vendor lock-in.
Measured Progress
Strive for concrete, focused deliverables that provide clear benefits to the WordPress ecosystem.
Balance innovation with pragmatism to ensure sustainable and practical AI implementations.
Iterative Development
Use canonical plugins and packages to test concepts, gather feedback, and refine ideas before potential core integration.
Adapt to the rapidly changing AI landscape while maintaining WordPress’s core philosophies.
High level overview of Current Initiatives
AI Services Plugin: Provides an abstraction layer for multiple AI providers, enabling plugin authors to use a unified API for AI interactions.
MCP WP: Implements Model Context Protocol (MCP) servers in WordPress, enabling advanced AI integrations via command-line or plugins.
WP Feature API: Structures WordPress features for better AI interaction, offering a standardized way to register resources for AI use.
Q&A
How does someone join the team, or is it only the four initial people?
The team is still forming. The best way to get involved is by joining discussions in the #core-ai Slack channel, participating in blog posts on make.wordpress.org/ai, and attending hallway hangouts. A roadmap and handbook will clarify how others can contribute going forward.
Are there any short-term objectives the team is focusing on?
The team is in the forming stage, focusing on foundational building blocks and defining deliverables through community discussions. Immediate next steps include WordCampWordCampWordCamps are casual, locally-organized conferences covering everything related to WordPress. They're one of the places where the WordPress community comes together to teach one another what they’ve learned throughout the year and share the joy. Learn more. Europe discussions, publishing notes, and continuing structured conversations in Slack.
Is there any plan to integrate WordPress core with LLM in the future?
There are no immediate plans to integrate LLMs directly into WordPress core. The team will focus on canonical plugins and packages that abstract AI provider APIs (e.g., like how AI Services does in its current plugin form). Core integration could be considered in the distant future if technical and philosophical limitations are resolved.
Could you talk about integrating with external AI models like OpenAI, Claude, and Google?
The AI Services plugin provides a unified abstraction layer for multiple AI providers, allowing developers to interact with various models without vendor lock-in. The team aims to support multiple providers while ensuring flexibility and user choice.
Will there be a standardized interface for AI data interaction?
Yes. Efforts like the AI Services plugin aim to create a middleware that standardizes interactions between AI providers and WordPress plugins. This ensures developers can easily swap providers while maintaining a consistent interface.
What is the mission and why launch the team now?
The mission is to build foundational building blocks for AI integration in WordPress. The timing is ideal due to the rapid evolution of AI, emerging standards like MCP, and the need to position WordPress as a central platform in the AI-driven web.
How do we know the team has succeeded in 12–24 months?
Success will include delivering concrete projects, such as canonical plugins and packages, increasing community involvement, and positioning WordPress as a leader in AI for the open web.
Where is the line drawn between building integrations for core versus plugins?
The focus is on canonical plugins and packages rather than core integration. WordPress avoids vendor lock-in and paid provider integrations by default. Future core integration may depend on emerging standards for AI APIs and user control over AI functionality.
Could AI eventually build or replace entire plugins?
The focus is on making WordPress a framework for AI-enhanced functionality rather than replacing existing plugins. AI can already assist in building plugins, but fully replacing robust plugins with consistent updates, support, and security is unlikely.
Will canonical plugins or packages be embeddable in plugins?
Yes. Composer packages could allow developers to embed functionality from canonical plugins without requiring direct dependencies. This approach supports flexibility for plugin developers.
How much does WordPress leadership support this team?
The team has full support from WordPress leadership, including Matt Mullenweg and Mary Hubbard. They recognize the importance of AI for the open web and the need to ensure WordPress remains central in this evolving landscape.
Are there thoughts on how core can support RAG (Retrieval Augmented Generation)?
While there are no immediate plans, the team is exploring all AI possibilities at this point. A vector database plugin or similar features could be considered in the future. Current efforts focus on creating building blocks for developers to integrate AI functionality effectively.
