DocsWP — WordPress Help

Guide to talking at WordPress meetups and WordCamps about the Core AI projects

WordPress Core AI is a fast-moving target, but in a good way. There’s real software shipping (some of it already in WordPress 6.9), plus a bunch of fast-moving building blocks that are very demoable, but need a bit of framing so your audience leaves excited instead of confused.

So here’s a practical speaker guide you can use for meetups and WordCamps, focused on the “Core AI projects” and how to present them confidently.

0) The one-paragraph “what is Core AI?” intro (steal this)

WordPress Core AI is a set of open building blocks that make WordPress “AI-ready” without baking a single vendor or model into Core. The big idea is: WordPress can describe what it can do (Abilities), call AI providers in a standard way (AI Client), and optionally expose site actions to external agents via MCP (MCP Adapter). Some of this shipped in WordPress 6.9, and more is on the roadmap toward WordPress 7.0 and beyond.

1) Possible talk ideas

Talk idea A — Using AI in your WordPress dashboard

Audience: low code, creators, site builders
Goal: show tangible workflows (title suggestions, summarise content, etc.)
Use: AI Experiments plugin as your demo surface
Avoid: deep protocol talk, JSON schema details

The AI Experiments plugin exists as both a user tool and a developer reference implementation.

Talk idea B — Managing your WordPress site with AI

Audience: site builders, admins, developers
Goal: show WordPress as an MCP server to replicate WP Admin functionality
Use: MCP Adapter + Abilities + an external agent (Claude/VS Code/Cursor)
Avoid: relying on web-based models on conference Wi‑Fi without a backup plan

The MCP Adapter exposes WordPress abilities as MCP tools/resources/prompts.

Talk idea C — Adding AI functionality to WordPress

Audience: developers
Goal: teach the primitives (Abilities + AI Client), show how to build a small feature
Use: Abilities API + wp-ai-client (and optionally php-ai-client). Bonus points for adding the MCP adapter to the mix
Avoid: spending 20 minutes on “what is an LLM”

The AI Client + Connectors allows users to “Bring Your Own Key,” while developers can build AI features without worrying about the foundational infrastructure.

Talk idea D — Managing AI connections in your WordPress site

Audience: admins, site builders, anyone who needs to setup & manage AI connectors but might not be the primary users of those features on a daily basis
Goal: show how to setup and manage AI connectors
Use: Provider plugin(s) + AI experiments plugin to confirm connection and demo admin controls
Avoid: getting distracted by specific AI features

The WP AI Client centralizes interactions with AI Models through WordPress Connectors, which are a way to connect any external service (including AI providers) to WordPress. (Lends itself to a more complete talk once central observability and permissions start landing).

Talk Idea E – How to make your own AI Connector

Audience: developers
Goal: Explain how AI Connectors work, help people see how they can build their own!
Use: Existing Connector, probably a simple one, to showcase what it needs to have and what things it needs to support
Avoid: doing live coding, getting too deep into the nitty gritty (this should be an overview for later deep reading)

2) The projects: how to explain each one on a slide

Below is a speaker-friendly way to describe each repo you listed, in “what it is / why it matters / what to demo”.

Abilities API

What it is: A standard way to register “things WordPress can do” as abilities (with schema + permissions).
Why it matters: makes functionality discoverable, callable, and safe across contexts (PHP, REST, future UI surfaces, AI tools).
What to demo: register a simple ability + run it, or show listing/running via REST.

This landed in WordPress 6.9 as a core API. (make.wordpress.org)

MCP Adapter

What it is: A bridge that turns abilities into MCP tools so external AI agents can call your site.
Why it matters: “WordPress as a tool” in an agent ecosystem; consistent auth/permissions story.
What to demo: connect an MCP client to a WordPress site and invoke one safe ability.

There’s a concrete release note for MCP Adapter v0.3.0 with transport/observability/error-handling improvements and alignment with Abilities API. (make.wordpress.org)

https://github.com/WordPress/mcp-adapter

PHP AI Client

What it is: A provider-agnostic PHP SDK for talking to LLM/embedding providers.
Why it matters: reduces “everyone writes their own OpenAI wrapper” duplication; keeps models/providers swappable.
What to demo: a tiny script that hits a provider and returns text, more easily demonstrated via WP-CLI.

Bundled in core as an external library as of WordPress 7.0 (make.wordpress.org)

WP AI Client

What it is: The WordPress-native SDK built on top of the PHP AI Client, using WordPress conventions (HTTP layer, etc.).
Why it matters: plugins/themes get a unified API + centralised credential handling.
What to demo: “generate titles / summarise content” style feature in a mini-plugin, or AI plugin.

