neillmcshea 7:37 pm on 5 August 2025
Tags: ,   

Core-AI Contributor Check-in – July 29th, 2025

Announcements (5 min)

  1. Welcome to our new meeting format! – Have a topic you think would contribute to executing on the work here? Leave a note in CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. AI channel pinging Neill and/or Tammie and we will help put them together for the following week’s meeting.

Progress this week (5 min)

  1. Making progress on building the PHPPHP PHP (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 Client foundation (Jason & Felix)
    1. https://github.com/WordPress/php-ai-client/pull/30
    2. https://github.com/WordPress/php-ai-client/pull/31/
  2. Project / Process: Labels: done, some milestones. Handbook page up, to be unblocked but started.

Questions/Decision points (15 min)

  1. Where should ProviderProvider An AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI).-specific code live? (Jason)
  2. What are our goals to have ready by WCUS?

Week’s goals (5 min)

  1. I really want to get the PHP Client foundation work done (Jason)
  2. Move A8C work into Abilities repo & early iteration of MCP adapterMCP Adapter Translates 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. (James) – This will unblock David (yay)
  3. Set up milestones and project boards starting with WCUS and work out what ‘done’ is for each in collaboration (Tammie and Neill)
  4. Sort MVPMinimum Viable Product "A minimum viable product (MVP) is a product with just enough features to satisfy early customers, and to provide feedback for future product development." - WikiPedia handbook (Tammie and Neill)
Gemini Generated Summary


A new meeting format was introduced, which allows for panelists (active contributors) and attendees (others interested in transparency) to join. They also discussed progress on the PHP client foundation, with the goal of completing the foundation work to allow for parallel development by more contributors. Tammie Lister provided an update on project processes, mentioning that labels have been standardized and that a handbook is being created, though she is currently blocked from publishing pages. The group debated where provider-specific code should live, with a tentative conclusion to build a generic, self-contained provider that follows the OpenAI shape and can be used with any compatible APIAPI An 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.. Finally, they outlined goals for WordCampWordCamp WordCamps 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. US, including having a minimum viable productMinimum Viable Product "A minimum viable product (MVP) is a product with just enough features to satisfy early customers, and to provide feedback for future product development." - WikiPedia (MVP) for the client SDK, abilities, and the MCP adapter, and to use the event’s Contributor DayContributor Day Contributor Days are standalone days, frequently held before or after WordCamps but they can also happen at any time. They are events where people get together to work on various areas of https://make.wordpress.org/ There are many teams that people can participate in, each with a different focus. https://make.wordpress.org/support/handbook/getting-started/getting-started-at-a-contributor-day/ to tie these pieces together through AI experiments.

Highlights

PHP Client Foundation Progress

  • The foundational work for the universal PHP client is underway to allow communication with any AI model from any provider.
  • The goal is to get the foundation work done as quickly as possible to enable parallel work.
  • Two pull requests (PRs) are nearing completion for the extender API, which will allow people to add their own providers and models.
  • After the extender API is complete, work will shift to the implementer API for users who want AI features without needing to know how AI works.
  • The plan is to have PRs for the two remaining foundational pieces up this week.

Project and Process Updates

  • Labels have been standardized across the project.
  • A handbook is being documented to provide a project primer and help new contributors get started.
  • Tammie Lister is unable to publish pages in the handbook and may need help from Neill McShea, who recently received blog rights access.

Goals for WordCamp US

  • The team aims to have an MVP for the client SDK, abilities, and MCP adapter ready for the event in 3-4 weeks.
  • Contributor Day at WordCamp US is planned as a hackathon to tie these components together and conduct AI experiments.
  • The goal is to have something that is usable by more than just early developers.
  • There will likely be a high-level discussion about the project on the main stage, and if there are demoable features, they could be highlighted.

Discussion on Provider Code Location

  • A key question is whether provider-specific code should live within the main client repository or in separate packages.
  • A related question is whether to use provider SDKs, which might tie the code to specific PHP versions.
  • The group agreed that not all providers should be in the main package, and there should be criteria for which ones qualify.
  • For now, the decision is to build a generic provider that follows the OpenAI API shape and can be built into the main repo to facilitate development.
  • This approach would allow the project to maintain a lower PHP version requirement (7.4) and avoid being tied to external SDKs.

Action Items

  • David Levine: David will contribute to the project once the abilities and MCP adapter repos have content ready for code review.
  • Felix Arntz & Jason Adams:  Jason will set up a call for tomorrow to discuss the HTTPHTTP HTTP 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. client stuff and authentication implementation. Anyone interested in the HTTP client discussion should pingPing The act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” Jason or Felix to be included in the call.
  • Neill McShea & Tammie Lister: Tammie will work on getting the MVP handbook unblocked. They will also set up milestones and project boards for WordCamp US and track progress on the goals.
  • James LePage: James will move the existing work from the Automattic organization’s repos into the new abilities and MCP adapter repos. He wants to have something viewable and ready for contribution by next week.
  • Jason Adams: Jason will continue work on the PHP client foundation, with the goal of having pull requests (PRs) up for the two remaining foundational pieces this week. He will also hound Felix for feedback.

#check-in, #core-ai

neillmcshea 7:28 pm on 5 August 2025
Tags: ,   

Core-AI Contributor Check-in – July 23rd, 2025

Announcements (5 min)

  1. Welcome! To our new contributors!
    1. Tammie Lister
    2. Adam Silverstein
    3. David Levine 

