MCP Abilities - Block Editor WP Registry grade A. No security issues foundWP RegistryNo security issues foundOpen the reportA

WordPress block-editor abilities for MCP. Parse, validate, inspect, generate, and update Gutenberg content safely.

Tested up to: 7.0 Stable tag: 0.20.25 License: GPLv2 or later License URI: https://www.gnu.org/licenses/gpl-2.0.html

What It Does

WordPress block-editor abilities for MCP. Parse, validate, inspect, generate, and update Gutenberg content safely.

The plugin covers four complete jobs: authoring-context inspection, structured generation and quality checks, Site Editor object management, and safe nested block-tree mutation. WordPress remains the authority for object permissions and stored block documents.

Download the stable plugin ZIP

This plugin is part of the MCP abilities ecosystem. It gives an MCP-capable agent a focused, authenticated way to work with Block Editor work inside WordPress through MCP.

Example: "Handle this WordPress maintenance task directly." - The agent can inspect the site, call the relevant ability, and return the result without making the human click through wp-admin for every step.

The Real Workflow

In practice, the human should not have to memorize every ability name.

The normal pattern is:

1. install the base MCP stack
2. install only the add-ons the site actually needs
3. let the agent discover the available abilities
4. give the agent a clear task with boundaries
5. verify the result in WordPress

The human's job is mostly to describe the goal. The agent's job is to figure out the mechanics.

Why This Feels Different

Most WordPress automation still leaves the repetitive part to the human.

This plugin is different because the agent can act inside the site through a narrow, authenticated ability surface:

• inspect current site state before changing anything
• run the specific action needed for the task
• return structured results that are easy to verify
• keep the workflow inside WordPress instead of a separate checklist

That changes the experience from:

• Here is what you should do in wp-admin

to:

• Tell the agent what needs doing, and let it carry out the work

Before vs After

Before

• ask the AI what to do
• copy the answer into WordPress by hand
• click through wp-admin for the repetitive bits
• postpone maintenance because the task is tedious

After

• tell the agent what needs doing
• let it inspect the relevant WordPress state
• let it run the targeted ability
• verify the result and move on

Who It Is For

This is a good fit for:

• agencies managing WordPress sites with AI-assisted maintenance
• operators who want agents to do real WordPress work instead of producing instructions
• teams already using MCP Expose Abilities
• sites where this WordPress area is updated often enough to deserve automation

It is especially useful when the manual version is repetitive enough that important maintenance gets delayed.

Documentation

Start with the main plugin page and base stack documentation:

• MCP Expose Abilities
• Plugin page
• Getting Started
• Install Order and Dependencies

If you are using an AI agent, the simplest instruction is often just:

• Read https://github.com/bjornfix/mcp-expose-abilities and figure out the stack before making changes.

Start Here

If you are new to the stack, use this order:

1. Install Abilities API.
2. Install MCP Adapter.
3. Install MCP Expose Abilities.
4. Install MCP Abilities - Block Editor.
5. Confirm the new abilities appear in discovery.
6. Give the agent a clear task that uses this add-on.

If you skip base-stack verification and start with add-ons immediately, troubleshooting gets harder than it needs to be.

Abilities (67)