Officially introduced to WordPress Core in version 7.0 along with the AI Connectors. (make.wordpress.org)

AI plugin

What it is: The AI experiments plugin (the plugin slug is ai).
Why it matters: it’s the “reference app” that shows how these building blocks work together.
What to demo: turn on an experiment and show it working end-to-end.

The AI plugin v0.1.0 was announced (with “Title Generation” as an example experiment). (make.wordpress.org)

And the plugin is now on WordPress.org with multiple experiments listed. (wordpress.org). Available to install directly from the Connectors page.

AI

WP Bench

What it is: A WordPress-specific benchmark to evaluate how well models understand WordPress (knowledge + execution).
Why it matters: helps the community measure models on our problems, and influences providers to care about WordPress quality.
What to demo: show a run, show a sample task, or show how to contribute new test cases.

WP‑Bench was introduced on 14 January 2026. (make.wordpress.org)

https://github.com/WordPress/wp-bench

Agent skills

What it is: WordPress-specific AI Agent skills that provide expert-level WordPress knowledge and best practices for AI coding assistants
Why it matters: helps developers ensure that whatever AI agent they use, it builds WordPress code the right way.
What to demo: show installing an agent skill and using it to generate a plugin.

https://github.com/WordPress/agent-skills

3) Recommended talk structures (pick one)

Option 1: 20-minute meetup talk (mixed audience)

Title: “Abilities + MCP: Powering the Agentic WordPress Experience”

  1. “WordPress can do a lot… but it’s hard for tools to discover that”
  2. Abilities API: what an “ability” is (schema + permission + executor) (make.wordpress.org)
  3. MCP Adapter: expose abilities as tools for agents (make.wordpress.org)
  4. Demo: run 1–2 abilities from an MCP client (keep it safe: read-only first)
  5. Wrap: what’s shipped (6.9, 7.0), what’s next (roadmap and direction) (make.wordpress.org)
  6. Call to action: contribute abilities, test AI Experiments, and add WP‑Bench cases

Option 2: 40–45 minute WordCamp talk (mixed audience)

Title: “AI building blocks in WordPress”

  1. No vendor lock-in; optional; building blocks approach (make.wordpress.org)
  2. The 3 pillars:
  1. Demo 1: AI Experiments plugin feature (creator-friendly) (wordpress.org)
  2. Demo 2: small plugin using the AI client in WordPress core (developer-friendly)
  3. Safety + permissions story (application passwords, capability checks, explicit actions)
  4. Wrap: “How you can help” + resources

Option 3: 45 – 90 minute WordCamp workshop (developer-focused)

Title: “Build your first WordPress AI-powered plugin”

  1. Build a plugin that uses all of the building blocks
  2. Create an Ability that performs some action
    • e.g., create a post based on specific inputs
  3. Add the MCP adapter plugin and expose the ability to an AI Agent
    • Configure the agent with the default MCP server details
    • Ask the agent to generate a post based on a topic with a given title
  4. Build an admin page that performs an action with some AI-generated content
  5. Build an admin page that replicates the external Agent process
  6. Show wp-bench in action for benchmarking LLMs
  7. Show how to install Agent Skills for plugin development (to build the admin page)

4) Demo planning (and how not to get burned)

My “conference Wi‑Fi survival kit”

  • Have a recorded fallback (screen capture + narration) for the core demo flow.
  • Keep live demos to one moving part: either “WordPress calls an AI provider” or “agent calls WordPress via MCP”, not both at once unless you enjoy chaos
  • Have local models ready for offline inference:
    • Ollama connection for local models in WP
      1. https://ollama.com/ – free tier provides server + API for local inference
      2. Ollama provider plugin: https://wordpress.org/plugins/ai-provider-for-ollama/
    • Capability will lag behind frontier cloud providers, but latest from any of the following model families should give you a working offline experience on consumer hardware:
      1. Google Gemma
      2. Qwen
      3. Mistral/Ministral

Keep the demo safe by design

  • Start with a read-only ability (e.g., list posts, fetch site info).
  • If you do write actions (create post), make it: in a sandbox/staging site/local site

Use pre-existing example implementations

You already have four perfect demo repos:

I’d recommend speakers explicitly choose one of these as their “golden path” and keep the rest as follow-up links.

Free resources for hands-on training

Leverage free tiers & trial accounts to get attendees hands-on with provider access

Props

Thanks to everyone who helped shape this guide:

@nikskyverge, @huzaifaalmesbah @juanmaguitar @annezazu @laurisaarni