Progress this week (5 min)

  1. Published our Roadmap
  2. First Code PR merged for PHP Client
  3. Two PRs in review
    1. Unit tests framework
    2. Implementor DTOs
  4. Activity in the Providers discussion
    1. Add this to the BiWeekly agenda for tomorrow.

Questions/Decision points (15 min)

  1. Confirm Plan to open this meeting to more Attendees via a Panalist/Webinar medium (thanks to @desrosj for the discussion point) 
  2. What does a Contributor for this coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. team look like? Is this defined by the current milestone? 
  3. Some structure for GitHubGitHub GitHub 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/ Projects (Tammie)
    1. Review proposed initial idea for labels: Proposal: core-ai repos
  4. Would a review call for the DTO work be useful? (Jason)
    1. https://github.com/WordPress/php-ai-client/pull/28
  5. Would documenting the method Jason is using for incorporating Claude Code
    1. Would this be documentation? 
    2. Publishing that this was generated via Claude

Week’s goals (5 min)

  1. Finish remaining “Foundation” work (Jason)
    1. Need for a discussion on where the providers need to live? Step before that – establishing a vision for how the providers connect holistically.
  2. PHPPHP PHP (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 Client Work & Abilities APIAbilities API A 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. – integrating some folks that will be working on this.
  3. David – has 4-5 hours for this week. James recommends partnering with some of the Automattic folks who will begin being available in the next few days.
  4. Tammie suggests starting to set some aggressive milestones, added when we have GitHub Projects set up a little more, that would encourage some momentum before WCUS 2025

Action Items and Notes 

  • Draft for tomorrows BiWeekly
  • James is leading the BiWeekly meeting tomorrow
  • Page to publish these meeting agendas and notes (James will set this up) 
Gemini Generated Summary

Neill McShea welcomed new team members Tammie Lister, Adam Silverstein, and David Levine. Jason Adams shared updates on the project’s progress and discussed providerProvider An AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI). integrations, while James LePage emphasized defining contributions and pathways, and Tammie Lister proposed structuring GitHub projects. The main talking points included the roadmap, provider integrations, meeting structure, defining contributions, GitHub project structure, DTO work, strategic vision for providers and hosts, and weekly goals.

Details

  • Welcome and Introductions Neill McShea welcomed new team members, Tammie Lister, Adam Silverstein, and David Levine, to the second meeting. Each new member briefly introduced themself, sharing their location and involvement with WordPress
  • Roadmap and Progress Review Neill McShea shared updates on the project’s progress, including the publication of their roadmap and the merging of the first code PR for the PHP client . Jason Adams noted activity in the providers discussion and mentioned that the topic of which providers to support and who will build the integrations needs further discussion .
  • Provider Integrations Discussion Jason Adams raised concerns about the timing and linear progression of provider integrations, suggesting that it might be better to invite contributions for these integrations rather than letting them hold up the experimental pluginPlugin A 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.. David Levine and Jason Adams agreed that the bi-weekly meeting would be a good venue to continue this discussion, as hosts are already listening in channels and seeking ways to contribute.
  • Meeting Structure and Attendance The team discussed confirming a plan to open the meeting to more attendees using a “panelist idea” proposed by Jonathan. James LePage and Neill McShea are looking into tools for this, aiming to allow wider participation while keeping the meetings focused on concrete progress and avoiding large, unstructured discussions.
  • Defining Contributions and Pathways James LePage emphasized the need for clear pathways and definitions of what constitutes a contribution beyond code, including design and thought, to better harness enthusiasm and guide contributors. Tammie Lister supported this, suggesting that scope should be defined per milestone or project, as different repositories will have different needs, such as documentation or design.
  • GitHub Project Structure Tammie Lister proposed structuring GitHub projects by adapting the best practices from the GutenbergGutenberg The 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/ repository, including labeling, documenting labels, and setting up milestones. This approach aims to guide contributions by clearly indicating where different types of help are needed and providing “good first contribution” areas, especially within the experiments project.
  • DTO Work and Cloud Code Jason Adams updated the team on the Data Transfer Object (DTO) work, describing it as a critical foundational piece that is nearing completion, with the goal to finish all foundational pieces this week. Jason Adams also highlighted the efficiency of using Cloud Code for generating 98% of the code, noting its high cost but effectiveness.
  • Strategic Vision for Providers and Hosts Jason Adams emphasized the need for a vision on how providers fit into the overall WordPress work, including how to involve hosts sooner rather than later to ensure broader adoption of the experimental plugin. James LePage stressed supporting state-of-the-art modalities and playing nicely with self-hosted and open-source solutions, expecting major hosts to adopt the new features immediately.
  • Weekly Goals and Upcoming Meetings James LePage outlined goals for integrating Automatic’s resources into the MCP and Abilities API work, aiming to have usable versions or clear pathways for all three packages by WordCampWordCamp WordCamps 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. US in a month . David Levine offered his free time for contributions, particularly in the Abilities and MCP work and the experiments plugin.
  • Agenda for Bi-Weekly Chat James LePage shared a draft agenda for the upcoming bi-weekly chat, inviting team members to review and suggest additions or restructuring for the discussion. Felix joined late and discussed the DTO pull request review process, with Jason Adams emphasizing the desire to complete foundational work this week.
  • Meeting Notes Publication Neill McShea reminded the team about the idea of publishing meeting agendas and notes on a dedicated page to ensure continuity and accessibilityAccessibility Accessibility (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), with James LePage volunteering to set this up .

