1) Baseline: measure before you optimize

Make performance visible first, then iterate. Capture three numbers on a staging copy: average editor load, average publish (save_post) time, and 95th percentile AI request latency.

WP-CLI profile (request hotspots)

# Profile a front-end request (requires WP-CLI profile command)
wp profile stage --url=https://example.com --fields=hook,time,cache_hits,cache_misses --all

Log slow HTTP calls (WordPress HTTP API)

<?php
add_filter('http_api_debug', function($response, $context, $class, $args, $url){
  if (!empty($args['timeout']) && $args['timeout'] < 20) { /* keep timeouts sane */ }
  if (!is_wp_error($response) && isset($response['http_response'])) {
    $code = $response['response']['code'] ?? 0;
    $t    = $response['http_response']->get_response_object()->headers['x-runtime'] ?? 'NA';
    error_log("[AI_HTTP] {$code} {$url} runtime={$t}");
  }
}, 10, 5);

Target: the editor and REST endpoints should stay < 1s P50 even while AI jobs run elsewhere.

2) Offload AI work from the editor request

Don’t block the editor while waiting on an AI API. Return quickly and process in the background. Two safe patterns:

Pattern A — Queue + cron worker

1. On button click, enqueue a job (post ID, prompt hash, model, user).
2. Return a “job accepted” message to the editor instantly.
3. A cron task pulls the next job, calls the AI API, stores the result, and notifies the user.

<?php
function ai_enqueue_job($post_id, $prompt){
  $key = 'ai_job_' . md5($post_id.$prompt);
  set_transient($key, ['post_id'=>$post_id,'prompt'=>$prompt,'ts'=>time(),'status'=>'queued'], 12 * HOUR_IN_SECONDS);
  wp_schedule_single_event(time() + 60, 'ai_process_job', [$key]); // run in 60s
}

add_action('ai_process_job', function($key){
  $job = get_transient($key);
  if (!$job || 'queued' !== $job['status']) return;
  // ... call AI API here (wp_remote_post / curl) ...
  // $content = ...
  wp_update_post(['ID'=>$job['post_id'], 'post_content'=>$content]);
  set_transient($key, ['status'=>'done'] + $job, 2 * HOUR_IN_SECONDS);
});

Pattern B — Fire-and-poll (non-blocking)

Kick off an async request and poll via a light REST endpoint; show progress in the UI without holding PHP open.

<?php
wp_remote_post($endpoint, [
  'blocking' => false,          // return immediately
  'timeout'  => 5,
  'headers'  => ['Content-Type' => 'application/json'],
  'body'     => wp_json_encode($payload),
]);

Guardrails: cap concurrency (queue depth), add per-user rate limits, and always log failures for replay.

3) Cache strategy: object cache + transients

Cache everything that is deterministic: prompts → responses, image prompts → URLs, and expensive list endpoints. Use a persistent object cache (e.g., Redis) so values survive between requests.

Cache by prompt hash (idempotent)

<?php
function ai_cached_response($prompt, $ttl=3600){
  $key = 'ai_resp_' . hash('sha256', $prompt);
  $val = wp_cache_get($key, 'ai');
  if ($val) return $val;

  // Call provider
  $resp = wp_remote_post('https://api.example.ai', [
    'timeout' => 20,
    'headers' => ['Authorization' => 'Bearer ...'],
    'body'    => wp_json_encode(['input' => $prompt]),
  ]);

  $body = is_wp_error($resp) ? null : wp_remote_retrieve_body($resp);
  if ($body) wp_cache_set($key, $body, 'ai', $ttl);
  return $body;
}

When transients are enough

For small sites without Redis, transients provide a simple TTL cache. Use them for “safe to miss” responses.

<?php
$key = 'ai_summ_' . md5($post_id);
if (false === ($summary = get_transient($key))) {
  $summary = ai_generate_summary(get_post_field('post_content', $post_id));
  set_transient($key, $summary, 6 * HOUR_IN_SECONDS);
}

Invalidation: bust caches on content update (save_post hook) or when model/temperature changes.

4) PHP OPcache & PHP-FPM hardening

OPcache compiles PHP to bytecode and keeps it in memory. Ensure it’s enabled with a sane memory budget and revalidate frequency. Tune PHP-FPM to avoid worker thrash under bursty AI jobs.

5) REST batching, timeouts & exponential backoff

Batch related writes (e.g., create post + upload images + set meta) to reduce handshake overhead. For third-party APIs, implement retries with jitter to play nicely with rate limits.

REST batching pattern

<?php
function wp_rest_batch($requests){
  $results = [];
  foreach ($requests as $r){
    $res = wp_remote_request($r['url'], [
      'method'  => $r['method'] ?? 'POST',
      'timeout' => $r['timeout'] ?? 15,
      'headers' => $r['headers'] ?? [],
      'body'    => $r['body'] ?? null,
    ]);
    $results[] = is_wp_error($res) ? null : wp_remote_retrieve_response_code($res);
    usleep(50 * 1000); // light pacing
  }
  return $results;
}

Retry with exponential backoff

<?php
function http_with_backoff($url, $args=[], $retries=3){
  $delay = 200; // ms
  for ($i=0; $i<=$retries; $i++){
    $res = wp_remote_post($url, $args);
    if (!is_wp_error($res) && wp_remote_retrieve_response_code($res) < 500) return $res;
    usleep($delay * 1000 + rand(0, 100000));
    $delay *= 2;
  }
  return $res;
}

Timeouts: keep API timeouts ≤ 20s on foreground requests; longer only in workers.

6) Images & media from AI pipelines

AI image/video can hammer disk and CPU. Offload early and cache aggressively.

• Object storage: Store large media in S3/compatible; serve via CDN.
• Formats: Prefer WebP/AVIF where supported; include srcset.
• Lazy-load: Always set loading="lazy" on inline images/iframes.
• ETag/Cache-Control: Set long TTLs; purge on update.

7) Server/runtime settings that matter

• Memory limit: PHP memory_limit 256–512M for AI plugins; test under load.
• Max execution: Keep max_execution_time ≤ 60s; long jobs → workers.
• HTTP keep-alive: Enable reuse on upstream/proxy to cut handshake cost.
• TLS session resumption: Reduce CPU per request (terminating proxy).
• Nginx buffers/fastcgi: Tune for token-stream responses if you stream.

When you’re ready to scale AI content production with performance best practices built in, streamline the flow with PostCrane’s WordPress-native AI content engine.

8) Performance levers: impact vs effort

Conclusion & next steps

AI features don’t have to slow WordPress down. Measure first, move AI work off the request path, cache aggressively, and harden PHP-FPM/OPcache. Batch writes and handle rate limits with backoff. Iterate weekly with small, measurable changes and keep your editors flying.

SGE Optimisation

• Return fast; run AI in background
• Cache prompt→response with TTL
• Enable OPcache + persistent cache
• Batch REST; add retry + backoff
• Profile regularly; tune FPM

PAA: optimize WordPress for AI workload performance by moving AI calls off the request path, enabling OPcache and persistent object caching, caching prompt responses with TTLs, and batching REST writes with retries.