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 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/preface.php. AI Client SDK, Abilities 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., MCP Adapter, and the AI Experiments 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.

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 API, 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 plugin offers a choice where users can connect their preferred AI provider 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 agent 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 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/preface.php. AI Client SDK, Abilities 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., MCP Adapter, and the AI Experiments 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.

Introduction

The PHP AI Client SDK (GitHub) provides shared infrastructure that lets WordPress plugins and other 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 provider 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-agnostic 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 API 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 plugin’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 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/preface.php. AI Client SDK, Abilities 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., MCP Adapter, and the AI Experiments 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.

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 API 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 plugin 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' ),
    'thinkingMessage' => __('Reviewing your content now!'),
    'successMessage' => __('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 ],
        ],
        'additionalProperties' => 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 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/preface.php. AI Client SDK, Abilities 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., MCP Adapter, and the AI Experiments 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.

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 server 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 client, WordPress can integrate with other MCP servers. Your site (though an embedded Agent, REST API, WP-CLI, 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 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/preface.php. AI Client SDK is an abstraction to interact with LLMs and embedding models from any major provider 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 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 API 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 server 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 adapter 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 Plugin 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 Agent 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 be 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

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 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/preface.php. AI Client SDK.

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 provider. 
  • @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 be 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

Tammie Lister 9:40 pm on 26 June 2025
Tags: , , ,   

AI Chat Summary – 26 June 2025

Location: #core-ai Slack Channel

Agenda: AI Chat Agenda – 26 June 2025

Project Administration

  • @isotropic outlined 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 be the repository owner. https://github.com/ project setup to coordinate WordPress AI efforts.
  • Introduced the new php-ai-client GitHub repository.
  • Plans for related repos for other “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.” focuses such as MCP and unified tool registry.

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

  • @flixos90 described the php-ai-client as:
    • A platform-agnostic PHP SDK for connecting to AI models.
    • Designed to be extensibleExtensible This 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.

  • @flixos90 introduced provider inclusion strategies:
    • No providers bundled (all external).
    • All providers bundled (with strict criteria).
    • Selective bundling based on clear criteria.
    • 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 migrationMigration Moving 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.
  • @isotropic favored:
    • 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.
  • @jeffpaul referenced WordPress’s OEmbed provider process as a precedent: WordPress Core Trac Ticket #58840
  • Roadmap outlined for integrating AI features into WordPress with no near-term coreCore Core 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.
  • @isotropic and @flixos90 discussed:
    • Host registration of providers versus proxying.
    • 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 Plugin A 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.
  • @flixos90 and @isotropic agreed:
    • Phased approach with separate packages.
    • No immediate core merge planned.
    • WordPress-specific code expected to ship initially as a Feature Plugin.

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

  • @jason_the_adams expressed enthusiasm for REST API specification residing in the php-ai-client repo: REQUIREMENTS.md in php-ai-client
  • @flixos90 agreed:
    • It’s a good idea worthy of further discussion.
    • Leans pragmatic but sees broader specification’s scalability benefits.
    • Encouraged ongoing discussions in php-ai-client GitHub repository
  • @justlevine hopes:
    • REST handling remains outside core SDK.
    • WPGraphQL aims to offer 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. parity.
  • @jason_the_adams committed to raising topics as GitHub issues.

Props to @jeffpaul for review.

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

Jeffrey Paul 8:36 pm on 25 June 2025
Tags: , ,   

AI Chat Agenda – 26 June 2025

The next WordPress AI Chat will take place on Thursday June 26, 2025 at 16:00 UTC in the core-ai channel on Make WordPress Slack.

The live meeting will focus on what we plan to build and have an open floor section.  The various curated agenda sections below refer to additional items.

Announcements

Discussions

The discussion section of the agenda is for discussing important topics affecting the newly formed AI Team and their forthcoming initiatives.  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.

Cross-team collaboration

Continue identifying ways the AI team can collaborate with other Make Teams to bring AI-powered functionality and assistance to their needs.  Examples could be (1) assisting 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 Review Team with AI-based reviews in tandem with their human-based reviews, (2) assisting the CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. Team (and others) with triaging tickets in their backlog.

Checkin on prior next steps

  • Decide 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 be the repository owner. https://github.com/ 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 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/preface.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 MySQLMySQL MySQL 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/. 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.

Next Steps

  • Goals for the next few weeks (updates on Features/Abilities 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. and MCP)

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

Isotta Peira 1:06 pm on 23 June 2025
Tags: make.wordpress.org/community,   

X-post: The Incident Response Team is looking for new members

X-comment from +make.wordpress.org/community: Comment on The Incident Response Team is looking for new members

Tammie Lister 10:29 pm on 13 June 2025
Tags: , , ,   

AI Chat Summary – 12 June 2025

Location: #core-ai Slack Channel

Theme: Next Steps After 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. 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

CoreCore Core 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:

  1. Provider-Agnostic LLM Client Abstraction – A shared 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/preface.php. abstraction layer for interacting with different LLM providers.
  2. Tool & Resource Definition / Registration – A system to register site features (“abilities”) that LLMs can understand and interact with.
  3. Integration Bridges (e.g., MCP) – Support for protocols like MCP to connect WordPress to external AI tools and ecosystems.

A showcase 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 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 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.: 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 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 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.org The 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.
  • @isotropic: pointed to dosu.dev as a model.
  • @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 MySQLMySQL MySQL 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.
    • Noted MySQL 9’s experimental vector data types.
  • @isotropic: shared past prototype wpvdb.
    • Suggested future support for vector/hybrid search in WP_Query or 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/..
  • @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.

Props to @jeffpaul for review.

#core-ai, #meeting, #summary