How a quiet shift in architecture could redefine how we build and interact with WordPress
WordPress is changing — and not in the way people usually say it is.
This shift isn’t aesthetic. It’s not about blocks or admin redesigns or even the embrace of full-site editing. What’s happening under the hood is far more structural, and arguably more consequential: WordPress is becoming machine-readable in a new, systematic way.
Enter the Features API — a quietly launched, technically sophisticated system that could lay the groundwork for the next decade of WordPress development, and usher in a wave of agent-driven automation, intelligent interfaces, and radically improved plugin interoperability.
This isn’t some bolt-on. It’s foundational.
Here are five reasons why the Features API matters — and how it might change everything from how you build plugins to how your clients manage their sites.
1. A Central Registry of What WordPress Can Do
At its heart, the Features API is a registry — a structured database of capabilities WordPress understands.
Not capabilities in the abstract, but concrete, callable functions: Insert a block, Create a post, List site pages, Update a plugin. Each of these is now a feature — a JSON-described unit of functionality that lives in a central place and can be queried by both server and client systems.
This matters because discoverability has long been one of WordPress’s greatest hidden costs. Developers often spend hours digging through documentation or source code to figure out how to achieve something that already exists somewhere in core or a plugin. Now, that functionality becomes indexed, filterable, and visible.
Features can be tagged, categorized, and filtered. They can advertise whether they're eligible for use in the current context (e.g. frontend vs admin). And, crucially, they can be accessed in a standardized format from both PHP and JavaScript.
This is the groundwork for interoperability — and for automation.
2. Native AI Agent Support — Not Just Content, But Actions
If the 2020s are remembered for anything in technology, it will be the rise of the intelligent agent — AI systems that don’t just generate text but act.
The Features API is explicitly built to support this paradigm. It’s structured around the MCP specification, a format designed to help AI agents identify, select, and execute functions in a software environment.
In plain terms: this means that a GPT-style system with access to your WordPress site can now go far beyond “writing a blog post.” It can reason about available tools, choose a registered feature (say, “add new testimonial”), and carry out the task — securely and transparently.
This could change how users interact with WordPress forever. Instead of learning workflows, users could describe goals:
“Add a contact form to my homepage.”
“Publish this as a private page and share the link.”
“Summarize last month’s most viewed posts.”
AI agents, properly integrated with the Feature API, could make this real — today.
3. Plugin and Theme Developers Can Register Their Own Features — and Get Superpowers in Return
This is where it gets exciting for developers.
In the past, exposing your plugin’s functionality to the broader WordPress ecosystem meant writing REST endpoints, building admin UIs, and hoping someone found your documentation. The Features API changes that by offering a standardised, pluggable way to advertise what your plugin can do.
Consider the following:
- A backup plugin registers a feature called
create_site_backup, complete with metadata about what it does, what parameters it needs, and when it’s eligible. - A newsletter plugin exposes
send_campaignandsegment_users. - A custom theme adds features like
toggle_dark_mode,switch_layout, orapply_brand_colours.
Suddenly, a client dashboard, AI agent, or even another plugin can discover and trigger these features — without knowing anything about how they’re implemented.
And yes, features can also reflect licensing state. A plugin can show “Generate Advanced SEO Report” as a feature — but only make it usable if the site has an active license. This opens the door to contextual upsells, where premium functionality is visible, but gated, in a transparent and structured way.
We’re not talking about theoretical use cases here. These patterns already exist in other ecosystems. The Feature API simply brings them into WordPress, in a way that aligns with its extensibility ethos.
4. Context-Aware Filtering Means Tools Show Up When They're Needed
One of the most powerful — and easily overlooked — elements of the Features API is its contextual intelligence.
Every feature in the registry can include:
- Keyword tags
- Human-readable descriptions
- Category assignments
- A callable
is_eligiblecheck - Context-matching logic (e.g. “only show in editor,” or “only trigger after a post is published”)
This matters because the future of interfaces is situational. Users shouldn’t have to browse menus or memorize actions. Features should surface when they’re relevant — like a good waiter who knows when to refill your glass without asking.
Whether it’s an AI agent deciding what options to offer, or a block editor assistant showing “smart actions” in a sidebar, the Feature API ensures that WordPress starts surfacing intent-matching functionality proactively, not reactively.
5. A Native SDK for Building Intelligent Interfaces — Fast
Lastly, we come to what may be the most practical benefit for developers: a ready-to-use SDK that lets you build interfaces on top of this new infrastructure.
The @wp-feature-api/client package is a full-featured library for:
- Registering and consuming features on the frontend
- Interacting with the registry
- Executing features directly from UI components
- Wiring up filters, triggers, and automations
In plain terms: you can build smarter admin panels, dashboards, and assistant UIs that actually do things, using the registry as the single source of truth.
Imagine:
- A custom dashboard for clients that only shows “Update today’s menu,” “Add new event,” or “Send newsletter” — all driven by registered features.
- An AI co-pilot that helps users create custom templates, insert blocks, and tweak settings without ever opening a manual.
- A self-healing admin system that detects errors and offers automated fixes via exposed features (“Reinstall broken plugin,” “Clear cache,” “Rebuild permalinks”).
The pieces are already in place.
Final Thoughts
What the Feature API introduces isn’t flashy. There are no new visual editors, no sparkly animations. But if you zoom out, what it offers is something WordPress has never had: a systematic language of action.
For developers, this means less boilerplate, more composability, and a clearer contract between systems. For users, it points to a future where WordPress becomes not just a CMS, but an intelligent assistant — capable of understanding, reasoning, and responding.
WordPress is getting smarter. And the Feature API might be the blueprint for how it learns to help.
Leave a Reply