Translated from the original Japanese article
Tech 7 min read

ACF 6.8 Makes WordPress an AI Agent's Playground

AI WordPress MCP API CMS
IkesanContents

I got a release email from ACF. Thought it was a routine update, but the subject said “AI-Ready & Discoverable Content”—WordPress Abilities API integration, Schema.org structured data, the works. An AI-ready custom fields plugin? Had to dig in.

Three New Features in ACF 6.8

ACF (Advanced Custom Fields) is the go-to WordPress plugin for adding custom fields, custom post types, and taxonomies. A staple in any WordPress developer’s toolkit.

Version 6.8 ships three new features:

  1. WordPress Abilities API integration
  2. Automatic Schema.org structured data generation
  3. WP-CLI commands for ACF JSON management

Let’s look at each.

What Is the WordPress Abilities API?

Understanding ACF 6.8’s features requires knowing about the WordPress Abilities API first.

The Abilities API was introduced in WordPress 6.9, developed by the WordPress Core AI team since its formation in May 2025. It provides a standardized way for plugins and themes to declare their capabilities in a machine-readable format, enabling external tools and AI agents to discover and invoke WordPress functionality.

Previously, consuming a plugin’s functionality from the outside meant knowing each plugin’s specific REST API endpoints, action/filter hooks, and global functions. The Abilities API standardizes this into a unified interface.

graph TD
    A[Plugins & Themes] -->|wp_register_ability| B[Abilities Registry]
    B -->|wp_get_abilities| C[Internal PHP usage]
    B -->|REST API| D[External tools]
    B -->|MCP Adapter| E[AI agents<br/>Claude, Cursor, etc.]
    B -->|JavaScript Client| F[Block Editor]

Each Ability carries the following information:

ElementDescription
Unique identifiernamespace/ability-name format
Label & descriptionHuman-readable name and explanation
CategoryFunctional classification
Input schemaParameter spec defined in JSON Schema
Output schemaReturn data type definitions
Execution callbackThe actual processing logic
Permission callbackFunction that determines execution eligibility

The developer community’s response has been enthusiastic—calling it “the biggest DX improvement since Hooks” and “the most significant architectural change since custom post types.” A client-side Abilities API is planned for WordPress 7.0.

ACF 6.8’s Abilities API Integration

ACF 6.8 uses the Abilities API to expose ACF functionality to AI agents and external tools.

The exposed operations (Abilities) fall into three categories:

Field Group Operations

  • List field groups that have AI access enabled
  • Create new field groups with field definitions and location rules

Custom Post Type Operations

  • List ACF-registered post types
  • Create new post types
  • Search, create, view, update, and delete posts

Custom Taxonomy Operations

  • List ACF-registered taxonomies
  • Create new taxonomies
  • Search, create, view, update, and delete terms

This means an AI agent can execute instructions like “Create a Recipe custom post type with fields for ingredients, cooking time, and instructions” from natural language.

Activation and Access Control

This feature is disabled by default. Enable it by adding a filter in functions.php:

add_filter( 'acf/settings/enable_acf_ai', '__return_true' );

The access control model works as follows:

  • Existing field groups, post types, and taxonomies have AI access disabled by default. Opt in individually from the Settings tab in the admin panel
  • Items created after activation have AI access enabled by default
  • All Abilities respect WordPress user capabilities. The executing user must hold ACF permissions (default: manage_options)

Connecting AI Agents via the MCP Adapter

The Abilities API alone only “registers” Abilities—it doesn’t directly connect to external AI agents. That’s where the WordPress MCP Adapter comes in.

MCP (Model Context Protocol) is a protocol developed by Anthropic that standardizes how AI agents communicate with external tools. The WordPress MCP Adapter converts Abilities registered via the Abilities API into MCP primitives (Tool, Resource, Prompt) and exposes them.

graph LR
    A[Claude Desktop<br/>Cursor<br/>Claude Code] -->|MCP Protocol| B[WordPress MCP Adapter]
    B -->|Abilities API| C[ACF 6.8]
    C --> D[Field Groups]
    C --> E[Custom Post Types]
    C --> F[Taxonomies]

Two connection methods are available:

STDIO Transport (local development)