Ability	Description
gutenberg/get-theme-context	Return active-theme and block-theme context relevant to Gutenberg authoring
gutenberg/get-style-guide	Summarize theme spacing, typography, palette, and layout guidance
gutenberg/get-style-book	Return block-style-book style context and styled block data
gutenberg/get-site-editor-summary	Summarize site-editor objects such as templates, parts, styles, and navigations
gutenberg/get-site-editor-references	Inspect cross-references between site-editor objects
gutenberg/list-available-blocks	List registered Gutenberg blocks available on the site
gutenberg/get-block-categories	List Gutenberg block categories
gutenberg/get-block-details	Return metadata for a specific block type
gutenberg/get-block-style-variations	List style variations for a block type
gutenberg/list-patterns	List registered block patterns
gutenberg/get-pattern	Get a specific registered pattern
gutenberg/list-synced-patterns	List reusable synced patterns (wp_block)
gutenberg/get-synced-pattern	Get a synced pattern by ID
gutenberg/block-guidance	Recommend the right Gutenberg block or layout pattern for a scenario
gutenberg/get-page-recipes	Return landing-page or full-page recipe options
gutenberg/get-section-recipes	Return reusable section recipe options
gutenberg/get-query-section-recipes	Return dynamic query-loop section recipe options
gutenberg/generate-landing-page	Generate a structured Gutenberg landing page
gutenberg/generate-section	Generate a reusable section from recipe-style inputs
gutenberg/generate-query-section	Generate a dynamic core/query section
gutenberg/validate-content	Validate block-tree shape, mutation safety, and layout-risk styles
gutenberg/audit-content	Run Gutenberg-specific QA checks on content structure
gutenberg/evaluate-design	Score design coherence and flag layout/design issues
gutenberg/suggest-design-fixes	Turn design findings into concrete remediation suggestions
gutenberg/evaluate-copy	Score copy quality and flag weak writing patterns
gutenberg/suggest-copy-fixes	Turn copy findings into rewrite suggestions
gutenberg/analyze-content	Analyze outline, links, media usage, and block usage
gutenberg/evaluate-render-context	Inspect the rendered page wrapper/context around Gutenberg content
gutenberg/parse-content	Parse Gutenberg content into a normalized block tree
gutenberg/serialize-blocks	Serialize normalized blocks back into valid Gutenberg markup
gutenberg/get-post-blocks	Read a post or page as structured Gutenberg blocks
gutenberg/list-templates	List block-theme templates
gutenberg/get-template	Get a block-theme template
gutenberg/create-template	Create a block-theme template
gutenberg/update-template	Update a block-theme template
gutenberg/list-template-parts	List block-theme template parts
gutenberg/get-template-part	Get a template part
gutenberg/create-template-part	Create a template part
gutenberg/update-template-part	Update a template part
gutenberg/list-navigations	List wp_navigation entities
gutenberg/get-navigation	Get a navigation entity
gutenberg/create-navigation	Create a navigation entity
gutenberg/update-navigation	Update a navigation entity
gutenberg/find-navigation-usage	Find where a navigation is referenced
gutenberg/find-template-part-usage	Find where a template part is referenced
gutenberg/find-synced-pattern-usage	Find where a synced pattern is used
gutenberg/create-page-from-blocks	Create a page directly from Gutenberg blocks
gutenberg/create-synced-pattern	Create a synced pattern (wp_block)
gutenberg/update-synced-pattern	Update a synced pattern
gutenberg/extract-synced-pattern	Extract existing blocks into a synced pattern
gutenberg/insert-synced-pattern-into-post	Insert a reusable synced pattern reference into a post
gutenberg/create-page-from-pattern	Create a page from a registered pattern
gutenberg/create-landing-page	Create a landing page from business inputs
gutenberg/insert-pattern-into-post	Insert a registered pattern into a post
gutenberg/transform-blocks	Apply structural block transforms
gutenberg/mutate-block-tree	Edit nested block trees by path
gutenberg/set-block-lock	Set block lock attributes
gutenberg/set-allowed-blocks	Set allowed child blocks for container blocks
gutenberg/set-template-lock	Set template-lock behavior
gutenberg/insert-inner-block	Insert a child block at a path
gutenberg/duplicate-block	Duplicate a block at a path
gutenberg/move-block	Move a block in the tree
gutenberg/replace-block-text	Replace text content inside matching blocks
gutenberg/get-block-bindings	Inspect Gutenberg block bindings
gutenberg/set-block-bindings	Update Gutenberg block bindings
gutenberg/normalize-heading-levels	Normalize heading hierarchy
gutenberg/update-post-blocks	Save structured Gutenberg blocks back to a post

Usage Examples

Get block guidance for a content scenario

{
  "ability_name": "gutenberg/block-guidance",
  "parameters": {
    "scenario": "hero section for a local service page"
  }
}

Generate a section

{
  "ability_name": "gutenberg/generate-section",
  "parameters": {
    "recipe": "pricing",
    "business_name": "Example Studio",
    "tone": "clear and commercially sharp"
  }
}

Evaluate design before saving

{
  "ability_name": "gutenberg/evaluate-design",
  "parameters": {
    "post_id": 231
  }
}