Suggested next steps

uncheckedDavid Levine and Matt Batchelder will help with the review of the DTOs.

uncheckedJames LePage will add the discussion about providers to the agenda for tomorrow’s bi-weekly meeting.

uncheckedJason Adams will follow up with Felix regarding the DTO work and finish all foundational pieces this week.

uncheckedJason Adams will schedule synchronous calls with Felix and pingPing The act of sending a very small amount of data to an end point. Ping is used in computer science to illicit a response from a target server to test it’s connection. Ping is also a term used by Slack users to @ someone or send them a direct message (DM). Users might say something along the lines of “Ping me when the meeting starts.” each other on SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ to speed up the review process when Felix has capacity.

uncheckedJames LePage will chat with David Levine about the abilities in MCP and how to tie the experiments plug-in together.

uncheckedJames LePage will spin up a page to publish meeting agendas and notes.

uncheckedTammie Lister and Neill McShea will lead the implementation of the GitHub project structure, starting by sharing the plan tomorrow and then iterating in public.

#check-in, #core-ai

Jonathan Bossenger 7:20 am on 31 July 2025
Tags: , , ,   

AI Chat Summary – 24 July 2025

Location: #core-ai Slack Channel 

Agenda: AI Chat Agenda – 24 July 2025

The bi-weekly WordPress CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. AI meeting on July 24, 2025, focused on the AI Building Blocks roadmap. Key celebrations included the publication of the roadmap, all four repositories going live, the first PHPPHP PHP (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 PR being merged, and the growing community interest.

The four interconnected AI Building Blocks discussed are:

  1. PHP AI Client: A provider-agnosticProvider-Agnostic Software design that works with multiple service providers without being tied to one. Recommended for WordPress AI integrations. LLM interface that provides a unified way to interact with LLMs, inferring model requirements based on prompts.
  2. Abilities API: Creates a central registry for WordPress capabilities, making them discoverable and accessible to AI agents and automation tools. This transforms WordPress into a unified system for AI interaction and will allow plugins to expose their functionalities. A key consideration is ensuring careful implementation when AI agents are given editing abilities, potentially leveraging the RevisionsRevisions The WordPress revisions system stores a record of each saved draft or published update. The revision system allows you to see what changes were made in each revision by dragging a slider (or using the Next/Previous buttons). The display indicates what has changed in each revision. APIAPI An 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..
  3. MCP Adapter: Implements the Model Context Protocol (MCP) to connect WordPress with external AI assistants like Claude and ChatGPT, enabling them to discover and execute actions on a WordPress site. WordPress aims to act as both an MCP serverMCP Server Exposes tools, resources, and prompts according to Model Context Protocol specification. WordPress can run multiple MCP servers with different configurations. (exposing its functionality) and client (connecting to other MCP servers).
  4. AI Experiments: A pluginPlugin A 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. that brings all AI Building Blocks together into practical implementations, serving as WordPress’s AI laboratory and a reference for developers. (This segment was cut short due to time constraints but details were provided for async exploration).

Discussions also touched upon:

  • Local AI Inference: The PHP Client will support local models, with specifics on how this will be surfaced in the AI Experiments pluginAI Experiments Plugin WordPress's AI laboratory bringing all building blocks together. Serves as both a user tool and developer reference implementation. First release (v0.1.0) includes Title Generation experiment. yet to be determined.
  • Privacy: The use of site-specific WordPress data by AI agents raises privacy concerns, emphasizing the need for isolated and smart implementations.
  • PHP Version Support: The current PHP AI Client is built with PHP 7.4 backward compatibility, with plans to align with WordPress Core’s PHP requirements when considering merging into Core.
  • Distribution Strategy: The AI Building Blocks will be distributed as Canonical and Feature Plugins using Composer packages, allowing developers to use them in production before potential inclusion in WordPress Core.

Attendees were encouraged to continue discussions on GitHubGitHub GitHub 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/ issues for the individual projects and in the #core-ai SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ channel. The next chat is scheduled for August 7.

#core-ai, #docs, #meeting, #summary

James LePage 9:09 pm on 23 July 2025
Tags: , ,   

AI Chat Agenda – 24 July 2025

The next WordPress AI Chat will take place on Thursday July 24, 2025 at 16:00 UTC in the #core-ai channel on Make WordPress SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/.

The live meeting will focus on discussing the AI Building Blocks roadmap published last week. We’ll dedicate approximately 10 minutes to each of the four projects for focused discussion. The various curated agenda sections below refer to additional items.

Announcements

  • AI Building Blocks for WordPress published July 17, 2025
  • Repository setup complete
  • First Code committed for the PHP AI Client SDKPHP AI Client SDK A platform-agnostic library providing unified access to LLMs and embedding models from any major AI provider. Developed collaboratively with the PHP community. The WordPress AI Client SDK is the WordPress-specific package that adds REST API endpoints, API key management, and integrations through `AI_Client::prompt()`.!

Pre-meeting preparation: Please review the AI Building Blocks article and individual project documentation before the meeting to maximize discussion time.

Discussions

The discussion section of the agenda is for discussing important topics affecting the AI Building Blocks roadmap. To nominate a topic for discussion, please leave a comment on this agenda with a summary of the topic, any relevant links that will help people get context for the discussion, and what kind of feedback you are looking for from others participating in the discussion.

Roadmap Overview (5 minutes)

Quick recap of the overarching vision, who this work is for, and how the building blocks work together. Overview of repos, and project management.

Project Deep Dives (40 minutes)

We’ll spend ~10 minutes on focused discussion for each project:

  • Abilities APIAbilities API A 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.
  • MCP AdapterMCP Adapter Translates 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.
  • AI Experiments PluginAI Experiments Plugin WordPress's AI laboratory bringing all building blocks together. Serves as both a user tool and developer reference implementation. First release (v0.1.0) includes Title Generation experiment.
  • PHP AI Client SDK

Topics may include technical implementation, integration considerations, open questions, and community concerns specific to each project.

Cross-cutting Themes

Several broader questions have emerged that affect multiple projects:

  • Distribution and packaging strategies
  • Who we’re building for
  • Integration with WordPress CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. roadmap
  • Protocol and standard considerations
  • Timeline and milestone planning

Getting Involved

Updates on contribution opportunities and how to participate in the Building Blocks development.

Progress Update

Current state of development across all four projects, including wins and challenges.

Next Steps

Immediate priorities and action items coming out of this discussion.

Open Floor

Any topic can be raised for discussion in the comments, please indicate whether you intend to be available during the meeting for discussion or will be async.

#agenda, #core-ai, #meeting

Jeffrey Paul 9:00 am on 17 July 2025
Tags:   

AI Experiments Plugin

This is part of the AI Building Blocks for WordPress initiative. The main projects are PHP AI Client SDKPHP AI Client SDK A platform-agnostic library providing unified access to LLMs and embedding models from any major AI provider. Developed collaboratively with the PHP community. The WordPress AI Client SDK is the WordPress-specific package that adds REST API endpoints, API key management, and integrations through `AI_Client::prompt()`., Abilities APIAbilities API A 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., MCP AdapterMCP Adapter Translates 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 the AI Experiments PluginAI Experiments Plugin WordPress's AI laboratory bringing all building blocks together. Serves as both a user tool and developer reference implementation. First release (v0.1.0) includes Title Generation experiment..

Introduction

The AI Experiments Plugin (GitHub) is where all AI Building Blocks come together into something tangible and real.  While the APIs and bridges provide infrastructure, the AI Experiments Plugin demonstrates what’s actually possible when these technologies work in harmony.  It combines the PHP AI Client SDK APIAPI An 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., Abilities API, and MCP Adapter into a meaningful presentation that delivers helpful AI features today while exploring tomorrow’s capabilities.

Bringing It All Together

The power of the AI Building Blocks lies not in any single component but in how they work together. The AI Experiments Plugin demonstrates this synergy through practical implementations that users can experiment with immediately.

Through the PHP AI Client, the pluginPlugin A 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. offers a choice where users can connect their preferred AI providerProvider An AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI). and switch between them seamlessly.  Through the Abilities API, the plugin understands WordPress capabilities and makes them accessible to AI.  Through the MCP Adapter, the plugin connects to external MCP Servers and Clients that can help manage WordPress sites.  Each building blockBlock Block 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. contributes essential functionality, creating experiences that would be impossible with any component alone.

