WordPress 7.0 "Armstrong" Is Live β Post-Release Deep Dive πΊ
Architecting Vendor-Neutral AI in WordPress: A Production Guide to the 7.0 Infrastructure Layer
Current Situation Analysis
The integration of artificial intelligence into content management systems has historically followed a fragmented pattern. Every plugin vendor builds proprietary SDKs, manages isolated credential stores, and locks developers into specific model providers. This creates three compounding problems: credential sprawl across multiple settings panels, inconsistent user interfaces for AI features, and architectural fragility when model providers change pricing, deprecate endpoints, or shift capabilities.
WordPress 7.0 "Armstrong" (released May 20, 2026) addresses this by treating AI as a transport layer rather than a feature toggle. The release ships with a foundational infrastructure stack that decouples request routing from capability discovery and execution. This mirrors the strategic rollout of the REST API in earlier WordPress versions: establish the rails first, then allow the ecosystem to build the trains.
The misconception driving most failed implementations is the expectation of immediate generative output. Updating to 7.0 without additional configuration yields zero AI functionality. The platform deliberately separates three concerns:
- Transport: The
WP AI Clientroutes prompts to external endpoints without exposing model-specific logic to calling code. - Capability Contract: The
Abilities API(PHP and JavaScript) declares what an AI feature can do, making it discoverable by both human interfaces and automated agents. - Execution: The optional AI plugin sits atop the infrastructure to actually generate text, images, or metadata.
This architecture is backed by significant contributor investment: over 900 developers participated in the release, with nearly 280 contributing to WordPress for the first time. The shift from monolithic AI plugins to a vendor-neutral core layer reduces plugin bloat, standardizes credential management, and future-proofs sites against model provider volatility.
WOW Moment: Key Findings
The architectural shift becomes immediately apparent when comparing legacy plugin stacks against the 7.0 core infrastructure. The following table isolates the operational impact across critical dimensions:
| Approach | Credential Management | API Routing | UI Integration | Vendor Lock-in | Maintenance Overhead |
|---|---|---|---|---|---|
| Legacy Plugin Stack | Manual entry per plugin, duplicated keys | Hardcoded SDK calls, provider-specific endpoints | Custom settings pages, inconsistent UX | High (tied to plugin vendor) | High (update each plugin independently) |
| WP 7.0 Core Infrastructure | Centralized via Connectors, single entry per provider | Abstracted through AI Client, provider-agnostic | Standardized Abilities UI, command palette hooks | None (swap providers without code changes) | Low (core handles routing, plugins focus on logic) |
This finding matters because it transforms AI from a per-plugin dependency into a platform capability. Teams can now rotate between OpenAI, Anthropic (Claude), and Google (Gemini) without refactoring plugin code. The Settings β Connectors screen eliminates credential duplication, while the Abilities API enables machine-readable capability discovery. For production environments, this means reduced attack surface, standardized audit trails, and predictable scaling when adding AI-driven workflows.
Core Solution
Implementing the 7.0 AI infrastructure requires understanding the decoupled architecture. The transport layer (WP AI Client) never interacts directly with model providers. Instead, it receives structured requests from registered abilities, applies routing rules, and returns standardized responses. The following implementation demonstrates how to register a client-side ability, configure the transport layer, and handle responses in a production TypeScript environment.
Step 1: Define the Capability Contract
Abilities must declare their purpose, input schema, and expected output. This contract enables both the editor UI and automated agents to discover and invoke the feature.
import { registerAbility, AbilityContract } from '@wordpress/abilities';
interface ContentSummarizationInput {
postId: number;
maxLength: number;
tone: 'professional' | 'casual' | 'technical';
}
interface ContentSummarizationOutput {
summary: string;
tokenCount: number;
modelProvider: string;
}
const summarizationContract: AbilityContract<ContentSummarizationInput, ContentSummarizationOutput> = {
name: 'core/content-summarize',
version: '1.0.0',
description: 'Generates a concise summary of post content using the configured AI provider.',
inputSchema: {
postId: { type: 'number', required: true },
maxLength: { type: 'number', required: false, default: 150 },
tone: { type: 'string', enum: ['professional', 'casual', 'technical'], required: false, default: 'professional' }
},
outputSchema: {
summary: { type: 'string' },
tokenCount: { type: 'number' },
modelProvider: { type: 'string' }
}
};
registerAbility(summarizationContract);
Step 2: Implement the Transport Handler
The WP AI Client abstracts provider routing. Your code calls the client, which resolves the active connector, injects credentials securely, and returns a normalized response.
import { aiClient } from '@wordpress/ai-client';
async function executeSummarization(input: ContentSummarizationInput): Promise<ContentSummarizationOutput> {
try {
const response = await aiClient.invoke({
ability: 'core/content-summarize',
payload: input,
options: {
timeout: 15000,
retryOnRateLimit: true,
fallbackProvider: 'anthropic' // Optional: automatic failover
}
});
return {
summary: response.data.text,
tokenCount: response.metadata.tokenUsage,
modelProvider: response.metadata.provider
};
} catch (error) {
if (error.code === 'AI_CLIENT_AUTH_FAILURE') {
console.warn('Connector credentials missing or invalid. Check Settings β Connectors.');
}
throw error;
}
}
Step 3: Wire to the Editor UI
The client-side Abilities API exposes a command palette hook and built-in UI components. This ensures AI features surface in context rather than buried in settings.
import { registerCommandPaletteAction } from '@wordpress/commands';
import { showNotification } from '@wordpress/notices';
registerCommandPaletteAction({
name: 'ai/summarize-current-post',
label: 'Summarize Current Post',
keywords: ['ai', 'summary', 'content'],
callback: async () => {
const currentPostId = wp.data.select('core/editor').getCurrentPostId();
try {
const result = await executeSummarization({
postId: currentPostId,
maxLength: 120,
tone: 'professional'
});
wp.data.dispatch('core/editor').editPost({
meta: { _ai_summary: result.summary }
});
showNotification({
id: 'ai-summary-success',
type: 'success',
content: `Summary generated via ${result.modelProvider}.`,
isDismissible: true
});
} catch (err) {
showNotification({
id: 'ai-summary-error',
type: 'error',
content: 'AI summarization failed. Verify connector configuration.',
isDismissible: true
});
}
}
});
Architecture Decisions & Rationale
- Decoupled Transport: The
WP AI Clientnever hardcodes provider endpoints. This eliminates SDK duplication across plugins and centralizes rate-limit handling, retry logic, and credential injection. - Contract-First Abilities: Declaring input/output schemas enables type safety, automated validation, and machine-readable discovery. Agents can parse capabilities without parsing UI code.
- Vendor Neutrality: The
Connectorsscreen stores credentials per provider, not per plugin. Swapping from OpenAI to Gemini requires zero code changes, only a configuration update. - Opt-in Execution: Core ships the infrastructure; generation requires the separate AI plugin. This prevents bloat on sites that don't need AI, while maintaining a consistent API for those that do.
Pitfall Guide
1. Expecting Out-of-the-Box Generation
Explanation: Teams update to 7.0 and immediately test for AI output, only to find nothing works. The core release intentionally ships infrastructure only.
Fix: Install the optional AI plugin after updating core. Verify the Settings β Connectors screen shows an active provider before testing abilities.
2. Hardcoding Credentials in Plugin Settings
Explanation: Developers bypass the Connectors screen and store API keys in plugin options or environment variables. This breaks vendor neutrality and creates duplicate credential management.
Fix: Always route requests through aiClient.invoke(). The client automatically resolves credentials from the centralized Connectors store. Never implement custom fetch() calls to provider endpoints.
3. Misregistering Abilities Without Contracts
Explanation: Abilities are registered without input/output schemas or versioning. This causes UI rendering failures and breaks agent discovery.
Fix: Always define inputSchema and outputSchema with explicit types. Include a version field to support backward-compatible updates. Validate payloads before invoking the client.
4. Breaking Pattern Cohesion in Complex Layouts
Explanation: Developers treat patterns as loose block collections, manually detaching and rearranging elements. This causes layout drift and breaks responsive visibility rules. Fix: Treat patterns as single units by default. Use the detach API only when structural modification is required. Reattach after editing to preserve responsive visibility and styling inheritance.
5. Ignoring Responsive Visibility Breakpoints
Explanation: Teams enable responsive visibility controls but don't configure custom breakpoints, relying on defaults that misalign with their design system.
Fix: Define breakpoints in theme.json under settings.custom.breakpoints. Test visibility toggles against actual device viewports, not just browser resize handles.
6. Assuming Single-Provider Scaling
Explanation: Production sites route all AI traffic through one provider without fallback configuration. Rate limits or outages halt all AI workflows.
Fix: Configure fallbackProvider in client options. Monitor token usage via the Connectors dashboard. Implement queueing for batch operations to avoid burst rate limits.
7. Overriding Core CSS Without Scoping
Explanation: Developers inject global CSS to fix block styling, conflicting with per-block custom CSS introduced in 7.0.
Fix: Use the Advanced panel's per-block CSS field for instance-specific overrides. Reserve global stylesheets for theme-level tokens. Scope custom rules to .wp-block-[name] to prevent cascade collisions.
Production Bundle
Action Checklist
- Verify core update to 7.0 completed without fatal errors in debug log
- Install and activate the optional AI plugin from the official repository
- Navigate to Settings β Connectors and configure at least one provider (OpenAI, Anthropic, or Gemini)
- Test ability registration by invoking a sample prompt through the command palette
- Audit existing AI plugins for credential duplication and migrate to Connectors
- Define custom responsive breakpoints in theme.json if design system differs from defaults
- Implement fallback provider configuration for production AI workflows
- Run a staging migration test focusing on pattern cohesion and revision history
Decision Matrix
| Scenario | Recommended Approach | Why | Cost Impact |
|---|---|---|---|
| Low-traffic blog with occasional AI assistance | Single provider via Connectors, no fallback | Simplifies configuration, reduces token overhead | Minimal (pay-per-use only) |
| High-volume content pipeline requiring 99.9% uptime | Multi-provider routing with automatic fallback | Prevents workflow halts during provider outages or rate limits | Moderate (redundant token allocation) |
| Enterprise site with strict data residency requirements | Self-hosted custom connector + on-premise model | Keeps data within controlled infrastructure, bypasses public APIs | High (infrastructure + maintenance) |
| Agency managing 50+ client sites | Centralized Connectors configuration + ability registry | Eliminates per-site credential management, standardizes AI features | Low (scales linearly with site count) |
Configuration Template
{
"$schema": "https://schemas.wp.org/wp/7.0/theme.json",
"version": 3,
"settings": {
"custom": {
"breakpoints": {
"mobile": "480px",
"tablet": "768px",
"desktop": "1024px"
},
"ai": {
"defaultProvider": "openai",
"fallbackProvider": "anthropic",
"timeoutMs": 15000,
"retryOnRateLimit": true
}
},
"typography": {
"fontLibrary": {
"enabled": true,
"defaultFontFamily": "system-ui"
}
},
"blocks": {
"core/breadcrumbs": {
"themeSupport": true,
"separator": "chevron"
},
"core/gallery": {
"lightbox": {
"enabled": true,
"slideshow": true
}
}
}
},
"styles": {
"blocks": {
"core/heading": {
"typography": {
"fontSize": "var(--wp--preset--font-size--large)",
"fontWeight": "600"
}
}
}
}
}
Quick Start Guide
- Update Core: Run
wp core update --version=7.0on a staging environment. Verify database migrations complete without errors. - Configure Connectors: Navigate to
Settings β Connectorsin wp-admin. Enter your API key for OpenAI, Anthropic, or Gemini. Save and verify the green status indicator. - Install AI Plugin: From Plugins β Add New, search for "WordPress AI", install, and activate. This enables generation capabilities on top of the core infrastructure.
- Test Abilities: Open the editor, press
βKorCtrl+K, and search for an AI ability. Execute a test prompt. Verify the response appears in the editor and the command palette logs the provider used. - Deploy to Production: Run a full backup, push the update, and monitor the debug log for
AI_CLIENT_*warnings. Verify existing plugins inherit the Connectors configuration automatically.
Mid-Year Sale β Unlock Full Article
Base plan from just $4.99/mo or $49/yr
Sign in to read the full article and unlock all tutorials.
Sign In / Register β Start Free Trial7-day free trial Β· Cancel anytime Β· 30-day money-back