Update a page from structured blocks

{
  "ability_name": "gutenberg/update-post-blocks",
  "parameters": {
    "id": 123,
    "blocks": [
      {
        "block_name": "core/paragraph",
        "attrs": {},
        "inner_blocks": [],
        "inner_html": "<p>Hello world</p>",
        "inner_content": ["<p>Hello world</p>"]
      }
    ]
  }
}

Notes

• This plugin is Gutenberg-specific and intentionally does not duplicate generic content/* or media/* abilities from the core plugin.
• It is designed to keep Gutenberg content as structured data instead of brittle HTML strings.
• gutenberg/evaluate-design, gutenberg/evaluate-copy, and gutenberg/evaluate-render-context exist to catch weak output before publishing, not just after.
• gutenberg/validate-content now includes mutation guardrails for static-block edits and layout-risk style detection.
• Block-document writes expose neutral preflight and protected-marker filters so a site plugin can add policy without coupling this public plugin to that site.
• gutenberg/evaluate-render-context inspects the rendered page wrapper around .entry-content or .page-content so wrapper-induced problems can be surfaced even when the block markup itself is valid.

Changelog

0.20.24

• Adds neutral site-policy seams for block-document write preflight and protected design markers.
• Removes the site-specific editorial validator and ability from this public plugin; site policy now belongs in the site's private adapter.

0.20.23

• Recognizes semantic GenerateBlocks headlines during content validation and keeps static-markup mutation guidance in the structured guardrail field instead of emitting a page warning.

0.20.22

• Fixed FAQ schema detection for nested Rank Math FAQ blocks inside Gutenberg container layouts.

0.20.21

• Refined Gutenberg design evaluation so Rank Math FAQ blocks are recognized as schema-backed FAQ content and normal three-card support rows are not blocked as cramped when their copy load is moderate.

0.20.20

• Routes source-design update preflight through a registered site-policy filter so the site adapter owns its contract.

0.20.19

• Fixed gutenberg/update-post-blocks so registered source-design repairs are preflighted against proposed content before save.

0.20.18

• Added an early site-policy source-design adapter; superseded by the neutral public seams in 0.20.24.

0.20.17

• Added an early site-specific editorial validator; removed from the public plugin in 0.20.24.

0.20.16

• Fixed no-argument Gutenberg abilities so MCP adapters that send empty input as an empty PHP array can still call style-guide, pattern, and site-editor inspection tools.

0.20.15

• Lowered the minimum WordPress metadata back to 6.9 while keeping 7.0 as the tested version.
• Made generated landing pages and reusable sections theme-neutral by removing bakery-specific copy, hardcoded gradient identity, and block-level typography overrides.
• Added small generation helpers for buttons and lists so generated markup has better locality and is easier to audit.

0.20.14

• Improved ability error responses so WordPress error codes, issue lists, and structured error data are preserved instead of returning message-only failures.
• Improved all ability output schemas so they include the shared error fields used by Gutenberg write and generation gates.
• Hardened site-editor template, template-part, and navigation write abilities so they require edit_theme_options at the ability permission layer.

0.20.13

• Refactored the block-editor implementation into focused include modules for core block handling, catalogs/site editor data, content analysis, block mutations, generation, and ability registration. No MCP ability names changed.
• Added write and generator gates that reject invalid Gutenberg block syntax before saving or returning generated content, with concrete issue details.
• Hardened site-editor template and navigation writes so they require the WordPress edit_theme_options capability.

0.20.12

• Fixed: gutenberg/audit-content no longer flags core/buttons wrapper blocks as missing links, avoiding false button_without_link warnings during valid button-group layouts

0.20.11

• Shared one editor-safe save pipeline across Gutenberg write paths for content preparation, layout validation, design-markup protection, persistence, and response formatting
• Reused the same write safety checks for page, template, navigation, synced-pattern, and post block updates

0.20.10

• Normalized legacy core/list markup into current core/list-item inner blocks before MCP writes, preventing WordPress 7.0 editor-invalid list blocks
• Repaired core/button border-class mismatches and URL attributes that lost JSON unicode escaping during transport before saving content
• Added editor-compatibility reporting to gutenberg/validate-content for issues PHP round-trips can miss

0.20.9

• Fixed broad Gutenberg content replacement paths so they block accidental removal of existing GenerateBlocks/design markup unless explicitly overridden

0.20.8

• Fixed zero-parameter ability schemas so MCP Adapter 0.4.x clients do not receive invalid properties: [] JSON

0.20.7

• Refined support_module_cramp_risk so clearly stacked/list-based proof groups are not treated like cramped horizontal strips
• Reinforced the calmer vertical proof-list fallback when support copy is too substantial for equal-width strip modules

0.20.6

• Tightened alignfull_breakout_risk so custom page-level width systems with multiple alignfull sections now fail unless the content explicitly neutralizes Gutenberg breakout margins
• Expanded block guidance so AI clients know to neutralize alignfull or switch to non-breakout full-width wrappers when a page introduces its own shell sizing

0.20.4

• Added faq_schema_missing_risk so the design evaluator can fail visually real FAQ sections that still lack matching FAQ schema
• Expanded block guidance and design-fix suggestions so AI clients preserve a good FAQ layout and add matching FAQPage JSON-LD underneath it instead of flattening the design

0.20.3

• Fixed support-row cramp evaluation so distinct Gutenberg rows no longer collapse into one generic selector

0.20.2

• Added support_module_cramp_risk so the evaluator can flag process rows, proof strips, and similar support modules that still feel too narrow

0.20.1

• Parsed width and max-width declarations inside CSS functions like min(...), so shell measures count as real page-width anchors during design evaluation

0.20.0

• Taught design evaluation to recognize generic shell/container/wrapper selectors as real page-width anchors, so underused inner text lanes are measured against the actual shell instead of being ignored

0.19.9

• Added fullwidth_section_seam_gap_risk so gutenberg/evaluate-design can flag seams between adjacent full-width sections that should visually touch

0.19.8

• Added followup_cluster_detachment_risk so gutenberg/evaluate-design can flag proof rows or support clusters that drift too far below the selling moment they belong to

0.19.7

• Expanded non-interactive proof guidance so visually prominent proof rows are expected to carry useful supporting lines instead of bare label chips

0.19.6

• Added noninteractive_control_affordance_risk so gutenberg/evaluate-design can flag inert labels or proof chips that are styled like clickable controls

0.19.5

• Expanded internal_measure_mismatch so widened sections can still fail when nested container rows quietly stay on a narrower usable measure

0.19.4

• Expanded editorial split-layout guidance so AI clients are nudged to center visibly shorter support columns and use full-height structural dividers

0.19.3

• Expanded gutenberg/evaluate-design with internal_measure_mismatch
• Added subtle_tilt_ambiguity
• Added repeated_object_treatment_inconsistency

0.19.1

• Made evaluate-render-context and other editable-post helpers work reliably from WP-CLI validation runs by binding to the first administrator when CLI is running without a current user

0.19.0

• Added spacing_rhythm_drift so the design layer can flag pages whose top-level Gutenberg sections use too many unrelated spacer heights, paddings, or margins

0.18.9

• Added row_treatment_inconsistency so the design layer can catch repeated rows where one sibling becomes a stray boxed/card-like module while the others stay open

0.18.8

• Tightened card_monotony_risk so the design layer can flag page-wide overuse of boxed section treatments

0.18.7

• Added card_monotony_risk so the design layer can flag when too many sections fall back to the same rounded-box/card treatment

0.18.6

• Expanded the design layer to flag design-token sprawl when a page uses too many different border-radius or shadow treatments

0.18.5

• Added gutenberg/suggest-design-fixes so design issues now come back with concrete remediation guidance instead of only scores and warnings

Contributing

PRs welcome. Keep changes focused on the plugin's WordPress ability surface and preserve authenticated, explicit workflows.

License

GPL-2.0+

Author

basicus

Links

• Plugin Page
• MCP Expose Abilities
• GitHub Releases

Star and Share

If this plugin saves you time or makes WordPress maintenance easier to verify, please:

• star the repo
• share it with people running WordPress sites
• point them to the main plugin page so they can see what the ecosystem can actually do

Why do it?

Because agent-friendly open WordPress tooling helps more of the boring but important work get done.