The near term roadmap focuses on exploration and discovery.  Users can experiment with different AI models, test how AI can enhance their WordPress workflows, and understand the potential of AI-powered content creation.  It’s a playground where the future of WordPress AI takes shape through real-world usage and feedback.

Why We’re Building This

We’re building the AI Experiments plugin to demonstrate how developers and agencies can use the new AI APIs from the WordPress AI team, deliver essential AI features directly in the WordPress admin and editor experiences, and provide a possible path to future coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. inclusion.  We’re committed to building the plugin transparently and with broad community feedback.

A Foundation for the Future

While today’s AI Experiments Plugin will demonstrate the current capabilities of the AI Building Blocks, it’s designed to evolve into something much more significant.  As outlined in the Phase 3: Collaboration roadmap, AI will become integral to how people interact with WordPress.

Through this plugin, we plan to explore how AI can interact with portions of the new Site Admin interface – for example, an AI agentAI Agent An AI system that autonomously performs tasks and interacts with systems through available tools and resources. can help users manage their sites through natural conversation.  In the GutenbergGutenberg The 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/ editor, we should explore how AI can participate in real-time collaboration, working alongside humans to create content.  Through the Async Commenting system, users could assign tasks to AI, which could then create suggestions and proposed revisionsRevisions The WordPress revisions system stores a record of each saved draft or published update. The revision system allows you to see what changes were made in each revision by dragging a slider (or using the Next/Previous buttons). The display indicates what has changed in each revision..  In the Media Library, AI can help with creation, editing, auto-captioning, and intelligent organization.

There’s a lot to explore and experiment with when it comes to AI and WordPress.  By starting with a Experiments plugin that demonstrates possibilities, we can learn what works, gather feedback, and ensure that AI enhances rather than complicates the WordPress experience. As these experiments mature and solidify, we may publish a Canonical AI Features Plugin and/or explore merging indvidual AI feature to WordPress core.

Getting Involved

