GoBuildWP

Caching and page speed · 25 plugins · 26 layers

WordPress Cache Plugin MCP that measures before it keeps a change.

A WordPress cache plugin MCP has to see the whole stack, because a page cache, an asset optimiser, an object cache and a CDN each keep their own copy. One shared module detects every layer, changes one setting at a time and measures what the change did.

What goes wrong without a plugin-aware module

  1. An edit that looks like it failed because one of several caches is still serving the old page
  2. Optimisation settings enabled that read back correctly and change nothing on the wire
  3. Speed work judged by a settings screen instead of a rendered page

Why it matters

What plugin-aware changes for caching and page speed

Caching is stacked, not singular, and the layers do not know about each other. An asset optimiser sits in front of a page cache, a CDN sits in front of both, and an object cache sits underneath. Purge one and the site serves a mix of old and new markup, which reads as a failed write rather than a stale cache. The second trap is quieter: a setting can be written, read back correctly, report success, and still do nothing, because whatever would carry it out lives outside WordPress - a host with no rewrite file, an edge that is not caching HTML, a next-gen image setting with no converter producing the files.

A first safe workflow

Detect every layer first, then take a baseline before touching anything: purge, warm, and measure, in that order, because measuring straight after a purge times WordPress building the page rather than the cache serving it. Then change one setting, repeat the loop, and keep it or roll it back. A batch of changes with one check at the end tells you nothing about which one did the damage.

How to tell it worked

In a browser, not on a settings screen. A write that reports success cannot see that the header logo is now a transparent placeholder, that a combined stylesheet returns a 404, or that deferring JavaScript stopped the menu opening. Core Web Vitals do not exist until a browser renders, so LCP and CLS come from the rendered page, and the request timings say whether an above-the-fold image started downloading late.

Modules

25 modules compared

Each module loads only when its plugin is active and needs GoBuildWP Pro. Open a module for its full ability list, requirements and safety notes.

Cache settings and purge declarations for each driver
PluginLayerMapped keysNative option fieldsPurge entry points
LiteSpeed Cachepage22
22 declared
  • litespeed.conf.cache
  • litespeed.conf.cache-ttl_pub
  • litespeed.conf.cache-mobile
  • litespeed.conf.cache-priv
  • litespeed.conf.cache-exc
  • litespeed.conf.cache-browser
  • litespeed.conf.cache-ttl_browser
  • litespeed.conf.object
  • litespeed.conf.optm-css_min
  • litespeed.conf.optm-css_comb
  • litespeed.conf.optm-css_async
  • litespeed.conf.optm-ucss
  • litespeed.conf.optm-js_min
  • litespeed.conf.optm-js_comb
  • litespeed.conf.optm-js_defer
  • litespeed.conf.media-lazy
  • litespeed.conf.media-iframe_lazy
  • litespeed.conf.media-add_missing_sizes
  • litespeed.conf.img_optm-webp
  • litespeed.conf.optm-css_font_display
  • litespeed.conf.cdn
  • litespeed.conf.crawler
allurlpost
WP Rocketpage24
1 declared
  • wp_rocket_settings
allurlpost
WP Fastest Cachepage7
1 declared
  • WpFastestCache
allurlpost
Speed Optimizer (SiteGround)page11
11 declared
  • siteground_optimizer_enable_cache
  • siteground_optimizer_enable_memcached
  • siteground_optimizer_enable_browser_caching
  • siteground_optimizer_optimize_css
  • siteground_optimizer_combine_css
  • siteground_optimizer_optimize_javascript
  • siteground_optimizer_combine_javascript
  • siteground_optimizer_optimize_javascript_async
  • siteground_optimizer_lazyload_images
  • siteground_optimizer_lazyload_iframes
  • siteground_optimizer_webp_support
allurl
WP-Optimizepage14
2 declared
  • wpo_cache_config
  • wpo_minify_config
