For years, WordPress site owners and developers who wanted to add AI capabilities to their websites had to navigate a fragmented, often frustrating landscape. Each third-party plugin handled its own API integrations. Credentials were stored in different places across different plugins. When OpenAI updated its API or Anthropic released a new Claude model, every plugin that relied on those providers had to be individually updated — and in many cases, those updates came slowly, if at all. Site owners often entered the same API keys into three or four different plugins, each one managing credentials in its own way, each one subject to its own security vulnerabilities.
That pattern is now changing in a concrete way. The WordPress core AI team has officially released three standalone plugins on WordPress.org — one for Anthropic Claude, one for Google Gemini, and one for OpenAI — that work together with the newly introduced PHP AI Client SDK to give the entire WordPress ecosystem a shared, standardized foundation for AI integration. These are not third-party tools built by independent developers. They are official plugins maintained by the WordPress AI team itself, published on WordPress.org, and designed to become part of how WordPress handles AI at the infrastructure level.
This guide covers what these plugins are, how they work technically, what features each one provides, what the requirements are to use them, how they relate to upcoming changes in WordPress 7.0, and what the implications are for site owners, plugin developers, and anyone building on WordPress going forward.
The Three Official WordPress AI Provider Plugins
The three plugins now available on WordPress.org are:
AI Provider for Anthropic — available at wordpress.org/plugins/ai-
Each plugin serves a single, focused purpose: registering a specific AI provider — Anthropic’s Claude, Google’s Gemini, or OpenAI’s GPT family — with the WordPress PHP AI Client SDK. Once registered, that provider’s models become available to any plugin on the site that is built using the SDK. A plugin developer writing an AI-powered feature no longer needs to write their own OpenAI integration or their own Anthropic client. They write to the SDK’s unified interface, and whichever provider the site owner has configured is used automatically.
This is a meaningful architectural decision, not just a convenience. The approach decouples the concern of “which AI service are we using” from the concern of “what are we building with AI.” A plugin that generates SEO-optimized blog post titles, for instance, does not need to know whether the site is running Claude or GPT. It simply makes a text generation request through the SDK, and the SDK routes it to whichever provider has been configured and has working credentials.
What You Need to Get Started
The technical requirements to use any of the three plugins are modest. Your server needs to be running PHP 7.4 or higher, which is a widely-supported baseline — most modern WordPress hosting environments meet this requirement without any configuration changes.
You will also need an API key from the respective AI provider. For the Anthropic plugin, that means an API key from Anthropic’s Console (console.anthropic.com). For the Google plugin, you’ll need a Google AI Studio API key or a Google Cloud API key with the appropriate Gemini API access enabled. For the OpenAI plugin, a standard OpenAI API key from platform.openai.com is required. These API keys are what authorize your WordPress site to make requests to the respective AI service, and you are responsible for the costs associated with those API calls according to each provider’s pricing.
The third requirement depends on which version of WordPress you’re running. On WordPress 6.9 — the version released in December 2025 and codenamed “Gene” — the PHP AI Client SDK is not yet part of WordPress core, so you will need to install it separately. The SDK is available as a plugin from GitHub (github.com/WordPress/php-ai-
For developers building plugins today, the recommended adoption path is to require the WordPress AI Client SDK via Composer as a package dependency. This allows plugins to ship with AI capabilities right now and transition cleanly to the core-integrated SDK when WordPress 7.0 arrives, without any breaking changes.
Feature Breakdown: What Each Plugin Actually Does
Each of the three provider plugins has its own feature set, reflecting the capabilities of the underlying AI service. The overlap is significant — all three support text generation and function calling, for instance — but the differences are real and worth understanding before you decide which provider to configure.
AI Provider for OpenAI
The OpenAI plugin is the most feature-rich of the three at this point, which reflects OpenAI’s relatively broad API surface area. Its capabilities include:
Text generation with GPT models. The plugin gives you access to OpenAI’s GPT model family for generating text. According to the official plugin description, available models are “dynamically discovered from the OpenAI API” — meaning the list of accessible models updates automatically as OpenAI releases new versions, without requiring a plugin update. This is an important detail. You do not need to wait for the plugin maintainers to push an update every time OpenAI releases a new GPT model. The model list refreshes on its own, cached for approximately one day.
Image generation with DALL-E and GPT Image models. The plugin enables image generation directly through the WordPress AI Client SDK, using OpenAI’s DALL-E models and, where available, GPT Image models. This opens the door for plugins to offer image creation functionality without building their own OpenAI API integration.
Text-to-speech (TTS). The OpenAI plugin also exposes TTS models through the SDK. This means plugins built on the WordPress AI Client can offer voice narration features, audio content generation, or accessibility-focused text-to-audio conversion using OpenAI’s TTS capabilities.
Web search support. This is a notable addition. The OpenAI plugin supports web search, which allows the AI’s responses to be grounded in current, real-time information rather than limited to training data. This capability is particularly valuable for plugins handling time-sensitive content — news summaries, current event commentary, or any use case where up-to-date information matters.
Function calling support. Function calling enables the AI model to trigger specific actions within your application based on the structure of a conversation or prompt. Rather than simply generating text, the model can be asked to call defined functions with structured parameters — a capability that forms the foundation for AI agents and automation workflows. The OpenAI plugin brings this capability to WordPress sites running the SDK.
Automatic provider registration. All three plugins share this feature: when the plugin is installed and activated, it automatically registers itself with the PHP AI Client SDK. No manual configuration beyond providing your API key is required to make the provider visible and available to SDK-compatible plugins on your site.
AI Provider for Anthropic (Claude)
The Anthropic plugin brings Claude’s distinctive capabilities to WordPress. Its feature set includes text generation with Claude models, function calling support, and automatic provider registration. The standout feature unique to this plugin is extended thinking support.
Extended thinking is a Claude capability that allows the model to work through complex problems step by step before generating a final response. Rather than producing an answer immediately, Claude reasons through the problem internally, then delivers a more considered output. For use cases that require careful reasoning — legal summaries, complex research tasks, multi-step problem-solving, nuanced editorial tasks — this capability can produce noticeably different results than standard text generation. The WordPress plugin exposes this capability through the SDK so that plugin developers can leverage it when appropriate.
The Claude models available through the plugin are also dynamically discovered, following the same pattern as the OpenAI plugin. As Anthropic releases new Claude versions, those models become accessible through the plugin without requiring updates.
One thing to note about the Anthropic plugin is that it does not currently include image generation support. Claude’s primary strength is text and reasoning, and Anthropic does not currently offer an image generation model equivalent to DALL-E or Imagen in its standard API. This means if your WordPress use case requires image generation, you would need to configure either the OpenAI or Google provider plugin alongside the Anthropic plugin, or rely on the SDK’s model fallback logic.
AI Provider for Google (Gemini)
The Google provider plugin integrates Google’s Gemini family of models with WordPress. It supports text generation with Gemini models, function calling, automatic provider registration, and image generation using Google’s Imagen models.
Imagen is Google’s dedicated image generation system, distinct from Gemini itself. The ability to generate images via Imagen through the same WordPress AI Client SDK interface as text generation from Gemini is a useful unified capability for site builders. Developers building plugins that combine text and image generation — a blog post generator that also creates a featured image, for example — can do both through a single SDK interface, regardless of whether the underlying models come from Google, OpenAI, or any other provider.
Gemini models, like the OpenAI and Claude models, are dynamically discovered from Google’s API. The model list stays current without plugin updates, following the same caching architecture used across all three provider plugins.
The PHP AI Client SDK: The Infrastructure Behind It All
To understand why the release of these plugins matters beyond simple convenience, it helps to understand what the PHP AI Client SDK actually is and what problem it was designed to solve.
Before the SDK existed, every WordPress plugin that wanted to use AI had to build its own integration layer. A plugin developer wanting to call GPT had to write their own OpenAI API client, manage their own authentication logic, handle their own error responses, and figure out their own streaming implementation. If the developer wanted to support multiple providers — giving users a choice between Claude and GPT, for instance — they had to maintain parallel implementations for each one. When a provider changed its API, the plugin broke and needed a hotfix. When a new, better model was released, the plugin had to be updated to add it.
Users on the receiving end of this fragmented ecosystem experienced it as credential fatigue. If you ran an AI content generator plugin, an AI SEO tool, and an AI chatbot on the same WordPress site, you were likely managing three separate sets of API keys in three separate settings panels. Each plugin might be using a different version of the same provider’s API. The same OpenAI key might be stored in three different locations, each with its own handling and its own potential security surface.
The PHP AI Client SDK addresses this by providing a single integration layer that sits between WordPress and the AI providers. The official documentation describes it as providing “shared infrastructure that lets WordPress plugins and other PHP projects integrate AI capabilities rapidly and flexibly,” offering “a unified interface that works across all AI providers — from simple text generation to complex multimodal operations, streaming responses, and long-running tasks.”
The SDK is actually composed of two Composer packages working together. The lower-level package is a pure PHP library, provider-agnostic and WordPress-independent, developed collaboratively with the broader PHP community. The upper-level package is WordPress-specific, adding WordPress HTTP API integration, the WP Admin credentials settings screen, and connections to the Abilities API and future REST API endpoints.
From a developer’s perspective, the simplest possible use looks like this:
$summary = AI_Client::prompt('Summarize the history of the printing press.')
->using_temperature(0.1)
->generate_text();
That single call routes through whichever AI provider the site owner has configured. The developer writing the plugin does not need to know or care whether it’s Claude, Gemini, or GPT on the other end. The SDK selects a compatible model from the registered providers, applies the configured credentials, and handles the API call.
For developers who want to specify preferences without hard-coding a single provider, the SDK supports preference lists:
$summary = AI_Client::prompt('Summarize the history of the printing press.')
->using_temperature(0.1)
->using_model_preference(
'claude-sonnet-4-5',
'gemini-3-pro-preview',
'gpt-5.1'
)
->generate_text();
The SDK tries each model in order, falling back gracefully if a given provider isn’t configured on that site. This means a plugin can express intelligent preferences while remaining functional across a wide variety of site configurations.
The WordPress-specific layer adds a centralized “AI Credentials” settings screen under WP Admin → Settings. Site administrators enter their API keys once, in one place, and those credentials are available to every plugin using the SDK. This eliminates the multi-plugin credential duplication problem entirely.
The Wider WordPress AI Building Blocks Initiative
The three provider plugins and the PHP AI Client SDK are part of a larger initiative the WordPress AI team calls AI Building Blocks for WordPress. Understanding this broader initiative helps clarify why these plugins represent something more than an incremental update.
The initiative is organized around four interconnected components. The first is the PHP AI Client SDK, discussed at length above. The second is the Abilities API, introduced in WordPress 6.9. The third is the MCP Adapter. The fourth is the AI Experiments Plugin.
The Abilities API
The Abilities API, which shipped as part of WordPress 6.9 “Gene” in December 2025, creates a central registry of WordPress capabilities — a machine-readable map of what a WordPress site can do. Instead of each plugin and theme exposing its functionality in isolation, the Abilities API allows all of those capabilities to be discovered and accessed through a unified system.
The practical implication is that AI agents and automation tools — including AI models accessed through the PHP AI Client SDK — can discover and invoke WordPress capabilities without needing to know in advance what plugins are installed. A WordPress site with a particular e-commerce plugin, booking system, or forms tool exposes those capabilities through the Abilities API, and an AI agent can find and use them the same way it would any other registered ability.
This transforms WordPress from a collection of isolated plugins into something more like a coordinated platform with a discoverable API surface for AI agents.
The MCP Adapter
The Model Context Protocol (MCP) is an emerging standard for connecting AI assistants to external tools and data sources. Tools like Claude Desktop and various AI coding assistants can use MCP to discover and invoke capabilities exposed by connected systems.
The WordPress MCP Adapter translates WordPress Abilities into MCP format, which means external AI tools — Claude, ChatGPT, and others that support MCP — can connect to a WordPress site and discover what it can do, then invoke those capabilities as tools. For developers and power users, this means AI assistants can interact with a WordPress site’s content, manage posts, trigger workflows, or access site data through natural language, without requiring custom integrations.
The AI Experiments Plugin
The fourth component is the AI Experiments Plugin, which released version 0.1.0 alongside the AI Client SDK. This plugin serves as both a working user tool and a reference implementation for developers — a demonstration of how to build on top of the AI Building Blocks. Its first feature, Title Generation, uses the AI Client SDK to suggest post titles within the WordPress editor. Additional experiments are expected as the initiative matures.
What Changes in WordPress 7.0
The release of the three AI provider plugins is explicitly designed to work with current WordPress installations — 6.9 and earlier, with the SDK installed separately — while also preparing for a structural change in WordPress 7.0.
WordPress 7.0 is scheduled for release on April 9, 2026. Its Beta 1 shipped on February 19, 2026. One of the defining features of 7.0 is the integration of the WordPress AI Client SDK directly into WordPress core. This is not a minor change. It means that for the first time in WordPress’s history, every WordPress site running 7.0 or later will have native AI infrastructure as a built-in part of the platform — not an optional add-on, not a third-party dependency, but a core component.
When WordPress 7.0 ships, the three AI provider plugins will continue to work exactly as they do today. Site owners who install the Anthropic, Google, or OpenAI provider plugins on a WordPress 7.0 site will find the setup process even simpler, because the SDK their providers need to register with will already be present. No separate SDK installation will be required.
For plugin developers, the transition is designed to be seamless. Plugins built using the Composer package path today will continue working after the core integration. The WordPress team has been explicit that the architecture anticipates and accommodates this transition.
The 7.0 release also brings real-time collaboration features, a redesigned admin interface, and an updated minimum PHP version requirement. But from the perspective of AI integration specifically, the SDK becoming a core component is the defining change.
Beyond the Official Three: Community-Built Providers
The provider architecture is intentionally open. Anyone can build a provider plugin for any AI service that exposes an API. The WordPress AI team documented the provider plugin pattern publicly, and community developers have already taken notice.
At the time of this writing, community-built provider plugins are already available for Grok (xAI’s model), OpenRouter (a service that provides access to dozens of AI models through a single API), and Ollama (a tool for running open-source AI models locally). The Ollama provider is particularly notable because it enables AI features in WordPress without any external API costs or data leaving your server. Site owners who are privacy-conscious or cost-sensitive can run an open-source model like Llama or Mistral on their own infrastructure and use it as the AI backend for any WordPress plugin built on the SDK.
This open provider ecosystem is one of the more consequential aspects of the building blocks architecture. The WordPress AI team is not trying to limit or control which AI services WordPress sites can use. The goal is to ensure that however you choose to integrate AI, the integration works through a common infrastructure layer so that plugins, themes, and site owners all benefit.
How to Install and Configure the Plugins
The installation process for any of the three official provider plugins is the same as any WordPress plugin. Navigate to Plugins → Add New Plugin in your WordPress admin, search for “AI Provider for Anthropic,” “AI Provider for Google,” or “AI Provider for OpenAI,” install, and activate.
After activation, you need to provide your API key. The recommended approach, and the most secure one, is to set the API key as an environment variable or PHP constant rather than entering it in the database. For the Anthropic plugin, that means setting ANTHROPIC_API_KEY. For the Google plugin, the constant is GOOGLE_AI_API_KEY or equivalent. For OpenAI, the standard OPENAI_API_KEY
If you’re using the WordPress AI Client SDK’s centralized credentials UI — available under Settings → AI Credentials in WP Admin — you can also enter API keys through that interface. The SDK encrypts and manages those credentials, making them available to all SDK-compatible plugins.
Once a provider plugin is installed and credentials are configured, any plugin on your site that uses the AI Client SDK will have access to that provider’s models. There is no per-plugin configuration required. This is the operational change that makes the architecture significant: you configure once, and everything benefits.
Implications for Plugin Developers
For WordPress plugin developers, the arrival of the official provider plugins and the PHP AI Client SDK represents a genuine shift in how AI features can be implemented in plugins.
Previously, a developer building an AI-powered feature had three options: build your own API integration (time-consuming, fragile), depend on a third-party SDK of uncertain maintenance quality, or build your plugin around a specific provider’s service and accept that users of other providers would be excluded.
Now there is a fourth option that is more sustainable than any of the previous three: build against the WordPress AI Client SDK’s unified interface and let the site owner’s configured provider handle the execution. This approach means:
The plugin works regardless of which provider the site owner prefers. A user who has configured the Anthropic plugin gets Claude-powered features. A user who has configured the Google plugin gets Gemini-powered features. The plugin developer writes the feature once and reaches users across all provider configurations.
The plugin is not responsible for credential management. API keys are handled at the platform level. Developers don’t need to build their own secure credential storage, their own API key validation logic, or their own settings screen for provider configuration.
The plugin stays current with new models automatically. Because model discovery is dynamic — the provider plugins fetch available models from the respective APIs and cache them — plugins built on the SDK automatically gain access to new model versions without any code changes.
The plugin can gracefully handle missing provider configurations. The SDK’s is_supported_for_text_ method (and equivalent methods for other capabilities) lets developers check whether the required AI capability is available before attempting to use it, enabling clean fallback behavior for sites that haven’t configured any AI provider.
For the WordPress plugin ecosystem broadly, this means we should expect to see an increasing number of plugins adding AI capabilities over the coming months, now that the infrastructure cost of building those features has dropped substantially.
Implications for Site Owners
For site owners who are not developers, the practical question is simpler: what does this mean for how I run my website?
The most immediate answer is that AI-powered WordPress plugins are about to become more consistent and easier to manage. When multiple plugins use the same SDK-based provider system, you configure your AI provider once — install one of the three official provider plugins, enter your API key — and all of those compatible plugins work with that same provider and those same credentials.
The choice of which provider to configure is yours, and it’s reversible. There is no lock-in to a particular AI service at the platform level. If you currently use Claude and want to switch to Gemini, you install the Google provider plugin, add your Google API key, and any SDK-compatible plugins on your site will use Gemini. If you want to use both providers — potentially giving individual plugins the flexibility to choose between them based on capability availability — you can install multiple provider plugins simultaneously.
Cost control is another practical consideration. Because all API calls go through your own API key, you pay the provider directly at their standard rates. There’s no markup, no subscription to an intermediary service, and no dependency on a third-party platform’s uptime or pricing decisions. This is the “bring your own API key” model, which gives site owners more transparency into what AI features cost and more control over usage limits.
Privacy is a related consideration. When your WordPress site sends data to an AI provider through the SDK, that data goes directly to the provider you’ve configured, under the terms of your agreement with that provider. Site owners who need to comply with GDPR, HIPAA, or other data protection regulations should review the data handling terms of whichever provider they choose. The Ollama community provider, for local model execution, offers an alternative path for sites with strict data residency requirements.
The Broader Context: WordPress and AI in 2025–2026
The release of these plugins didn’t happen in isolation. The WordPress project has been building toward native AI integration for some time, and the timeline of recent developments illustrates the pace of that work.
WordPress 6.9 “Gene,” released December 2, 2025, introduced the Abilities API as a core component and shipped the AI Experiments Plugin (v0.1.0) as a companion. That release was described in official WordPress communications as “paving the road for the future” of the platform’s AI capabilities. The Abilities API specifically was positioned as transforming WordPress “from isolated functions into a unified system” — the foundational prerequisite for the kind of AI agent interaction that the MCP Adapter enables.
The PHP AI Client SDK was announced in November 2025 as part of the AI Building Blocks initiative, with the WordPress-specific package (wordpress/wp-ai-client 0.1.0) delivering core credential management, the WP Admin settings screen, and the AI_Client::prompt() interface. The three official provider plugins followed, completing the initial functional stack: SDK + providers = a working AI integration layer for WordPress plugins.
WordPress 7.0, scheduled for April 9, 2026, will complete this initial phase by moving the SDK from an optional install to a core component. The 7.0 beta shipped February 19, 2026, and the feature set includes real-time collaboration (Phase 3 Gutenberg), a redesigned admin UI, and the embedded AI Client SDK.
Taken together, this represents roughly six months of deliberate, staged work: introduce the APIs in core (6.9), release the tooling (SDK + provider plugins), then integrate the tooling into core (7.0). The sequencing allows the community to test and provide feedback on the SDK before it becomes a core dependency, which is consistent with the WordPress project’s standard approach to major architectural changes.
What This Means for Search, Content, and AI Discovery
One dimension of this development that deserves attention is how AI-powered WordPress functionality intersects with how content is discovered in 2025 and 2026. Search is no longer limited to traditional web crawlers indexing HTML. Google’s AI Overviews, Perplexity, ChatGPT Browse, Claude, and other AI-powered query interfaces now surface content based on a combination of structured data, semantic relevance, and the quality of factual coverage on a given topic.
WordPress sites that integrate AI capabilities through the official provider plugins are better positioned to produce the kind of content that performs well in these environments. AI-assisted content tools built on the SDK can help site owners generate more thorough, well-structured, and factually grounded content — not because AI writes the content for them, but because AI tooling embedded in the editorial workflow makes it easier to research, structure, and refine what gets published.
The Abilities API and MCP Adapter add another layer here. As AI assistants gain the ability to interact with WordPress sites directly through MCP connections — reading posts, updating content, triggering workflows — the information on those sites becomes more accessible to AI-driven research tools. A WordPress site with proper MCP integration may find its content more readily surfaced in AI-generated answers, because the content can be directly queried rather than only discovered through crawling.
None of this happens automatically by installing the three provider plugins. But the infrastructure these plugins provide is the foundation on which those capabilities are built.
Frequently Asked Questions
Q: What is the difference between the WordPress AI provider plugins and existing AI plugins like AI Engine or Rank Math AI?
The official WordPress AI provider plugins (for Anthropic, Google, and OpenAI) are infrastructure plugins, not feature plugins. They register AI providers with the PHP AI Client SDK, making those providers available to any plugin built on the SDK. They don’t add content generation features, chatbots, or SEO tools to your site themselves. Plugins like AI Engine or Rank Math AI are feature plugins that deliver specific AI-powered functionality directly in your WordPress admin. The expectation is that feature plugins will increasingly be built on top of the SDK, using the provider plugins as their backend, rather than maintaining their own direct API integrations.
Q: Do I need all three provider plugins installed, or just one?
You only need one. Installing and configuring one provider plugin — whichever AI service you have API access to and prefer using — is enough for compatible plugins to work. Installing multiple provider plugins simultaneously is supported, however. The SDK will use whichever provider a given plugin requests, or fall back to automatic selection if no preference is specified. If you want the flexibility of both Claude and GPT on the same site, install both the Anthropic and OpenAI provider plugins and configure both API keys.
Q: Is there a cost to using these plugins?
The plugins themselves are free, open-source, and available on WordPress.org. However, using them requires API keys from the respective AI providers, and those providers charge for API usage based on their standard pricing. OpenAI, Anthropic, and Google all price API calls based on the number of tokens processed. The cost depends on which models you use and how frequently your plugins make API calls. There is no subscription fee paid to WordPress or to the WordPress AI team.
Q: How are API keys stored and secured?
API keys can be stored either as server-level environment variables or PHP constants (the recommended approach for security) or through the centralized “AI Credentials” settings screen in WP Admin, where the SDK handles storage. Storing API keys as environment variables keeps them out of the WordPress database entirely, which is best practice for any credential that should not be accessible to plugins or theme code. If you use the WP Admin settings screen approach, the WordPress AI Client SDK manages the credential storage.
Q: What happens when a provider releases a new AI model?
The provider plugins dynamically discover available models from each provider’s API and cache the model list for approximately 24 hours. When OpenAI, Anthropic, or Google releases a new model, it automatically appears in the available model list after the next cache refresh — no plugin update required. This is one of the practical advantages of the dynamic discovery architecture over hard-coded model lists.
Q: Are these plugins compatible with page builders like Elementor, Divi, or Bricks?
The provider plugins are backend infrastructure plugins, not UI components, so they are compatible with all page builders. The provider plugins don’t interact with the front-end display layer of your site at all. Whether the AI features built on top of the SDK integrate with a specific page builder depends on how those feature plugins are developed, not on the provider plugins themselves.
Q: What is the WordPress PHP AI Client SDK, and do I need to install it separately?
The PHP AI Client SDK is the shared infrastructure layer that the provider plugins register with. On WordPress 6.9, you need to install it separately from GitHub (github.com/WordPress/php-ai-
Q: Can I use the WordPress AI provider plugins with a locally-hosted AI model like Llama or Mistral?
The three official provider plugins cover Anthropic, Google, and OpenAI specifically. However, the provider architecture is open, and community developers have already released a provider plugin for Ollama, which enables running open-source models like Llama, Mistral, and others locally on your server. Using the Ollama provider, you can power all SDK-compatible plugins on your site with a locally-hosted model, with no external API calls and no data leaving your infrastructure.
Q: Does the extended thinking feature in the Anthropic plugin work with all Claude models?
Extended thinking support is a Claude-specific capability and is only available on models that Anthropic has enabled it for. The specific models that support extended thinking are dynamically discovered by the plugin from the Anthropic API, so the list may change as Anthropic updates its offerings. Within the SDK, plugin developers can check capability support before invoking extended thinking to ensure graceful fallback on models that don’t support it.
Q: How do the WordPress AI provider plugins relate to the Abilities API and MCP?
The three provider plugins are specifically the outbound AI layer — they allow WordPress to send requests to external AI services. The Abilities API is the inbound layer — it defines what WordPress can do and makes those capabilities discoverable. The MCP Adapter translates those abilities into the Model Context Protocol format so external AI tools can connect to and interact with a WordPress site. These are complementary components of the same AI Building Blocks initiative, not alternatives to each other.
Q: Will these plugins work on WordPress.com, managed WordPress hosts, or only on self-hosted WordPress?
The plugins are designed for self-hosted WordPress installations (WordPress.org). However, WordPress.com has separately announced its own Claude Connector integration, with WordPress.com becoming the first WordPress host to have an official connector in Claude’s Connectors Directory — a separate implementation from the open-source provider plugins. For managed WordPress hosts, compatibility will depend on whether the host supports plugin installation and allows outbound HTTPS connections to external APIs, which most managed hosts do.
Q: Can I build my own AI provider plugin for a service not yet covered?
Yes. The WordPress AI team has documented the provider plugin pattern openly, and the system is designed to support community-built providers. The requirement is that your provider plugin implements the provider interface defined by the PHP AI Client SDK. Community providers already exist for Grok, OpenRouter, and Ollama, demonstrating that the architecture works for services beyond the official three. If you use a service like Mistral, Cohere, or any other AI provider with a REST API, you can build a provider plugin that makes it available through the SDK.
Q: Is there a risk that these plugins will conflict with existing AI plugins on my site?
The official provider plugins register themselves with the PHP AI Client SDK and do not interfere with plugins that manage their own AI integrations independently. If you are running a plugin that has its own OpenAI API integration (not using the SDK), that plugin will continue to work as it does today. The provider plugins only affect plugins that explicitly use the AI_Client::prompt()
Q: What is the AI Experiments Plugin, and should I install it?
The AI Experiments Plugin (v0.1.0) is the WordPress AI team’s laboratory for testing new AI features built on the AI Building Blocks. Its first feature is Title Generation — using AI to suggest post titles in the WordPress editor. It is both a functional user tool and a reference implementation showing developers how to build with the SDK. Whether to install it depends on whether you want to use or test those specific AI features in your editorial workflow. It is not required for the provider plugins to function.
Where This Leaves WordPress in the AI Ecosystem
The release of three official AI provider plugins, built and maintained by the WordPress core AI team, marks a genuine turning point in how WordPress handles AI at the platform level. The fragmentation of the past — dozens of plugins each managing their own API integrations, credentials scattered across multiple settings screens, no shared infrastructure — is being replaced by a coherent architecture that separates AI provider configuration from AI feature development.
The timeline ahead is clear. WordPress 6.9 introduced the foundational APIs. The provider plugins and SDK complete the initial functional layer. WordPress 7.0, arriving in April 2026, will make that infrastructure a native part of the platform for every WordPress site on earth. The plugin ecosystem will respond to that shift, and the pace of AI-powered WordPress plugin development will accelerate as the infrastructure cost of building those features drops.
For site owners, the immediate action is straightforward: if you’re running WordPress 6.9 and have API access to Claude, Gemini, or GPT, you can install one of the three official provider plugins today and begin using SDK-compatible AI features. For developers, building against the WordPress AI Client SDK now — rather than writing custom integrations — is the path that reduces maintenance burden, maximizes compatibility, and positions your plugin for the WordPress 7.0 core integration.
The openness of the provider architecture — the fact that Grok, OpenRouter, and Ollama providers are already available from community developers — signals that this is not a platform designed around any single AI vendor’s interests. WordPress is positioning itself as an AI-capable publishing platform where the choice of AI provider is a site owner’s decision, not a platform constraint.
About ALM Corp
ALM Corp is a digital strategy and web solutions company that helps businesses build, optimize, and grow their online presence on platforms including WordPress. As AI integration becomes a core component of how WordPress sites function — from content workflows powered by Claude and Gemini to automated site management through the MCP Adapter — ALM Corp works with clients to navigate these changes practically and strategically.
Whether you’re a site owner looking to understand which AI provider to configure, a business evaluating how to incorporate AI-powered content tools into your editorial workflow, or an organization exploring what the WordPress 7.0 core AI integration means for your digital infrastructure, ALM Corp’s team combines deep WordPress technical expertise with a clear-eyed view of where AI tools deliver genuine value. The shift from fragmented third-party AI plugins to a unified, platform-level AI infrastructure is one of the most consequential changes WordPress has seen in years — and ALM Corp helps clients understand it, implement it, and use it to competitive advantage.
Visit www.almcorp.com to learn more about how our team can support your WordPress strategy in 2025 and beyond.