The AI Experiments Plugin is where ideas become reality and experiments shape the future.  Whether you’re curious about AI in WordPress, have ideas for new features, or want to contribute to the design and development, your involvement matters.  We’re eager for feedback from designers, accessibilityAccessibility Accessibility (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) experts, content creators, and developers on the planned UXUX UX 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. flows, accessibility considerations, and feature approaches.  We plan to share wireframes and early design explorations soon, and your input will help shape the direction before we move into development.  As work evolves, we’ll post to Make/AI with progress updates and calls-for-testing posts as an entry point for broader contributor involvement.

Join us in #core-ai on SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/, explore the development work, or simply experiment with the plugin and share your feedback.  Together, we’re not just building a plugin, we’re defining how millions of people will work with AI in WordPress.

#ai-building-blocks

Felix Arntz 9:00 am on 17 July 2025
Tags:   

PHP AI Client

This is part of the AI Building Blocks for WordPress initiative. The main projects are PHP AI Client SDKPHP AI Client SDK A platform-agnostic library providing unified access to LLMs and embedding models from any major AI provider. Developed collaboratively with the PHP community. The WordPress AI Client SDK is the WordPress-specific package that adds REST API endpoints, API key management, and integrations through `AI_Client::prompt()`., Abilities APIAbilities API A 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., MCP AdapterMCP Adapter Translates 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 the AI Experiments PluginAI Experiments Plugin WordPress's AI laboratory bringing all building blocks together. Serves as both a user tool and developer reference implementation. First release (v0.1.0) includes Title Generation experiment..

Introduction

The PHP AI Client SDK (GitHub) provides shared infrastructure that lets WordPress plugins and other PHPPHP PHP (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 projects integrate AI capabilities rapidly and flexibly. Similar to projects like the Vercel AI SDK, it offers a unified interface that works across all AI providers – from simple text generation to complex multimodal operations, streaming responses, and long-running tasks.

Developers specify what AI capabilities they need, and users manage their providerProvider An AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI). credentials in one place. Those credentials then work automatically across all compatible plugins on their site.

The SDK addresses both user needs and developer needs:

  • A provider-agnosticProvider-Agnostic Software design that works with multiple service providers without being tied to one. Recommended for WordPress AI integrations. approach puts the user first. The WordPress site administrator(s) choose which provider and/or model they want to configure and use, and they can provide APIAPI An 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. credentials in a single place. Any plugins with AI features just work. No more vendor lock-in.
  • Developers can focus on building AI features, not AI infrastructure. Instead of trying to find an unofficial SDK for a single provider or having to even build it yourself, the SDK gives developers the central infrastructure to get started quickly and focus on the user benefits rather than their own pluginPlugin A 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.’s technical plumbing. No more reinventing the wheel.

How It Works

The API adapts to different developer needs. Some plugin solutions may require specific models, while others just need any text completion capability. The PHP AI Client SDK handles all the complexity behind the scenes. Different authentication methods, API formats, streaming protocols, and provider quirks all work through the same clean interface.

Here is a simple tentative code example for generating text using a specific model:

$text = AiClient::prompt('Write a 2-verse poem about PHP.')
    ->usingModel(Google::model('gemini-2.5-flash'))
    ->generateText();

And the same example, but written in a model and provider agnostic way:

$text = AiClient::prompt('Write a 2-verse poem about PHP.')
    ->generateText();

The Problem It Solves

Today, every WordPress plugin with AI features rebuilds the same infrastructure: provider integrations, API key management, response normalization, error handling. Users enter the same credentials multiple times and deal with inconsistent experiences. When providers change their APIs, every plugin breaks separately.

It is worth highlighting that these problems not only exist in WordPress, but in more or less every PHP project that aims to use AI in a provider agnostic way. The only truly provider agnostic SDKs that exist to date are for other tech stacks that are not interoperable with general PHP projects – either different server-side languages (e.g. the Vercel AI SDK for NodeJS) or specific platforms (Drupal’s AI module).

The PHP AI Client SDK centralizes this complexity for the PHP ecosystem, and in WordPress specifically. One integration point handles all providers. One credential system serves all plugins. When providers update or new ones emerge, the changes happen once and benefit everyone. The architecture is designed with latest trends like multimodal-first in mind and even anticipates future shifts like client-side or browser-based AI.

Built Together

The PHP AI Client SDK technically consists of two Composer packages:

  • The underlying PHP package provides the unified AI interface, and it is WordPress agnostic. It is a collaborative effort with the wider PHP community.
  • This is complemented by another WordPress specific package that adds features technically tied to WordPress, such as the shared settings page for AI API credentials, connection to the Abilities API, and the REST APIREST API The 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/ endpoints to use AI capabilities in JavaScriptJavaScript JavaScript or JS is an object-oriented computer programming language commonly used to create interactive effects within web browsers. WordPress makes extensive use of JS for a better user experience. While PHP is executed on the server, JS executes within a user’s browser. https://www.javascript.com as well.

This modular approach means when any community adds a provider or improves performance, everyone benefits while each platform maintains its unique experience.

For WordPress developers, this architecture offers flexibility. Use the WordPress package for the full experience with admin UIUI UI 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., or the underlying PHP package for lower-level projects such as a WP-CLIWP-CLI WP-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/ integration. While also available as a plugin for testing, these Composer packages are the official adoption path – require them today, ship plugins with AI capabilities, and seamlessly transition if these become part of WordPress CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress.. Multiple plugins can use the same packages without conflicts, with Composer handling dependencies.

Moving Forward

