WordPress 7.0 ("Armstrong") shipped on May 20, 2026 with native AI as the headline. The interesting part isn't a new editor widget — it's the underlying architecture. The WP AI Client gives plugins a provider-agnostic interface for sending prompts. The Connectors screen centralizes API-key management for OpenAI, Anthropic, and Google in one place at the site level. The Abilities API standardizes how AI can take action in a workflow. For the first time, building capability-style AI into a WordPress site is a normal engineering project instead of a plugin-vendor lock-in scenario. Here's what that changes.
WordPress 7.0, codenamed Armstrong, shipped on May 20, 2026 with native AI as its headline. Most of the coverage so far has been about which AI-flavored features are now in core — smart content suggestions, alt-text generation, translation assist, summarization. The interesting part is one layer down. WP 7.0 didn’t ship an AI feature set so much as the architecture that lets AI features be built and shipped cleanly. That’s the part worth understanding.
The four pieces.
The native AI architecture is four building blocks that interact:
- The WP AI Client — a provider-agnostic interface for sending prompts to AI models. Plugin code calls
wp_ai_client_prompt()and receives a response, without caring which provider is on the other end. The provider is whatever the site has connected. - The Connectors screen (Settings > Connectors) — a single page where the site owner manages credentials for AI providers. Ships with three defaults: OpenAI, Anthropic, and Google. Add the API key once; every plugin that talks to the WP AI Client uses that connection.
- The Abilities API — a standardized surface for AI to take action inside a WordPress workflow, not just return text. The pattern an “agent-style” plugin needs to write content, modify taxonomies, run reports — in a way that’s introspectable and revocable.
- The Connectors API — a developer-facing interface for adding new providers. The three defaults aren’t the limit; anything that exposes a compatible API can be wired in — a self-hosted model, a regional provider, a specialized vendor.
None of this is the AI feature anyone is going to put in a marketing screenshot. All of it is the substrate the screenshots depend on.
What it changes: ownership.
The pre-7.0 pattern for AI in WordPress was: install a plugin, give the plugin your API key (or use the plugin author’s keys, often with markup), get a chunk of bundled functionality, accept the lock-in. That pattern has a long list of problems — the most consequential is that AI usage costs and AI usage data both live with the plugin, not with the site owner. Switching plugins meant resetting both relationships.
The Connectors model inverts this. The API keys are the site’s keys. The billing relationship is the site’s relationship with the provider. A plugin that uses AI now plugs into the site’s existing connection, runs against the site’s existing usage budget, and surfaces the cost on the site’s existing invoice from the provider. The plugin doesn’t sit in the middle. If a plugin gets uninstalled, the AI capabilities built around it remain available, because the connection is the site’s, not the plugin’s.
For client work this is the biggest single change. The agency or developer can build a custom integration that uses Claude (or OpenAI, or Gemini), and the client holds the billing profile and the API keys directly — no vendor markup, no surprise switching cost. Anthropic’s Role-Based Workspace and OpenAI’s organization-level keys both fit cleanly inside this model.
What it changes: portability.
Prompts written against the WP AI Client target an interface, not a vendor. The same plugin code, calling wp_ai_client_prompt() with the same prompt, can be served by Claude today and Gemini tomorrow without a code change — the swap happens at the Connector level. That has real implications:
- You can run an evaluation across providers without rewriting integration code
- You can fail over to a second provider if the primary has an outage
- You can match the right model to the right job (a fast, cheap model for one task; a more capable model for another) without forking the integration
- You can switch providers when pricing or model quality shifts — which it does, on a roughly six-month cycle — without rewriting the AI parts of the platform
This is the part that turns AI integration from a one-shot vendor commitment into a normal engineering decision with a normal escape hatch.
What it changes: privacy.
One of the durable problems with the old plugin-managed AI pattern was visibility. A site might have three AI plugins, each with its own opaque relationship to its own provider, each sending visitor or editor data somewhere the site’s privacy disclosures didn’t quite capture. The Connectors screen makes the picture legible: every connected provider is in one place, every plugin that uses one is auditable, every flow of data to a third party is something the site owner can see at a glance and disclose accurately in the privacy policy.
That doesn’t eliminate the privacy question. Data still goes to a third-party model, and that still needs the same kind of disclosure as any other third-party data transfer. The point is the question is now answerable in a single place instead of being scattered across plugin settings. See the consent banner WordPress sites don’t actually need for how this fits into the broader privacy posture.
What you can actually build now.
The architectural change makes the capability-style AI work argued for in capabilities, not chatbots finally shippable as a normal engineering project. Concrete examples:
- Editorial assist — AI-suggested categories, AI-drafted alt text on image upload, AI-flagged accessibility regressions in the editor preview. Each is now a thin plugin against the WP AI Client, not a bundled vendor integration. Auto-generated alt text for WordPress covers where this works and where it falls down.
- Embeddings-backed site search — an embedding API on a connected provider, vectors stored in the WordPress database or in a dedicated store, the existing search experience swapped to query against semantic similarity. See embeddings-backed WordPress search.
- LLM-assisted code review — an Abilities-API workflow that reads pull requests, flags accessibility or security regressions before merge, and reports back in the WordPress admin. The model is whichever provider’s connected; the workflow lives in the site. See using LLMs to audit WordPress code.
- Structured content generation — the most concrete example currently in production. A non-profit needed Plain Language and Easy Read versions of every page (with custom SVG icons for cognitive accessibility), at scale, in multiple languages, without the manual copy-paste pipeline that had made the previous approach unsustainable. The integration uses
wp_ai_client_prompt()against Anthropic via the Connectors screen, wired into Advanced Custom Fields. One click in the post editor produces a structured JSON response with both alternate reading modes and the per-sentence SVG icons in roughly 15 seconds. The client holds the Anthropic API keys directly via a Role-Based Workspace — no vendor markup, no intermediary. The full case study is here.
None of these are chatbots. None of them have an “AI” badge. They make the platform better at being a platform — faster editorial workflow, more accessible content, more semantic search, fewer code regressions. The WP 7.0 architecture is what makes them practical to build and own.
What didn’t ship, and what to watch for.
Three notes worth knowing for anyone planning around 7.0:
- Real-time collaboration didn’t ship. The most-anticipated non-AI feature was pulled on May 8 by Matt Mullenweg over concerns about race conditions, memory efficiency, and recurring bugs found in testing. It’s punted to a future release. If a platform plan was depending on it, that’s a slip to work around.
- PHP 7.4 is the floor. Sites still on older PHP have a hosting move to make before they can move to 7.0. Worth doing anyway — modern PHP versions have meaningful security and performance gains — but worth knowing it’s a precondition, not a postcondition.
- The privacy work doesn’t go away. A cleaner architecture for sending data to AI providers is still an architecture for sending data to AI providers. The disclosure obligations are the same as for any other third-party data transfer. The Connectors screen makes the picture legible; the privacy policy still has to reflect it.
The takeaway.
WP 7.0 didn’t make AI useful in WordPress — it was already useful for the right capability-style work. What it did is make AI integration a normal engineering project: provider-agnostic, ownable by the site, auditable, portable, with the privacy posture explicit instead of buried in plugin settings. The capability-style work that’s been worth doing for two years now has a clean architectural home.
If you’re planning AI features into a WordPress platform this year, this is the layer to build against. See AI integration built into the platform for what shipping this kind of work looks like in practice.