allurlpost
W3 Total Cachepage8Noneallurlpost
Autoptimizeasset8
7 declared
  • autoptimize_imgopt_settings
  • autoptimize_css
  • autoptimize_css_aggregate
  • autoptimize_css_defer
  • autoptimize_js
  • autoptimize_js_aggregate
  • autoptimize_js_defer_not_aggregate
all
SpeedyCachepage6
4 declared
  • speedycache_options
  • speedycache_cdn
  • speedycache_object_cache
  • speedycache_img
allurlpost
Breezepage12
5 declared
  • breeze_basic_settings
  • breeze_advanced_settings
  • breeze_file_settings
  • breeze_cdn_integration
  • breeze_preload_settings
all
Cache Enablerpage3
1 declared
  • cache_enabler
allurlpost
PerfmattersassetNone
3 declared
  • perfmatters_options
  • perfmatters_tools
  • perfmatters_script_manager
None declared
FlyingPresspageNone
2 declared
  • flying_press_settings
  • FLYING_PRESS_SETTINGS
allurl
WP Super CachepageNone
4 declared
  • wpsc_
  • ossdl_
  • supercache_
  • wp_cache_
allurlpost
Redis Object CacheobjectNone
2 declared
  • redis_object_cache
  • wp_redis_
all
Jetpack BoostpageNone
1 declared
  • jetpack_boost_
all
Aruba HiSpeed CachepageNone
2 declared
  • ahsc_
  • aruba_hispeed
None declared
NitroPackpageNone
1 declared
  • nitropack
allurl
HummingbirdpageNone
2 declared
  • wphb_
  • wphb-
all
10Web BoosterpageNone
2 declared
  • tenweb_
  • twoptimize_
None declared
Docket CacheobjectNone
2 declared
  • docket_cache
  • docket-cache
all
SQLite Object CacheobjectNone
1 declared
  • sqlite_object_cache
all
Powered CachepageNone
1 declared
  • powered_cache
all
Swift PerformancepageNone
1 declared
  • swift_performance
all
Swift Performance LitepageNone
1 declared
  • swift_performance
all
Super Page Cache for CloudflareedgeNone
1 declared
  • swcfpc_
all
Converter for MediaassetNone
1 declared
  • webpc_
None declared

26 detected layers, 10 with a shared settings map. Purge entry points are declared in the source, not proof that a callback exists on your installed version. CDN and host caches may need separate credentials, and a flush does not by itself make a page faster.

Worked example

Try deferring JavaScript on a store's product page, and keep the change only if the page gets faster without breaking.

The shared cache module, which detects every cache and speed layer on the site rather than assuming there is one.

  1. wppilot/cache-check-setupPro

    Lists every layer in front of the site: page cache, asset optimiser, object cache, and any CDN or host edge that answered, with the purge scopes each supports.

  2. wppilot/cache-begin-experimentPro

    Snapshots the settings rows of each cache plugin GoBuildWP can read, native keys included, and returns an experiment id so one call can put them back later. Layers it cannot snapshot, such as a CDN or host edge, are listed under not_captured and will not be reverted.

  3. wppilot/cache-measure-pagePro

    Takes the baseline after a purge and a warm: time to first byte over repeated requests, whether the cache answered HIT, HTML weight, and render-blocking files.

  4. wppilot/cache-set-settingsPro

    Sets js.defer. It is one of the keys refused without confirm=true, because it is among the settings most likely to break a menu or a checkout while the settings screen looks fine.

  5. wppilot/cache-warmPro

    Purges have already happened as part of the write; this requests the page again so the next measurement times the cache rather than WordPress rebuilding the page.

  6. wppilot/cache-verify-in-browserPro

    Returns suggested browser checks and PageSpeed report links for that URL. The ability does not run a browser or prove that the menu, layout or checkout works.

What to check yourself. Run those browser checks in a real browser: open the menu, add to cart, watch the console. If anything fails or the numbers are worse, wppilot/cache-revert-experiment writes the captured settings back in one call and reports whether they match the snapshot. It does not reach layers listed as not captured, and a plugin that builds rewrite rules or a config file from its settings may need its settings screen saved once to regenerate them.