As AI becomes essential to WordPress, this SDK provides the sustainable foundation. It’s designed to grow with emerging capabilities – new modalities, advanced features, novel deployment models. The focus now is expanding provider support and refining the developer experience based on real-world usage.

Please join the discussion in #core-ai on SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ or explore the implementation.

#ai-building-blocks

James LePage 9:00 am on 17 July 2025
Tags:   

Abilities API

This is part of the AI Building Blocks for WordPress initiative. The main projects are PHP AI Client SDKPHP AI Client SDK A platform-agnostic library providing unified access to LLMs and embedding models from any major AI provider. Developed collaboratively with the PHP community. The WordPress AI Client SDK is the WordPress-specific package that adds REST API endpoints, API key management, and integrations through `AI_Client::prompt()`., Abilities APIAbilities API A 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., MCP AdapterMCP Adapter Translates 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 the AI Experiments PluginAI Experiments Plugin WordPress's AI laboratory bringing all building blocks together. Serves as both a user tool and developer reference implementation. First release (v0.1.0) includes Title Generation experiment..

Introduction

The power of WordPress, derived from its thousands of functions within coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress., plugins, and themes, is often obscured by its reliance on developer-centric code. The Abilities API (GitHub) addresses this by establishing a shared language, enabling all WordPress components to express their capabilities in a unified manner, comprehensible to both humans and machines.

This APIAPI An 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. creates a centralized registry where all functionalities can be formally registered with well-defined schemas, comprehensive descriptions, and explicit permissions. By adopting this common language, plugins and themes will empower AI-driven solutions to seamlessly discover, interpret, utilize, and coordinate capabilities throughout the entire WordPress ecosystem.

The Challenge We’re Solving

A typical WordPress site might have dozens of plugins, each adding unique functionality. But there’s no standardized way for these components to express their capabilities. An AI assistant has no systematic way to discover that your backup pluginPlugin A 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. can create snapshots, your SEO plugin can analyze content, or your e-commerce solution can generate reports. This fragmentation limits what we can build.

The Abilities API establishes a common pattern the entire ecosystem can adopt. It may look something like this:

// Any plugin can register its abilities with the `init` hook.
wp_register_ability( 'my-seo-plugin/analyze-content-seo', [
    'label'       => __( 'Analyze Content SEO', 'my-seo-plugin' ),
    'description' => __( 'Analyzes post content for SEO improvements.', 
'my-seo-plugin' ),
    'thinking_message' => __('Reviewing your content now!'),
    'success_message' => __('Content reviewed successfully.'),
    'execute_callback'    => [ 'MySEOPlugin', 'analyze_content' ],
    'input_schema'  => [
        'type' => 'object',
        'properties' => [
            'post_id' => [ 'type' => 'integer', 'description' => __( 'The post identifier.', 'my-seo-plugin' ), 'required' => true ],
        ],
        'additional_properties' => false,
    ],
    'output_schema' => ]
        'type' => 'number',
        'description' => __( 'The score for the content in percentage.', 'my-seo-plugin' ),
        'required' => true,
    ],
    'permission_callback'  => 'edit_posts',
] );

When the ecosystem adopts this pattern, WordPress transforms from isolated functionalities into an interconnected system where capabilities can be discovered, composed, and automated. Abilities can be used for AI, but also for things like the Command Palette, Workflows tools, and integrating with UIUI UI 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. like toolbars, menus, etc.

When used for AI, developers can create impressive systems like automation tools and AI agents (leveraging other building blocks, like the PHP AI Client for a LLM-based orchestrator).

Enabling AI Integration

The Abilities API also allows AI systems such as Claude, ChatGPT, Gemini, and other assistants to discover WordPress capabilities through adapters like the MCP Adapter. Once registered, flagged abilities become accessible to any AI system that supports the relevant protocols.

The API manages registration and permissions, while protocol Adapters translate these into formats external AI systems understand. This establishes a robust connection between WordPress functionality and AI assistants, with the first-party API serving as the definitive source for exposed logic.

Developer Adoption and Distribution

While available as a plugin for experimentation, the Abilities API is designed as a Composer package that developers can include in their plugins today. This serves as the official adoption path before potential WordPress core inclusion. Developers can require the package now, ship plugins with standardized capability declarations, and seamlessly transition when the Abilities API becomes part of WordPress itself.

Getting Involved

The Abilities API needs input from across the WordPress ecosystem. Whether you’re a plugin developer exposing functionality, a theme author registering visual capabilities, or building AI solutions for WordPress, your perspective is crucial.

Join the discussion in #core-ai on SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/, explore the early implementation, or share your vision for how WordPress Abilties should work in our future with AI.

#ai-building-blocks

Pascal Birchler 9:00 am on 17 July 2025
Tags:   

MCP Adapter

This is part of the AI Building Blocks for WordPress initiative. The main projects are PHP AI Client SDKPHP AI Client SDK A platform-agnostic library providing unified access to LLMs and embedding models from any major AI provider. Developed collaboratively with the PHP community. The WordPress AI Client SDK is the WordPress-specific package that adds REST API endpoints, API key management, and integrations through `AI_Client::prompt()`., Abilities APIAbilities API A 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., MCP AdapterMCP Adapter Translates 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 the AI Experiments PluginAI Experiments Plugin WordPress's AI laboratory bringing all building blocks together. Serves as both a user tool and developer reference implementation. First release (v0.1.0) includes Title Generation experiment..

