Recentemente eu venho postando vídeos sobre as iniciativas do WordPress sobre inteligência artificial. Um novo time criado entre Automattic, Google e 10up visa implementar novas funcionalidades integradas com inteligência artificial no núcleo do WordPress. O que isso significa? Sites WordPress, por padrão, irão suportar aplicações com inteligência artificial.
Mas calma lá, você não irá ter um ChatGPT dentro do seu WordPress, e sim o alicerce para que desenvolvedores implementem soluções integradas à IA. Uma estrutura padronizada para construir aplicações eficientes, funcionalidades que permitem o uso interno e externo, como servidores MCP. E o mais importante: tudo será opcional. Se você não quiser IA no seu site, nada muda.
IA como algo fundamental no WordPress: a analogia com o banco de dados
Em um post publicado no Make WordPress Core, Jason Adams propõe uma analogia poderosa: imagine o WordPress sem banco de dados, sem persistência, sem armazenamento de metas, sem comentários. O conceito parece absurdo porque o banco de dados é algo que simplesmente assumimos que existe.
A proposta do Core AI Team é tratar a IA da mesma forma. Não como um plugin extra ou uma feature avançada, mas como algo que desenvolvedores e usuários podem assumir que está disponível. A pergunta central é: “E se, do usuário final ao desenvolvedor de plugin, todos pudessem dar como certo que existe um modelo de IA acessível?”
Isso não significa que a IA seja obrigatória. Significa que, quando disponível, o WordPress simplesmente funciona melhor e, quando não está, nada quebra.
Recentemente, o podcast WP Minute entrevistou Jason Adams, o novo Diretor de Engenharia de IA na Automattic, que trouxe detalhes ainda mais valiosos sobre a estratégia do time. Vou compartilhar os pontos mais relevantes aqui.
O Core AI Team: quem está por trás das decisões
Jason Adams entrou na Automattic após contribuir com o projeto Core AI desde meados do ano passado. James Leage é o head de todas as iniciativas de IA da Automattic, incluindo projetos como Big Sky (o assistente AI no editor de blocos do WordPress.com) e Telex (telex.automatic.ai, focado em construção de blocos e temas de blocos).
Com o crescimento das frentes de IA, James está migrando para um papel mais estratégico e de visão, enquanto Jason assume as decisões de engenharia como Diretor de Engenharia de IA. Essa divisão reflete o nível de investimento da Automattic nessa área.
Os quatro building blocks do WordPress para IA
Foram escolhidas quatro iniciativas para serem desenvolvidas pelo time de inteligência artificial:
- PHP AI Client SDK
- Abilities API
- MCP Adapter
- AI Experiments Plugin
PHP AI Client SDK e WP AI Client: como usar IA em plugins WordPress
Inicialmente, este SDK era um plugin criado por Felix Arts do Google, chamado AI Services (disponível no repositório do WordPress.org). Felix trouxe experiência significativa com esse plugin e também familiaridade com o Vercel AI SDK, a ideia de criar um cliente AI unificado não é nova, mas é a primeira implementação agnóstica de framework em PHP.
Por que dois clientes? PHP AI Client vs WP AI Client
O projeto se divide em duas camadas:
- PHP AI Client (
wordpress/php-ai-client) — um pacote Composer puro, sem nenhum conceito de WordPress. Funciona em qualquer projeto PHP (Laravel, Symfony, etc.). UsaAiClient::prompt()com camelCase e segue padrões PSR (PSR-7, PSR-14, PSR-18). - WP AI Client (
wordpress/wp-ai-client) — um wrapper que conecta o PHP AI Client ao ecossistema WordPress:wp_ai_client_prompt()com snake_case, tela admin de credenciais, REST endpoints (/wp-ai/v1/generate), JavaScript API (wp.aiClient), integração comWP_Error.
O que o WP AI Client resolve?
O problema central é que cada modelo de IA tem sua própria API, com formato específico. O WP AI Client cria uma camada de abstração sobre essas variações, oferecendo um esquema único para trabalhar com qualquer modelo. A arquitetura foi inspirada no Vercel AI SDK e oferece duas APIs paralelas: uma Fluent API (method chaining) e uma API tradicional (array-based, alinhada às convenções do WordPress).
Exemplos reais da API
A função principal é wp_ai_client_prompt(). Veja exemplos do repositório oficial:
Geração de texto (PHP + JavaScript):
// PHP — gerar texto com tratamento de erro WordPress-style
$text = wp_ai_client_prompt( 'Write a haiku about WordPress.' )
->generate_text();
if ( is_wp_error( $text ) ) {
wp_die( $text->get_error_message() );
}
echo wp_kses_post( $text );Code language: PHP (php)// JavaScript — mesma operação no browser
const text = await wp.aiClient
.prompt( 'Write a haiku about WordPress.' )
.generateText();Code language: JavaScript (javascript)Geração de imagem:
$image_file = wp_ai_client_prompt( 'A futuristic WordPress logo in neon style' )
->generate_image();
if ( is_wp_error( $image_file ) ) {
wp_die( $image_file->get_error_message() );
}
echo '<img src="' . esc_url( $image_file->getDataUri() ) . '" alt="WordPress logo futurista">';Code language: PHP (php)JSON estruturado com controle de temperatura:
$schema = array(
'type' => 'array',
'items' => array(
'type' => 'object',
'properties' => array(
'plugin_name' => array( 'type' => 'string' ),
'category' => array( 'type' => 'string' ),
),
'required' => array( 'plugin_name', 'category' ),
),
);
$json = wp_ai_client_prompt( 'List 5 popular WordPress plugins with their primary category.' )
->using_temperature( 0.2 )
->as_json_response( $schema )
->generate_text();
$data = json_decode( $json, true );Code language: PHP (php)Entrada multimodal (alt text automático para imagens):
// PHP AI Client (agnóstico) — gerar alt text a partir de uma imagem
$text = AiClient::prompt('Generate alternative text for this image.')
->withInlineImage($base64Blob, 'image/png')
->generateText();Code language: PHP (php)Saída multimodal (texto + imagem combinados):
use WordPress\AiClient\Messages\Enums\ModalityEnum;
$result = wp_ai_client_prompt( 'Create a recipe for a chocolate cake and include photos for the steps.' )
->as_output_modalities( ModalityEnum::text(), ModalityEnum::image() )
->generate_result();
foreach ( $result->toMessage()->getParts() as $part ) {
if ( $part->isText() ) {
echo wp_kses_post( $part->getText() );
} elseif ( $part->isFile() && $part->getFile()->isImage() ) {
echo '<img src="' . esc_url( $part->getFile()->getDataUri() ) . '" alt="">';
}
}Code language: PHP (php)Como Felix Arts resumiu: “queremos que coisas simples sejam fáceis e coisas complicadas sejam possíveis”.
Model Inference e Feature Detection: seleção inteligente de modelos
Um dos recursos mais importantes é o sistema de inferência de modelo. Seria muito inconveniente se, a cada prompt, o desenvolvedor tivesse que especificar qual modelo usar, até porque não há como garantir que GPT-5 ou Gemini estejam disponíveis em cada instalação do WordPress.
O SDK resolve isso de três formas:
1. Seleção automática: se você não especifica um modelo, ele procura um compatível com o prompt:
// Agnóstico — funciona com qualquer provedor configurado
$text = wp_ai_client_prompt( 'Summarize this article.' )
->generate_text();Code language: PHP (php)2. Preferência de modelo com fallback — você lista modelos preferidos, mas o SDK encontra alternativas se nenhum estiver disponível:
$summary = wp_ai_client_prompt( 'Summarize the history of the printing press.' )
->using_temperature( 0.1 )
->using_model_preference(
'claude-sonnet-4-5',
'gemini-3-pro-preview',
'gpt-5.1'
)
->generate_text();Code language: PHP (php)3. Feature detection — verifique se o ambiente suporta a operação antes de mostrar a UI:
$prompt = wp_ai_client_prompt( 'Generate an excerpt from this post.' )
->using_temperature( 0.2 );
if ( $prompt->is_supported_for_text_generation() ) {
$text = $prompt->generate_text();
} else {
// Fallback: esconder o botão ou mostrar instruções de setup
}Code language: PHP (php)// Mesma verificação no JavaScript
const prompt = wp.aiClient.prompt( 'Generate an excerpt.' )
.usingTemperature( 0.2 );
if ( await prompt.isSupportedForTextGeneration() ) {
const text = await prompt.generateText();
} else {
// Esconder feature
}Code language: JavaScript (javascript)Capacidades suportadas pelo PHP AI Client SDK
O PHP AI Client suporta um conjunto amplo de capacidades, cada uma com interfaces dedicadas:
- Text Generation — geração de texto, chat, JSON estruturado
- Image Generation — criação de imagens a partir de prompts
- Text-to-Speech — conversão de texto em áudio
- Speech Generation — geração de fala
- Video Generation — geração de vídeo
- Embedding Generation — vetores para busca semântica
- Chat History — histórico de conversa para contexto persistente
O sistema de inferência analisa automaticamente o prompt e identifica quais capacidades são necessárias, por exemplo, se o prompt inclui uma imagem, o SDK já filtra apenas modelos que suportam entrada multimodal.
Estado atual: proposta de merge no WordPress 7.0
Em fevereiro de 2026, o time publicou a proposta oficial para integrar o WP AI Client no WordPress 7.0. O documento deixa claro o que entra e o que não entra no core:
O que será incluído no 7.0:
- PHP API + Prompt Builder — interface WordPress-friendly para construir prompts e invocar modelos
- Abstração de Provider/Model — interface consistente e vendor-neutral para desenvolvimento de plugins
- Discoverability — habilitação dinâmica de features baseada na detecção de modelos disponíveis
- Integração com HTTP do WordPress — transporte alinhado com as convenções do WP e comportamento de
WP_Error - Gerenciamento de credenciais — UI admin para armazenar credenciais de provedores, compartilhadas entre plugins
- REST Endpoints + JavaScript API — API para contextos de browser, wp-admin e editor de blocos
- Mecanismo de controle — filtro (
prompt_ai,list_ai_providers_models) para aprovar ou negar prompts e configurações específicas
O que NÃO será incluído:
- Nenhuma credencial ou provedor de IA pré-configurado
- Nenhuma interface de assistente de IA para o usuário final
- Experiências de produto ficam no território de plugins e do ecossistema
Garantias de segurança e privacidade:
O merge não habilita chamadas de IA automaticamente. O WordPress exige configuração explícita e código de invocação antes de enviar qualquer dado externamente. Sem provedor configurado, nenhuma chamada de rede acontece. Endpoints REST e execução JavaScript permanecem protegidos por capabilities, e credenciais não podem vazar via REST ou logs.
Em termos de performance, o impacto é mínimo quando não utilizado, as operações de admin não afetam as requisições do frontend.
Migração para o WordPress 7.0:
Para quem já usa o pacote wordpress/wp-ai-client antes do 7.0, a migração é direta:
- Substituir
AI_Client::prompt()porwp_ai_client_prompt()(que retornaWP_Errorem vez de exceções) - Remover chamadas a
AI_Client::init()(o core auto-inicializa) - Remover imports da classe
WordPress\AI_Client\AI_Client - Após atualizar para 7.0, remover o pacote das dependências Composer
Abilities API: a padronização que o WordPress precisava
A Abilities API é descrita como “AI adjacent” — na verdade, ela resolve um problema que existe no WordPress há anos, independentemente de inteligência artificial.
O problema real que a Abilities API resolve
Pense em plugins como Gravity Forms, GiveWP, LearnDash, The Events Calendar. Cada um tem sua própria forma de expor uma API pública para que outros desenvolvedores a integrem. Alguns usam funções, outros, classes, outros, REST API.
Não existe um padrão unificado para como um plugin expõe suas funcionalidades no WordPress. Você simplesmente torce para que a documentação seja boa e segue em frente.
A Abilities API é exatamente essa padronização. Ela cria uma forma unificada de registrar e documentar funcionalidades por temas e plugins — desde comandos de CLI até endpoints REST e lógica customizada. Esta camada fica disponível tanto no servidor (PHP) quanto no cliente (JavaScript).
Como registrar uma ability na prática
O desenvolvedor registra uma habilidade especificando:
- Label
- Description
- Dados de entrada (input schema)
- Dados de saída (output schema)
- Callback de execução
- Callback de permissão
Uma vez definida a habilidade, você pode decidir em qual contexto ela fica disponível: REST API, MCP, ou qualquer protocolo futuro, adicionando apenas uma ou duas linhas de configuração.
Duas direções para desenvolvedores de plugins
Jason destaca que existem dois caminhos para desenvolvedores de plugins:
- “Quero usar IA para fazer algo” — gerar imagens, criar resumos, classificar conteúdo. Nesse caso, use o WP AI Client.
- “Quero tornar meu plugin acessível para IA” — permitir que modelos externos controlem funcionalidades do seu plugin. Nesse caso, use a Abilities API + MCP Adapter.
MCP Adapter: conectando WordPress a agentes de IA
O nome “Adapter” é proposital. O time reconhece que não sabe se o MCP vai existir daqui a 3 anos. O adapter simplesmente pega as abilities registradas e as transforma em um servidor MCP com tools, prompts e resources.
Se o MCP desaparecer ou um novo protocolo surgir, basta criar um novo adapter. As habilidades registradas permanecem intactas, você apenas adiciona uma linha de meta para expor a funcionalidade no novo protocolo.
Como o MCP funciona com WordPress na prática
O MCP é o inverso do que muita gente imagina. Não é o WordPress pedindo algo para um modelo — é um modelo externo (ChatGPT, Gemini, Claude, qualquer um) que quer comunicar-se com a sua aplicação WordPress.
O modelo diz: “quero alterar o título do site”. E o MCP responde: “ok, me passe uma string com o novo título e eu faço isso”. Ou: “quero publicar um post”, “quero deletar um comentário” — qualquer operação que faça sentido dentro do WordPress, exposta de forma segura.
<?php
/**
* Plugin Name: Example MCP Server Plugin
* Description: A demonstration WordPress plugin showing how to set up an MCP (Model Context Protocol) server.
* Version: 1.0.0
*/
if ( ! defined( 'ABSPATH' ) ) {
exit; // Exit if accessed directly.
}
// Ensure Composer dependencies are available
if ( ! file_exists( __DIR__ . '/vendor/autoload.php' ) ) {
error_log( 'Example MCP Plugin: Autoloader not found. Please run "composer install" in the plugin directory.' );
exit;
}
require __DIR__ . '/vendor/autoload.php';
// Import classes from the MCP framework
use WP\MCP\Core\McpAdapter;
use WP\MCP\Infrastructure\ErrorHandling\ErrorLogMcpErrorHandler;
use WP\MCP\Infrastructure\Observability\NullMcpObservabilityHandler;
use WP\MCP\Transport\Http\RestTransport;
// Register a site info ability
add_action( 'abilities_api_init', function(){
wp_register_ability( 'site/site-info', array(
'label' => __( 'Site Info', 'ai-experiments' ),
'description' => __( 'Returns information about this WordPress site', 'example-plugin' ),
'input_schema' => array(),
'output_schema' => array(
'type' => 'object',
'properties' => array(
'site_name' => array(
'type' => 'string',
'description' => __( 'The name of the WordPress site', 'example-plugin' )
),
'site_url' => array(
'type' => 'string',
'description' => __( 'The URL of the WordPress site', 'example-plugin' )
),
'active_theme' => array(
'type' => 'string',
'description' => __( 'The active theme of the WordPress site', 'example-plugin' )
),
'active_plugins' => array(
'type' => 'array',
'items' => array(
'type' => 'string',
),
'description' => __( 'List of active plugins on the WordPress site', 'example-plugin' )
),
'php_version' => array(
'type' => 'string',
'description' => __( 'The PHP version of the WordPress site', 'example-plugin' )
),
'wordpress_version' => array(
'type' => 'string',
'description' => __( 'The WordPress version of the site', 'example-plugin' )
)
),
),
'execute_callback' => 'ai_experiments_get_siteinfo',
'permission_callback' => function( $input ) {
return current_user_can( 'manage_options' );
}
));
});
// site info ability execute callback
function ai_experiments_get_siteinfo(){
$site_info = array();
$site_info['site_name'] = get_bloginfo( 'name' );
$site_info['site_url'] = get_bloginfo( 'url' );
$site_info['active_theme'] = wp_get_theme()->get( 'Name' );
$site_info['active_plugins'] = get_option( 'active_plugins', array() );
$site_info['php_version'] = phpversion();
$site_info['wordpress_version'] = get_bloginfo( 'version' );
return $site_info;
}
// Initialize the server adapter
$adapter = McpAdapter::instance();
// Hook into MCP adapter initialization
add_action( 'mcp_adapter_init', function ( $adapter ) {
// Example server configuration
$adapter->create_server(
'example-server', // Server identifier (unique slug)
'example-namespace', // REST API namespace
'mcp', // Base route
'Example MCP Server', // Display name
'A demonstration of an MCP server.', // Description
'1.0.0', // Version
array( // Transports
RestTransport::class,
),
ErrorLogMcpErrorHandler::class, // Error handler
NullMcpObservabilityHandler::class, // Observability handler
// Example abilities exposed as tools
array(
'site/site-info',
)
);
} );Code language: HTML, XML (xml)O papel dos hosts: quem vai fornecer a IA para WordPress?
Um dos pontos mais relevantes do podcast é a discussão sobre quem vai fornecer o acesso aos modelos de IA. Segundo Jason, o maior ponto de dor dos plugins de IA atuais é a configuração da API key:
“Você diz para o usuário: vá até a Anthropic, crie uma conta, configure billing, pegue uma API key e traga de volta. Nesse ponto, você perdeu a grande maioria do mercado.”
A proposta é que provedores de hospedagem assumam essa responsabilidade. O WP AI Client no WordPress 7.0 não virá com nenhuma integração de provedor específico, justamente para não favorecer ninguém. Cabe ao host decidir:
- Qual modelo oferecer (Gemini, GPT, Claude, modelos open-source)
- Como limitar o uso (por tokens, por requests)
- Se vai incluir como diferencial ou cobrar à parte
Isso dá liberdade a cada host para abordar o mercado de forma diferente. Hosts mais técnicos podem oferecer opções avançadas; hosts voltados para usuários finais podem simplesmente bundlear a IA no plano e usá-la como diferencial de marketing.
WordPress 7.0 e IA: o que esperar
O WP AI Client e as APIs relacionadas estão previstos para o WordPress 7.0.
Algumas APIs já foram incluídas no WordPress 6.9, como a Abilities API; agora, na versão 7.0, a WP AI Client API vai funcionar como um refinamento em relação à versão anterior.
O que muda é que desenvolvedores de plugins poderão criar features de IA com muito menos esforço. Imagine um botão “Gerar Resumo” ao lado do campo de excerto, se o ambiente suporta IA, o botão aparece. Se não suporta, o botão simplesmente não existe. Sem erros, sem configuração manual.
Além do chatbot: IA invisível no WordPress
Jason faz um ponto importante: precisamos sair da mentalidade de UI de chatbot. Quando pensamos em IA, pensamos em uma interface de chat — mas essa não é a única forma.
Um botão de “gerar excerto” é gerado por IA. A classificação automática de conteúdo é uma aplicação de IA. Sugestão de tags é IA. Nenhuma dessas features precisa de uma janela de chat. O usuário final nem precisa saber que está usando IA, ele só percebe que o WordPress ficou mais inteligente.
A visão de longo prazo é ambiciosa: fazer com que o WordPress seja associado não como um CMS datado, mas como o primeiro CMS verdadeiramente AI-powered, onde o ecossistema inteiro de plugins, temas e hosts contribui para essa experiência.
AI Experiments Plugin: a implementação de referência (v0.5.0)
O quarto building block é o AI Experiments Plugin, que atua como implementação de referência e laboratório para os demais componentes. Atualmente, na versão 0.5.0, o plugin já está alinhado com o WordPress 7.0.
O que mudou na v0.5.0
A versão 0.5.0 marca a transição para o WordPress 7.0 como versão mínima suportada. As principais mudanças:
- Remoção de dependências internas — o plugin não mantém mais seu próprio AI Client. Agora depende exclusivamente da infraestrutura de IA nativa do WordPress 7.0.
- Migração para Connectors — credenciais de provedores que antes ficavam na tela “AI Credentials” do plugin agora migram para a tela de Connectors do WordPress, centralizando a configuração de provedores de IA para todo o ecossistema.
O que vem na v0.6.0
O roadmap para a próxima versão traz funcionalidades que mostram o potencial prático dessas APIs:
- Image Editing — apagar/substituir objetos, expandir canvas e remover fundo de imagens
- Refine from Notes — integração de feedback editorial com IA para refinar conteúdo
- Content Provenance (C2PA) — rastreamento de proveniência para texto e imagens gerados por IA
- Contextual Tagging — sugestão automática de tags baseada no conteúdo do post
- Onboarding “Try AI” — fluxo conectado ao callout do WordPress 7.0 para novos usuários experimentarem IA
- Possível renomeação — de “AI Experiments” para “WordPress AI”, sinalizando maturidade do projeto
Protótipos em estágio inicial exploram sugestões type-ahead, moderação de conteúdo, logging de requisições de IA, e um AI Playground com integração MCP mais profunda.
A estratégia de distribuição segue a filosofia “canonical first, Core when ready”: a funcionalidade vive em pacotes Composer e plugins até amadurecer o suficiente para o core.
Integração com a Fase 3 do WordPress: Colaboração
Esses building blocks se conectam com várias iniciativas do WordPress:
- Site Admin — agentes de IA, chatbots e automações de workflow na nova interface de administração
- Colaboração em tempo real — IA que resolve comentários, cria revisões e colabora dentro do editor de posts
- Media Library — criação de mídia com IA, alt text automático, agrupamento inteligente e busca multimodal
Como acompanhar o projeto
Repositórios oficiais no GitHub:
- PHP AI Client — SDK agnóstico para qualquer projeto PHP
- WP AI Client — wrapper WordPress com REST API e JavaScript API
- Abilities API — registro unificado de funcionalidades
- MCP Adapter — exposição de abilities via MCP
- AI Experiments — plugin de referência
Canais de comunicação:
- Make AI Blog no wordpress.org — principal canal de atualizações
- Canal #core-ai no Slack do Make WordPress — aberto para perguntas, feedback e contribuições (não precisa ser técnico para participar)
Conclusão
O Core AI Team não está tentando fazer o WordPress competir no espaço de IA com o esforço de um time pequeno. Muitas vezes, as pessoas pedem uma resposta do WordPress. O foco do WordPress é gerenciamento de dados e democratização de conteúdo para a internet.
A estratégia é empoderar o ecossistema inteiro, os milhares de desenvolvedores de plugins, temas e hosts, para que a criatividade coletiva faça o trabalho pesado. Reverberando em novas ferramentas para criadores de conteúdo e donos de plataformas que dependem desta infraestrutura.
Se tudo o que o desenvolvedor precisa fazer é ser criativo sobre como usar IA sem se preocupar com setup, API keys ou compatibilidade de modelos, estamos em um lugar muito interessante.
Deixe um comentário