WordPress CoreCore Core is the set of software required to run WordPress. The Core Development Team builds WordPress. 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 AdapterMCP Adapter Translates WordPress abilities into Model Context Protocol format, allowing AI assistants like Claude and ChatGPT to discover and invoke WordPress capabilities as tools, resources, and prompts.). 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 pluginAI Experiments Plugin WordPress’s AI laboratory bringing all building blocks together. Serves as both a user tool and developer reference implementation. First release (v0.1.0) includes Title Generation experiment. as your demo surface
Avoid: deep protocol talk, JSONJSON JSON, or JavaScript Object Notation, is a minimal, readable format for structuring data. It is used primarily to transmit data between a server and web application, as an alternative to XML. 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 serverMCP Server Exposes tools, resources, and prompts according to Model Context Protocol specification. WordPress can run multiple MCP servers with different configurations. 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 APIAbilities API A core WordPress API (introduced in 6.9) that creates a central registry of capabilities, making WordPress functions discoverable and accessible to AI agents, automation tools, and developers. Transforms WordPress from isolated functions into a unified system. + 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: ProviderProvider An AI service offering models for generation, embeddings, or other capabilities (e.g., Anthropic, Google, OpenAI). pluginPlugin A plugin is a piece of software containing a group of functions that can be added to a WordPress website. They can extend functionality or add new features to your WordPress websites. WordPress plugins are written in the PHP programming language and integrate seamlessly with WordPress. These can be free in the WordPress.org Plugin Directory https://wordpress.org/plugins/ or can be cost-based plugin from a third-party.(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 (PHPPHP PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used open source general-purpose scripting language that is especially suited for web development and can be embedded into HTML. https://www.php.net/manual/en/index.php, REST, future UIUI UI is an acronym for User Interface – the layout of the page the user interacts with. Think ‘how are they doing that’ and less about what they are doing. surfaces, AI tools).
What to demo: register a simple abilityAbility A registered, self-documenting unit of WordPress functionality that can be discovered and invoked through multiple contexts (REST API, Command Palette, MCP). Includes authorization and input/output specifications. + run it, or show listing/running via REST.
This landed in WordPress 6.9 as a core APIAPI An API or Application Programming Interface is a software intermediary that allows programs to interact with each other and share data in limited, clearly defined ways.. (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 clientMCP Client AI agents, IDEs, or assistants that connect to MCP servers to access capabilities. 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)
PHP AI Client
What it is: A provider-agnosticProvider-Agnostic Software design that works with multiple service providers without being tied to one. Recommended for WordPress AI integrations. 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-CLIWP-CLI WP-CLI is the Command Line Interface for WordPress, used to do administrative and development tasks in a programmatic way. The project page is http://wp-cli.org/ https://make.wordpress.org/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 (HTTPHTTP HTTP is an acronym for Hyper Text Transfer Protocol. HTTP is the underlying protocol used by the World Wide Web and this protocol defines how messages are formatted and transmitted, and what actions Web servers and browsers should take in response to various commands. 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.orgWordPress.org The community site where WordPress code is created and shared by the users. This is where you can download the source code for WordPress core, plugins and themes as well as the central location for community conversations and organization. https://wordpress.org/ with multiple experiments listed. (wordpress.org). Available to install directly from the Connectors page.
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)
Agent skills
What it is: WordPress-specific AI AgentAI Agent An AI system that autonomously performs tasks and interacts with systems through available tools and resources. 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.
3) Recommended talk structures (pick one)
Option 1: 20-minute meetup talk (mixed audience)
Title: “Abilities + MCP: Powering the Agentic WordPress Experience”
- “WordPress can do a lot… but it’s hard for tools to discover that”
- Abilities API: what an “ability” is (schema + permission + executor) (make.wordpress.org)
- MCP Adapter: expose abilities as tools for agents (make.wordpress.org)
- Demo: run 1–2 abilities from an MCP client (keep it safe: read-only first)
- Wrap: what’s shipped (6.9, 7.0), what’s next (roadmap and direction) (make.wordpress.org)
- 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”
- No vendor lock-in; optional; building blocks approach (make.wordpress.org)
- The 3 pillars:
- Abilities (describe actions) (make.wordpress.org)
- AI Client (call providers) (make.wordpress.org)
- MCP Adapter (connect agents) (make.wordpress.org)
- Demo 1: AI Experiments plugin feature (creator-friendly) (wordpress.org)
- Demo 2: small plugin using the AI client in WordPress core (developer-friendly)
- Safety + permissions story (application passwords, capability checks, explicit actions)
- Wrap: “How you can help” + resources
Option 3: 45 – 90 minute WordCamp workshop (developer-focused)
Title: “Build your first WordPress AI-powered plugin”
- Build a plugin that uses all of the building blocks
- Create an Ability that performs some action
- e.g., create a post based on specific inputs
- 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
- Build an admin page that performs an action with some AI-generated content
- Build an admin page that replicates the external Agent process
- Show wp-bench in action for benchmarking LLMs
- 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
- https://ollama.com/ – free tier provides server + API for local inference
- 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:
- Google Gemma
- Qwen
- Mistral/Ministral
- Ollama connection for local models in WP
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
- Google Gemini: https://ai.google.dev/
- Copilot/VSCode: https://code.visualstudio.com/blogs/2024/12/18/free-github-copilot
- Ollama Cloud: https://ollama.com/
- Optional: may use local models w/ setup ahead of time. Include this in your talk description or invitation so folks can prepare, don’t recommend having everyone download models on conference wifi
- Mistral AI: https://console.mistral.ai/
- Free tier with API keys
- Can be used with https://wordpress.org/plugins/ai-provider-for-mistral/
Props
Thanks to everyone who helped shape this guide:
@nikskyverge, @huzaifaalmesbah @juanmaguitar @annezazu @laurisaarni