Introduction

Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context to LLMs. In WordPress, the MCP Adapter (GitHub) implements this open standard, exposing Abilities to AI assistants, while also connecting to other MCP servers.

MCP’s applications are transformative for various users. Content creators can manage their WordPress sites conversationally, while developers can automate complex workflows across systems. Agencies can build sophisticated integrations, from content migrationMigration Moving the code, database and media files for a website site from one server to another. Most typically done when changing hosting companies. to performance optimization.

Consider a typical workflow: an AI assistant receives a request to publish a blog post. Through MCP, it can research topics using external tools, generate content, create images, optimize for SEO, and schedule publication. This entire process happens via natural conversation, respecting permissions and requiring approval when configured.

Two-Way Communication

WordPress can operate as both an MCP serverMCP Server Exposes tools, resources, and prompts according to Model Context Protocol specification. WordPress can run multiple MCP servers with different configurations. and client, exposing its functionality and connecting to other tools within the MCP ecosystem. This bidirectional functionality allows major AI applications and assistants to discover and directly execute actions on your WordPress site.

As an MCP server, WordPress makes its capabilities registered via the Abilities API available as MCP tools and resources. AI assistants can discover, understand, and execute actions like creating posts, managing media, and moderating comments, all through the standardized protocol.

As an MCP clientMCP Client AI agents, IDEs, or assistants that connect to MCP servers to access capabilities., WordPress can integrate with other MCP servers. Your site (though an embedded Agent, REST API, WP-CLI, PHPPHP PHP (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 functions…) could leverage AI writing tools for content, specialized services for data analysis, or project management systems, becoming an active participant in a network of interconnected capabilities.

To start, we will focus on building the server side of the MCP Adapter.

Flexible Transport and Security

As an MCP server, WordPress supports the Streamable HTTPHTTP HTTP 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. transport via the existing REST APIREST API The 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/ as well as the stdio transport via WP-CLIWP-CLI WP-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/. This ensures compatibility with the wider MCP ecosystem and enables compatibility with local development.

For security, the MCP adapter will leverage the built-in application password mechanism for authentication and the capabilities system for granular authorization. When acting as a MCP Client, we plan for WordPress to implement common user approval controls.

Building for Tomorrow

MCP is a rapidly evolving protocol. The WordPress MCP implementation is designed for adaptability, ensuring it can accommodate future changes and emerging standards. This is achieved through the underlying Abilities API, which represents WordPress functionality in a standard-agnostic way. The MCP adapter translates this functionality into MCP’s format, but other adapters could be developed for different protocols as they emerge.

This approach future-proofs WordPress for an AI-driven world. It allows for quick adaptation to new AI systems and protocols without requiring a restructuring of coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. functionality.

Getting Started

The MCP Adapter requires the Abilities API to expose WordPress functionality and works seamlessly with the PHP Client SDK and AI Experiments Plugin. Whether you’re connecting your site to AI assistants, building AI-powered applications, or contributing to development, join us in #core-ai on SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/ or explore the MCP adapter code.

The future of WordPress is one where sites and AI assistants work together as partners. The MCP Adapter is making that future possible today.

#ai-building-blocks

James LePage 8:59 am on 17 July 2025
Tags: , core   

AI Building Blocks for WordPress

As the open web evolves in the era of AI, WordPress must keep pace. To ensure our CMS remains the leading solution to democratize publishing, we are creating and maintaining a collection of projects that form technical Building Blocks for AI within the WordPress project.

These Building Blocks will allow users and developers alike to create powerful AI implementations within WordPress – pushing the CMS to serve more needs and be even more flexible than it already is. We have three immediate focuses and four deliverables. When used together, each contributes the required functionality to create anything from AI features, to workflows, to agents, both inside and outside of the software.

Each Building BlockBlock Block 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. is listed below with a short description and a more detailed overview article linked for further reading.

PHP AI Client SDK

The PHP AI Client SDKPHP AI Client SDK A platform-agnostic library providing unified access to LLMs and embedding models from any major AI provider. Developed collaboratively with the PHP community. The WordPress AI Client SDK is the WordPress-specific package that adds REST API endpoints, API key management, and integrations through `AI_Client::prompt()`. is an abstraction to interact with LLMs and embedding models from any major providerProvider An AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI). in a unified way. This allows developers to implement AI-powered features rapidly while giving users the freedom to choose their preferred AI provider and/or model.

