Abilities API

Expose everything ACPT can do to AI agents and MCP clients via the WordPress Abilities API

The WordPress Abilities API is a WordPress 6.9+ core feature. This integration registers ACPT's abilities but does nothing on sites running an older WordPress version — see Requirements below.

The Abilities API is a standard way for WordPress core, plugins, and themes to declare discrete, machine-readable actions — each with a name, a human description, a JSON Schema for its input and output, a permission check, and a PHP callback. AI agents, MCP (Model Context Protocol) servers, and other automated tools can discover these actions and call them safely, without scraping the admin UI or guessing at internal APIs.

ACPT registers 57 abilities covering everything you can build with the plugin: custom post types, taxonomies, meta field groups/boxes/fields, field values, option pages, forms, dynamic blocks, and Custom Content Types (tables, table groups, and records). An AI agent connected to your site can, for example, design a new content model end-to-end — "create a Movie post type with a Genre taxonomy and a Release Date field" — by calling these abilities directly.

The 15 Custom Content Types (CCT) abilities are registered alongside the rest, but the operations they perform need the CCT feature enabled (ACPT → Settings → Content settings) and a valid ACPT license — otherwise the call returns a normal failure envelope.

In this section

• How it works — architecture, ability naming, the response envelope, permissions, and error handling

• Custom post types

• Taxonomies

• Meta field groups, boxes & fields

• Field values

• Option pages

• Forms

• Dynamic blocks

• Custom Content Types

• Agent Connector for WP — using ACPT's abilities through Agent Connector's MCP server

• Extending — filters for developers, adding your own abilities

• Full reference — every ability in one table

Requirements

• WordPress 6.9 or later. The Abilities API ships in WordPress core starting with 6.9. On earlier versions, wp_register_ability() doesn't exist and ACPT's integration stays inactive — no abilities are registered, and nothing else in ACPT is affected.

• The "Enable Abilities API" setting, which is disabled by default.

Enabling it

Go to ACPT → Settings → Content settings and toggle Enable Abilities API on — it's off by default, alongside the other feature toggles described in Content settings.

Internally, this toggle just flips the enable_abilities_api option, which ACPT reads into a ACPT_ENABLE_ABILITIES_API constant at boot. The integration checks both that constant and that wp_register_ability() actually exists before doing anything:

// src/Integrations/AbilitiesAPI/ACPT_AbilitiesAPI.php
protected function isActive(): bool
{
    if (!defined("ACPT_ENABLE_ABILITIES_API")) {
        return false;
    }

    if (!ACPT_ENABLE_ABILITIES_API) {
        return false;
    }

    return function_exists('wp_register_ability');
}

So it's always safe to leave the setting on — on a site that later gets upgraded to WordPress 6.9, the abilities simply start appearing without any further action from you.

Using the abilities from an MCP client

Every ACPT ability is registered with show_in_rest and with mcp.public set to true in its meta. That is what the official WordPress MCP Adapter needs to discover and run an ability, so with the adapter active, its default MCP server exposes all of ACPT's abilities. No other plugin is required.

Through the MCP Adapter, each call runs as the WordPress user the MCP client authenticates as, and ACPT's own capability checks apply (see Permissions). This lets you give an agent a user account limited to what it needs.

Agent Connector for WP is another way to reach the same abilities. It adds an audit log, but replaces ACPT's capability checks with its own admin-only gate, and gives agents extra tools of its own.

A first call, end to end

Once enabled on WordPress 6.9+, here's what creating a custom post type through the Abilities API looks like from PHP:

$ability = wp_get_ability('acpt/save-post-type');

// post_name/singular_label/plural_label are the only required fields - everything else
// (icon, supports, labels, settings) is optional and gets filled in with the same
// defaults the admin UI's creation wizard pre-selects (public, visible in wp-admin,
// title + editor support, etc.) if you don't send it. Send an explicit empty value
// (e.g. "supports": []) instead of omitting a field if you deliberately want it empty.
$result = $ability->execute([
    'post_name'      => 'movie',
    'singular_label' => 'Movie',
    'plural_label'   => 'Movies',
]);

if (is_wp_error($result)) {
    echo 'Error: ' . $result->get_error_message();
} else {
    // $result === ['success' => true, 'message' => '...', 'data' => [ ...the created post type... ]]
}

Any MCP server or AI agent wired into WordPress's Abilities API sees the exact same acpt/save-post-type ability, with the same schema and description, and can call it the same way — that's the entire point of the integration. See How it works for the full request/response contract, and Custom post types for exactly what gets pre-filled.