# Divi 5 vs Oxygen — AI Bot Builder Comparison

Which WordPress page builder should power an AI agent-driven site building pipeline? This paper compares Divi 5 and Oxygen Builder across the three criteria that matter for bot-driven construction: Vision (can agents see the builder?), Buildability (can agents construct pages programmatically?), and Bot Functionality (what REST APIs, MCP servers, and automation tools exist?).

Context: Steve holds licenses for both builders. This is not a “which to buy” recommendation — it's a “which to bet the bot-building pipeline on” analysis. All Divi 5 data comes from production experience across 4 active sites (kaburu.co, l8.kaburu.co.uk, thechippyvan.co.uk, llmtest.kaburu.co). Oxygen data is researched from public documentation, community tools, and third-party MCP server listings.

—

## Executive Summary

Recommendation: Divi 5 is the clear winner for AI bot-driven site building in 2026. The free, production-proven DiviOps MCP ecosystem (85 tools, zero cost) and comprehensive REST API give agents a mature programmatic surface that Oxygen simply doesn't match. Oxygen's cleaner architecture and JSON tree format are appealing, but the tooling gap is decisive.

—

## 1. Criterion: Vision — Can Agents SEE the Builder?

Agents need to inspect builder state, understand page structure, and verify their work visually. This section scores how well each builder exposes itself to machine observation.

### Divi 5 — Score: 7/10

Runtime State Inspection (window.divi.data):

Divi 5's Visual Builder exposes a read-only state registry inside the VB iframe:

```javascript var store = window.divi.data.select('divi/edit-post'); store.getAllModuleIds(); // Array of all module IDs on page store.getModuleName(id); // 'divi/text', 'divi/section', etc. store.getModuleType(id); // 'module', 'section', 'row', 'column' store.getModuleAttrs(id); // Full attributes object ```

This gives agents programmatic visibility into every module on the page — what it is, what its attributes are, and where it sits in the hierarchy. The limitation: it's read-only and module IDs are ephemeral (change on every page reload).

LLM-Friendly Documentation:

The [16wells Divi 5 Docs](https://16wells.github.io/divi-docs/) provide structured, machine-readable documentation covering 70+ modules, the Visual Builder architecture, decoration paths, and a Known Limitations playbook. This is purpose-built for LLM consumption — far more agent-friendly than traditional human-oriented docs.

Respira MCP — Full Intelligence:

Respira's MCP server provides Full Intelligence on Divi 5: 40+ module definitions, 7 page patterns, design tokens, and a 13-point validation system. Agents can extract builder content as structured trees and query module schemas at runtime.

Visual QA Pipeline (Proven):

A working visual QA pipeline exists: Chromium headless → PNG screenshot → minicpm-v:8b vision model → design QA feedback. This runs locally on the Z840 (two RTX 3060 GPUs) with a known VRAM tradeoff (conflicts with llama-server when both run simultaneously).

Weaknesses: - Dual-frame architecture (parent window + iframe) requires cross-frame awareness - `wp.data`/Redux store is NOT available — agents must use `window.divi.data` only - REST-created blocks are invisible in the VB Layers panel (see Buildability section) - No public JSON import/export schema

### Oxygen — Score: 6/10

JSON Component Tree:

Oxygen stores page layouts as serialized JSON component trees in postmeta (`_ct_builder_json`). This format is inherently more agent-friendly than Divi's deeply nested block comments:

```json {

"id": 1,
"name": "ct_section",
"options": {"ct_id": 1, "selector": "section-1-123"},
"children": [
  {"id": 2, "name": "ct_headline", "options": {"ct_content": "Welcome"}},
  {"id": 3, "name": "ct_link_button", "options": {"ct_content": "Get Started"}}
]

} ```

The flat `id`/`name`/`options`/`children` structure is easier for agents to parse than Divi's `<!– wp:divi/text {“module”:{“decoration”:{…}}} –>` format. Respira catalogs 49 components with 140+ CSS properties across this tree.

Respira MCP — Smart Defaults:

Respira supports Oxygen with Smart Defaults: element-tree reading, structure-aware writes (preserving parent/child references), and a data repair pipeline that fixes common JSON corruption (UTF-8 BOM bytes, double/triple `wp_slash` escaping, broken Unicode sequences). The repair pipeline self-heals by rewriting canonical JSON back to the database.

Runtime State Inspection:

Oxygen has no equivalent to `window.divi.data`. There is no programmatic runtime state registry that agents can query during a Visual Builder session. Agents must rely entirely on the JSON postmeta or Respira's extraction tools.

Visual Builder Architecture:

Oxygen uses a structured panel (left) + live preview (right) layout, not Divi's dual-frame approach. While simpler in concept, there is no documented API for agents to inspect builder state programmatically. The Visual Builder is an iframe (`oxygen_iframe=true`), but the internal state management is not exposed.

Weaknesses: - No runtime state inspection equivalent to `window.divi.data` - Respira support is Smart Defaults, not Full Intelligence (fewer pre-built patterns) - No equivalent to 16wells LLM-friendly docs - JSON corruption in postmeta is common (Respira's repair pipeline exists because this is a real problem) - No documented visual QA pipeline for Oxygen sites

—

## 2. Criterion: Buildability — Can Agents CONSTRUCT Pages?

How well can agents programmatically create, modify, and manage page structure? This is the core work loop: design → generate → deploy → verify.

### Divi 5 — Score: 8/10

DiviOps MCP — 85 Free Tools:

The DiviOps MCP server (`@diviops/mcp-server` v1.5.33, MIT license) provides 85 execution tools at zero cost. DiviOps Pro is not needed — all schema discovery can be done via `diviops_schema_get_module(raw=true)`. Key tool categories:

REST API — 40+ Endpoints:

DiviOps exposes a full REST API at `/wp-json/diviops/v1/` covering pages, sections, modules, schema, validation, globals, variables, presets, theme builder, and templates. All operations are REST-callable with WordPress application password auth.

Proven Production Pipeline:

The L8 Water Hygiene deployment validated the pipeline end-to-end: 62 blocks across 6 sections, generated via Python `json.dumps()`, SCP'd to Hetzner, pushed via `wp post update`. 21 of 22 content strings verified. This is not theoretical — it works in production.

DiviFlash — 97 Additional Modules:

DiviFlash v5.2.0 adds 107 modules in the `difl/*` namespace including FAQ, flip-box, carousels, pricing tables, Lottie animations, typing text, tilt cards, and a Contact Form Extender (`difl/cfseven`). While not registered in DiviOps schema tools, their `module.json` files can be read directly from the server filesystem and consumed by agents.

The CREATE vs MODIFY Rule (Critical Limitation):

This is Divi 5's most significant bot-building limitation:

- MODIFY existing VB-created blocks via REST API = WORKS ✅ — VB reads updated block JSON on next open - CREATE new blocks via REST API = INVISIBLE in VB ❌ — Blocks render on frontend but VB Layers panel shows only an empty section. Clients cannot select, move, or edit programmatically-created blocks.

Why: Divi 5 blocks don't register in Divi's internal React state. The VB loads content into its own state management layer, and blocks it didn't create are invisible to that layer.

Practical consequence: For bot-built pages that will never need manual VB editing, this is acceptable. For pages needing ongoing client edits, structure must be created in VB first (manually or via browser automation), then REST API used for bulk attribute changes.

Python Block Generation:

Agents generate block markup using Python `json.dumps()` (never hand-write — deeply nested decoration paths like `headingFont.h1.font.desktop/tablet/phone` cause silent brace-mismatch failures). The `gen-divi-page.py` helper script provides preset functions for all block types.

Weaknesses: - CREATE = VB-invisible is a fundamental architectural limitation - MCP transport double-escapes backslashes on >7 blocks (workaround: SCP + WP-CLI) - Block JSON nesting is deep (headingFont.h1.font.desktop.value.*) - `builderVersion` must be `“5.0.3”` (block spec), not theme version - REST calls must be sequential — parallel calls hang - Module UUIDs change on every VB reload

### Oxygen — Score: 7/10

Direct Postmeta Manipulation:

Oxygen's primary build path for agents is direct postmeta manipulation:

```php $page_id = wp_insert_post([

  'post_title'  => 'Page Title',
  'post_status' => 'publish',
  'post_type'   => 'page'

]);

$json_tree = json_encode([

  ['id' => 1, 'name' => 'ct_section', 'options' => [...], 'children' => [
      ['id' => 2, 'name' => 'ct_headline', 'options' => ['ct_content' => 'Hello']]
  ]]

]);

update_post_meta($page_id, '_ct_builder_json', wp_slash($json_tree)); ```

This is architecturally simpler than Divi's approach — there's no CREATE-vs-MODIFY distinction because the JSON tree is the canonical format. Both creation and modification go through the same path.

Respira MCP — Element Tree Editing:

Respira provides structure-aware element-tree editing for Oxygen. The duplicate-first workflow (edit a copy, approve in WordPress admin) adds safety but adds friction to the bot-building loop. Snapshot protection means every change creates a recoverable backup, which is excellent for safety but adds latency.

Brainstorm MCP — Free, Open Source:

The [brainstorm-wordpress-mcp-server](https://www.npmjs.com/package/brainstorm-wordpress-mcp-server) is a free, open-source alternative that supports Oxygen (parse JSON 4.0+, parse shortcodes legacy, find elements by name, update element options). This is the closest equivalent to DiviOps for Oxygen, but with fewer tools and less Oxygen-specific intelligence.

Development Translation Bridge:

The [Development Translation Bridge](https://github.com/coryhubbell/Development-Translation-Bridge) supports framework-to-framework conversion including Oxygen → Divi 5, Elementor → Oxygen, etc. This is useful for migration scenarios but less relevant for day-to-day bot building.

No CREATE=VB-Invisible Problem:

Because Oxygen's JSON tree IS the canonical format, there is no distinction between “VB-created” and “REST-created” content. Programmatically created pages ARE editable in the Visual Builder. This is a significant architectural advantage over Divi 5.

Element Studio (Oxygen 6):

Oxygen 6 includes Element Studio, a visual IDE for creating custom builder elements using HTML, CSS, and Twig. Agents could theoretically generate custom elements, but the workflow (generate PHP code via Twig, register in Element Studio) is more complex than Divi's block generation.

Limitations via Respira: - Global styles and stylesheets require the builder UI — not MCP-editable - Custom PHP code blocks are preserved but not editable through Respira - Dynamic data connections are preserved but not directly editable - Conditional visibility rules: only simple rules (logged-in, post type, role) write through MCP

Weaknesses: - No free, dedicated MCP server comparable to DiviOps (Respira is paid, Brainstorm is multi-builder generic) - No pre-verified page templates/patterns in MCP tools - JSON corruption in postmeta is a known problem (UTF-8 BOM, wp_slash escaping) - Oxygen 4.x (shortcodes) vs Oxygen 6 (Breakdance-derived JSON) format split - Meta key change: `ct_builder_json` → `_ct_builder_json` (Oxygen 4.8.3+) - Smaller third-party module ecosystem (no DiviFlash equivalent) - Element Studio custom elements require Twig + PHP knowledge

—

## 3. Criterion: Bot Functionality — APIs, MCP, Automation

The full tooling surface: REST APIs, MCP servers, browser automation, SEO integration, image pipelines, and monitoring.

### Divi 5 — Score: 9/10

Free MCP Ecosystem:

DiviOps MCP alone provides everything needed for production bot-building without paying a cent. Respira adds deeper intelligence (boxShadow, filters, transform, sticky, scroll, animation schemas) for a fee, but it's additive, not required.

REST API Surface:

- DiviOps REST: `/wp-json/diviops/v1/` — 40+ endpoints covering all builder operations - WordPress Core REST: `/wp-json/wp/v2/` — pages, media, users, settings - RankMath REST: `/wp-json/rankmath/v1/` — SEO meta, schema, search intent, redirects - Custom REST: `/wp-json/chippy/v1/` — GPS position, routes, preferences (example of extensibility)

SEO Automation (Production-Ready):

The RankMath REST API integration is fully scripted (`rankmath-seo.py`, 497 lines): set focus keywords, SEO titles, meta descriptions, OG tags, structured data schemas (Article/FAQ/Service/LocalBusiness), robots.txt strategies, orphan detection, and full-SEO one-shot setup.

Image Pipeline:

ComfyUI (local Juggernaut XL v9) → Hetzner relay → WP media upload. Fallback to OpenAI DALL-E 3. Script: `comfyui-generate.py`. The upload architecture (base64 encode → SSH stdin pipe → decode on Hetzner → curl to WP REST API) handles the Cloudflare-block-REST-API-from-Z840 problem.

Browser Automation:

- Web MCP (chrome://flags/#web-mcp-for-testing) replaces Playwright for browser-dependent tasks: WordPress admin login, manual VB operations, live page screenshots - Playwright is possible but Claude in Chrome has a security filter blocking `=;?&` characters - Visual QA: `vision-check.py` and `scroll-review.py` scripts using local minicpm-v:8b

Monitoring & Analytics:

- RankWatch API: Keyword rankings, competitive tracking, weekly reports - Matomo: Bot crawl tracking (AI bot visibility report), analytics - Markdown for Agents: Serves lightweight markdown to AI crawlers instead of rendered Divi pages

Weaknesses: - Cloudflare blocks REST API from Z840 → Hetzner relay required - FastPixel conflicts with VB (must deactivate before VB work) - REST calls must be sequential (parallel calls hang) - WP-CLI `wp media import` fails without ImageMagick/GD on Hetzner - No live MCP server reload — requires `/reset` session restart

### Oxygen — Score: 5/10

MCP Ecosystem:

Oxygen has no equivalent to DiviOps — no free, dedicated MCP server built specifically for Oxygen's data model. Respira's Smart Defaults provide tree utility operations but require a paid subscription for production use. Brainstorm MCP is free and open-source but offers generic multi-builder support rather than Oxygen-specific intelligence.

REST API Surface:

Oxygen has no native REST API for builder operations. The only programmatic paths are:

1. Respira MCP — paid, third-party abstraction 2. Brainstorm MCP — free, generic 3. Direct postmeta manipulation — wp_insert_post + update_post_meta 4. Development Translation Bridge — framework conversion, not page building 5. do_oxygen_elements() — PHP function to render JSON on frontend

The absence of a native REST API is the single biggest gap for bot-driven building. Every operation requires either a paid third-party service or custom WordPress plugin development.

SEO Integration:

No documented RankMath integration for Oxygen sites. SEO workflows would need to be built from scratch or rely on Respira's generic WordPress SEO tools.

Browser Automation:

Oxygen's structured panel + live preview layout is arguably simpler to automate than Divi's dual-frame architecture. However, no production-proven bot-driven browser automation pipeline exists for Oxygen in our infrastructure.

Visual QA:

No documented visual QA pipeline for Oxygen-built pages. While the same headless screenshot approach would work, Oxygen's cleaner HTML output would make vision model analysis easier (less DOM noise to parse through).

Weaknesses: - No native REST API for builder operations (critical gap) - No free, dedicated MCP server comparable to DiviOps - Respira's Smart Defaults are less capable than its Divi 5 Full Intelligence - No documented SEO automation scripts for Oxygen sites - No image generation pipeline integration - No monitoring/analytics integration scripts - Oxygen 4.x (shortcodes) vs Oxygen 6 (JSON) creates format fragmentation - Oxygen 6 is new — tools that worked with 4.x may not work with 6.x

—

## 4. Head-to-Head Scoring

### Detailed Score Matrix

### Weighted Category Scores

—

## 5. Recommendation

### Winner: Divi 5 (8.0/10 vs 6.0/10)

For AI bot-driven site building, Divi 5 is the clear choice. The deciding factors:

1. Free MCP Ecosystem: DiviOps MCP provides 85 tools at zero cost. Oxygen's equivalent (Respira) requires a paid subscription, and the free alternative (Brainstorm) is generic multi-builder support without Oxygen-specific intelligence.

2. REST API Gap: Divi 5 has 40+ REST endpoints covering every builder operation. Oxygen has no native REST API — every bot operation requires a third-party MCP server or direct postmeta manipulation.

3. Proven Pipeline: L8 Water Hygiene (62 blocks, 6 sections, production deployment) proves the bot-building workflow works end-to-end. No equivalent production validation exists for Oxygen.

4. SEO + Image + Monitoring Scripts: RankMath automation (497 lines), RankWatch API (497 lines), ComfyUI/DALL-E image generation, Matomo bot tracking — all built, tested, and scripted for Divi 5 sites. Rebuilding this stack for Oxygen would require significant effort.

5. Module Ecosystem: 97 DiviFlash modules (difl/* namespace) extend what agents can build far beyond native Divi. Oxygen has no comparable third-party module library accessible to bots.

### When Oxygen Would Win

Oxygen is architecturally superior in ways that matter for bot building:

- JSON tree format is cleaner and more agent-parseable than Divi's nested block comments - No CREATE=VB-invisible problem — programmatically created pages ARE editable in the VB - Cleaner HTML output — better PageSpeed scores, easier for vision models to analyze - Element Studio — agents could theoretically generate custom elements via Twig

Oxygen would win if: - A free, dedicated Oxygen MCP server equivalent to DiviOps were built (e.g., an “OxyOps” MCP) - Native REST API endpoints were added to Oxygen - The DiviOps CREATE=VB-invisible limitation became a dealbreaker for client-editable pages - Performance (PageSpeed/Core Web Vitals) was the primary bot-building goal

### What Would Close the Gap

If Oxygen invested in bot-building tooling, the architectural advantages (cleaner JSON, VB-visible creates, better performance) could make it the superior choice. What's needed:

—

## 6. Divi 5 Bot-Building Reference

For agents building on Divi 5, these are the key facts:

### Architecture

``` Hermes/Z840 ◄──► DiviOps MCP Server (npx/@diviops/mcp-server)

                    │
          WordPress REST API (/wp-json/diviops/v1/)
                    │
          diviops-agent plugin (v1.5.5, free, MIT)
                    │
          Divi 5 blocks written to post_content
          (VB-editable if created in VB first)

```

### Critical Rules

1. MODIFY existing blocks ✅ | CREATE new blocks = VB-invisible ❌ 2. Use Python `json.dumps()` for block generation — never hand-write JSON 3. `builderVersion` = `“5.0.3”` (block spec), NOT theme version 4. `innerContent` at `content.innerContent.desktop.value` 5. Unicode escapes (`\u003c`) must remain as literal strings 6. MCP double-escapes on >7 blocks — use SCP + WP-CLI 7. REST calls must be sequential — parallel calls hang

### Sites & MCP Servers

### Key Files

``` /home/kaburu/.hermes/skills/infrastructure/divi-5-builder/ ├── SKILL.md # Main reference (649 lines) ├── scripts/gen-divi-page.py # Page generator ├── scripts/rankmath-seo.py # SEO automation ├── scripts/rankwatch.py # RankWatch API ├── scripts/comfyui-generate.py # Image generation └── references/ # 19 reference files ```

—

## 7. Oxygen Bot-Building Reference

### Architecture

``` Agent ◄──► Respira MCP (paid) or Brainstorm MCP (free)

              │
        WordPress REST API (generic - no builder endpoints)
              │
        Postmeta: _ct_builder_json (primary)
                  _ct_builder_shortcodes (fallback, legacy)
              │
        Oxygen renders via do_oxygen_elements() on frontend

```

### Data Format

Oxygen 4.8.3+ stores JSON in `_ct_builder_json` postmeta:

```json [

{
  "id": 1,
  "name": "ct_section",
  "options": {"ct_id": 1, "selector": "section-1-123"},
  "children": [
    {"id": 2, "name": "ct_headline", "options": {"ct_content": "Hello"}},
    {"id": 3, "name": "ct_link_button", "options": {"ct_content": "Click", "url": "/page"}}
  ]
}

] ```

### Common Component Types

### MCP Tool Equivalents

### Known Gotchas

- JSON in `_ct_builder_json` is frequently corrupted (UTF-8 BOM, wp_slash escaping) - Respira's data repair pipeline fixes this automatically on extraction - Oxygen 4.8.3+ changed meta key from `ct_builder_*` to `_ct_builder_*` - Oxygen 6 uses Breakdance-derived Jenga namespace — different format from 4.x - Global styles/colors require the builder UI — not MCP-editable - Dynamic data connections are preserved but not MCP-editable - Custom PHP code blocks are preserved but not MCP-editable

—

## 8. Conclusion

Divi 5 wins for AI bot-driven site building today based on tooling maturity, not architectural superiority. The free DiviOps MCP with 85 tools, 40+ REST endpoints, and production-proven pipeline give agents a surface they can actually use. Oxygen's cleaner JSON architecture and VB-visible programmatic creates are genuine advantages, but they're theoretical until the tooling gap closes.

The CREATE=VB-invisible limitation is Divi 5's biggest weakness. For the specific use case of “build once, never manually edit,” it's fine. For client-editable pages, it requires a hybrid workflow: create structure in VB (manually or via browser automation), then use REST API for bulk attribute changes.

If the bot-building pipeline were starting from scratch today with equal tooling investment: Oxygen's cleaner architecture would be the better foundation. Its JSON tree is more agent-friendly, programmatic creates are VB-visible, and the HTML output is superior for performance. Building a DiviOps-equivalent MCP server for Oxygen is technically feasible — the data model is simpler than Divi's — but would require significant development effort.

For the Kaburu infrastructure: Divi 5 is the right bet. The tooling exists, the pipeline is proven, and the module ecosystem (97 DiviFlash modules) is unmatched. Steve holds licenses for both builders, so Oxygen remains available for projects where its architectural advantages (performance, code cleanliness, VB-visible creates) outweigh the bot-building tooling gap.

—

*Researched and written 2026-07-05. Divi 5 data from production experience across 4 active sites. Oxygen data from public documentation, Respira MCP listings, Brainstorm MCP repository, and community developer resources. Version references: Divi 5.8.1, DiviOps Agent 1.5.5, DiviOps MCP Server 1.5.33, Oxygen 6.1 RC 1, Respira MCP Server 7.2.2.*