We’re building this as two distinct Composer packages: a platform-agnostic PHP AI Client SDK developed collaboratively with the wider PHPPHP PHP (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 community, and a WordPress-specific package that adds REST APIREST API The 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/ endpoints, APIAPI An 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. key management, and other foundational WordPress integrations. This approach ensures broad PHP ecosystem compatibility while providing seamless WordPress experiences.

Abilities API

The Abilities APIAbilities API A 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. transforms WordPress from a collection of isolated functions into a unified, discoverable system. By creating a central registry of capabilities, it allows AI agents, automation tools, and developers to understand and interact with everything WordPress can do – from CLICLI Command Line Interface. Terminal (Bash) in Mac, Command Prompt in Windows, or WP-CLI for WordPress. commands and REST API endpoints to custom logic and pluginPlugin A 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. functions.

MCP Adapter

The MCP (Model Context Protocol) Adapter allows WordPress to connect to AI assistants like Claude and ChatGPT. It builds on the Abilities API to translate selected WordPress server-side abilities into a MCP serverMCP Server Exposes tools, resources, and prompts according to Model Context Protocol specification. WordPress can run multiple MCP servers with different configurations. that exposes them as tools and resources.

Rather than hard-coding support for specific standards, we create Adapters, like this one, that translate between the Abilities API and external protocols. The MCP adapterMCP Adapter Translates 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. is our first and most important implementation, positioning WordPress at the forefront of AI integration while maintaining the flexibility to support future standards.

AI Experiments Plugin

The AI Experiments PluginAI Experiments Plugin WordPress's AI laboratory bringing all building blocks together. Serves as both a user tool and developer reference implementation. First release (v0.1.0) includes Title Generation experiment. brings together all the AI Building Blocks into a unified experience. It serves as both a powerful tool for users and a reference implementation for developers, demonstrating how the PHP AI Client SDK, Abilities API, and MCP Adapter work together in practice.

Starting as WordPress’s AI laboratory for experimentation, the plugin may evolve into a full-fledged AI Feature PluginFeature Plugin A plugin that was created with the intention of eventually being proposed for inclusion in WordPress Core. See Features as Plugins. It can provide an AI playground, WP-CLIWP-CLI WP-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/ integration, intelligent agents, and visual workflow builders – everything needed to explore and implement AI capabilities in WordPress.

To avoid early lock-in and maintain flexibility as AI technology rapidly evolves, we will use Canonical and Feature Plugins as a way to distribute these features to end consumers, while encapsulating the coreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. functionality and logic of the API projects in Composer packages. This makes it easy for plugin developers to use these official Building Blocks even before they are considered for WordPress Core. It is extremely important that developers can and do use these projects in production, and the approach of using Composer packages is our answer to this – aligning with our “canonical first, Core when ready” philosophy.

This work directly overlaps with some of the largest components of the Phase 3: Collaboration roadmap. It unlocks unique, futuristic capabilities that can be added through plugins. Here are some examples:

Site Admin

We must plan for these building blocks to be surfaced to end users in this new Site Admin interface. We hope to make it easy for developers to create AI Agents, chatbots, workflow automations and more, using the AI Building Blocks, and surfacing functionality through the new Site Admin UIUI UI 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..

Real-Time and Asynchronous Collaboration

A logical and non-disruptive implementation of AI is within the Post Editor, specifically surfacing through Real-Time Collaboration and Commenting. Instead of working with human counterparts, comments could be assigned to AI, which would work to resolve them, creating a suggestion or proposed revision. Instead of collaborating in real time with people, why not collaborate with AI?

Media Library

Using AI to create and edit media is becoming increasingly popular. Additionally, there are many smaller implementations that AI could help with: auto alt text and captioning, intelligent grouping, multimodal search capabilities, and more.

It’s our intention to craft our projects with the end implementations in mind. By WordPress version 7.0, any WordPress user – enterprise or blogger, developer or designer – should be able to access, use, and build powerful AI features to aid in furthering their digital presence on the open web. Before that, product owners and plugin developers will have a robust toolkit to build AI features into their own offerings, which will work seamlessly with whatever core additions we may make in the future.

How this is made available to Core is still an open question, as is much with such fundamental releases on the horizon. Over the next several months, we’ll explore which building blocks and features should be merged to Core or remain canonical. Questions like “should AI providers and content generation be included in Core,” “do we add an AI AgentAI Agent An AI system that autonomously performs tasks and interacts with systems through available tools and resources. as a canonical plugin,” and “which protocols should we support” will surface and be addressed in Hallway Hangouts, Make proposals, and #core-ai discussions.

We invite you to join in on the work and discussions. This journey will shape how millions publish and share ideas on the open web, and we can’t do it alone. Join the #core-ai channel on WordPress SlackSlack Slack is a Collaborative Group Chat Platform https://slack.com/. The WordPress community has its own Slack Channel at https://make.wordpress.org/chat/, open GithubGitHub GitHub 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/ Issues, or begin contributing to the projects to help us build the next generation of AI tools for WordPress.

Resources and Repositories

Repositories

Reference Implementations

– The WordPress AI Team: Jeff, Felix, Pascal, James

#ai-building-blocks, #core
Jonathan Bossenger 2:06 pm on 11 July 2025
Tags: , , ,   

AI Chat Summary – 10 July 2025

Location: #core-ai Slack Channel

Agenda: No formal agenda

This summary covers the key discussion points from the last bi-weekly AI chat in the Make WordPress SlackSlack Slack 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 PHP AI Client SDKPHP AI Client SDK A platform-agnostic library providing unified access to LLMs and embedding models from any major AI provider. Developed collaboratively with the PHP community. The WordPress AI Client SDK is the WordPress-specific package that adds REST API endpoints, API key management, and integrations through `AI_Client::prompt()`..

1. PHP AI Client SDK – Project Status and Discussion

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 APIAPI An 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. 
  • The distinction between the two API surfaces is outlined in the SDK’s architecture requirements.

3. Fluent API vs. Traditional Method Calls

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 providerProvider An AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI).. 
  • @jason_the_adams elaborated on three types of prompt returns:
    • 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 CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress./GutenbergGutenberg The 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 GitHubGitHub GitHub 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/ discussions for these asynchronous conversations, a proposal @karmatosed welcomed.

Props to @jeffpaul for review.

#core-ai, #docs, #meeting, #summary