Connects to a local WordPress environment via WP-CLI. Point your Claude Desktop or Cursor config file to the WP-CLI command path and WordPress directory.

HTTP Transport (remote connections)

Uses the @automattic/mcp-wordpress-remote package to connect to a public WordPress site. Requires WordPress application passwords or OAuth authentication.

With this in place, you can tell Claude Desktop something like “Create an Events custom post type on this WordPress site with fields for date, location, and capacity” and ACF will actually create the post type and field group.

Automatic Schema.org Structured Data

The second feature targets SEO and AI discoverability. ACF automatically generates Schema.org structured data (JSON-LD) from custom fields.

This serves not just search engines but AI-powered answer engines (Perplexity, Google AI Overview, etc.) that need to understand content structure. It addresses the emerging fields of GEO (Generative Engine Optimization) and AEO (Answer Engine Optimization).

Enable it with a filter:

add_filter( 'acf/settings/enable_schema', '__return_true' );

Coverage spans 867 Schema.org types and 1,509 properties. ACF field types are automatically mapped:

ACF FieldSchema.org Output
Text, WYSIWYGText, Name, URL
Number, RangeInteger, Float
Date PickerISO 8601 date
ImageImageObject (with metadata)
RepeaterArray of properties
UserPerson schema

For example, mapping fields to a Recipe post type automatically outputs JSON-LD like this in the page head:

{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Chocolate Chip Cookies",
  "prepTime": "PT15M",
  "recipeIngredient": ["200g flour", "100g sugar"],
  "author": {
    "@type": "Person",
    "name": "Jane Baker"
  }
}

Author info, featured image, publish date, and URL are included automatically. ACF Blocks can also opt in via the autoJsonLd property in block.json.

This feature is marked as experimental, given how rapidly the GEO landscape is evolving.

WP-CLI Commands

The third addition is a set of ACF JSON management commands, targeting CI/CD pipeline workflows.

CommandFunction
wp acf json statusDisplay sync status for field groups, post types, and taxonomies
wp acf json syncSync JSON files to the database
wp acf json importImport JSON to database (--dry-run supported)
wp acf json exportExport items to JSON files

Type filtering is supported (e.g., wp acf json sync --type=field-group). Handy for deployment automation, though not directly AI-related.

Security Concerns

The Abilities API integration is opt-in with permission checks, but several points deserve attention.

Token Exposure via MCP Adapter

Enabling the No-Auth URL feature in the MCP Adapter plugin exposes a bearer token through the /wp-json/ REST API index. This token acts as the AI agent’s authentication credential, granting access to content management, command execution, and user account modification.

“New Items Default to AI-Accessible”

Existing items are opt-in, but items created after activation have AI access enabled by default. Accidentally creating a field group containing sensitive data means it’s unintentionally accessible to AI agents.

Coarse Permission Model

ACF Abilities require manage_options (admin-level) by default. No fine-grained access control at the field group or field level. “Read-only for this field group, read-write for that one” isn’t possible through the Abilities API.

Production Deployment Risks

The MCP Adapter docs explicitly state that “the MCP Client operates as an authenticated WordPress user.” Exposing overly permissioned Abilities in production is equivalent to handing admin access to an external service. The recommended approach: create a dedicated MCP user, scope application passwords tightly, and test on staging before going live.

Available in the Free Version

The release blog was titled “ACF PRO 6.8” and betas were PRO-exclusive, so I assumed these were paid features. Turns out the free version repository on GitHub also shipped 6.8.0 with all three features—Abilities API integration, Schema.org structured data, and WP-CLI commands.

Official docs list each feature’s requirement as simply “ACF 6.8 or later” with no Pro-only designation. Pro exclusives remain the usual suspects: ACF Blocks, Options Pages, Repeater, Flexible Content, Gallery, and Clone fields.

The beta was a Pro early-access perk; the GA release brought everything to the free tier. Makes sense—the Abilities API is a WordPress Core feature, so gating the plugin-side implementation behind a paywall would be hard to justify.

Saw “AI” in the release email and expected marketing fluff. Turned out to be a solid feature set built on the WordPress Abilities API. That said, handing WordPress admin privileges to an AI agent in production still feels risky. Starting with prototyping on staging is the pragmatic move.