Choosing what to tune, and how

Shared keys, native settings and presets: three ways to change a cache plugin

Every cache plugin here answers the same module, but each exposes a different share of its own settings to it. The table above shows the split. Mapped keys are the shared vocabulary, such as page cache on, CSS minify or JavaScript defer, that cache-set-settings writes on any plugin that supports them. Native fields are the plugin's own option names, reachable through cache-set-native for everything the shared model does not cover; LiteSpeed's guest mode, ESI and per-asset exclusions are examples. A plugin with no native fields declared, such as W3 Total Cache, is limited to the shared keys.

cache-set-native refuses any key it cannot read back first, so a key renamed between plugin versions is rejected instead of creating an option the plugin ignores. Read with cache-get-settings and include_native before writing.

When a preset is the right tool, and when it is not

cache-list-presets shows the conservative, balanced and aggressive configurations and, more usefully, which keys would actually change on this site. cache-apply-preset writes them as one ledger entry that rollback-change undoes in full; the aggressive preset needs confirm because it includes the gated keys. A preset suits a site where the cache plugin was installed and never configured. On a site you are tuning against measurements, set one key at a time instead, because a preset that makes things slower will not tell you which of its settings did it.

Actions that are not settings, and the ones you cannot undo

Crawling, preloading and database clean-up are listed by cache-list-actions and run with cache-run-action. Each entry says whether the action blocks, whether it is destructive and whether its entry point resolves on this install, and an unavailable one is refused rather than reported as done. Database clean-up deletes rows such as old revisions; it needs confirm and the change ledger cannot bring them back, because the ledger restores settings, not deleted content. Take a backup before any destructive action, and re-measure later after a non-blocking one, since it only queued the work.

One page cache per site

Stacked caching is normal: a page cache, an asset optimiser, an object cache and a CDN each do a different job. Two page caches doing the same job is not. Run cache-check-setup on an inherited site and, if it reports more than one page-cache plugin, pick one to keep, usually the one your host recommends, and deactivate the other in wp-admin before tuning anything. Measurements taken with two page caches answering tell you about whichever one won the request, not about the setting you changed.

FAQ

Caching and page speed and AI, answered

Why did my edit not show up on the front end?

Almost always a cache rather than a failed write. Confirm the database actually changed by reading the post back; if it did, a page cache is still serving HTML built before the edit. Purging one layer is not enough on a stacked site, which is why the purge here reaches every detected WordPress-side layer at once and reports which entry point it called for each. A CDN or host edge in front of the site is not purged by it and needs its own purge.

Can an agent safely turn on things like combining CSS or deferring JavaScript?

Those are gated. Combining CSS or JavaScript, critical CSS, unused-CSS removal, deferring JavaScript and caching for logged-in users are refused without an explicit confirmation, and the refusal names which keys it stopped. They are the settings that most often break a site while leaving the settings screen looking perfectly correct.

Does GoBuildWP give a PageSpeed score?

It reports Google's and never invents one. GoBuildWP Free's pagespeed-check asks PageSpeed Insights through Site Kit, or through GoBuildWP Cloud with GoBuildWP's own Google key, so no key is needed from you; a key of your own is optional. Separately, server-side measurement reports time to first byte, whether the cache answered HIT or MISS, HTML weight, and how many stylesheets and scripts block the first paint. Lighthouse figures are one simulated load; real visitors' LCP, CLS and INP come only from field data, when Google has it for the page.

What if the fix is not a WordPress setting at all?

Then it says so, and says whose job it is. A host with no rewrite file makes browser-cache headers and WebP delivery inert while both still read back as enabled; an edge reporting DYNAMIC for the HTML means every visitor reaches the origin however well the page cache performs. Each of those comes back with which settings it silently neutralises and the steps for whoever owns that panel.

Start in Read Only, then add what the site runs

Connect your AI client to the free MCP foundation and check what it can see. Add Pro when a job needs the module for your installed plugin.