Deep Intelligence April 13, 2026

Respira × Oxygen Builder

Oxygen Deep Intelligence

The deepest Oxygen Builder MCP integration available. 49 components cataloged. 140+ CSS properties in the schema. Fuzzy matching catches AI typos. Data repair fixes corrupted JSON. Dual detection supports both Oxygen Classic (4.x) and Oxygen 6. Ten ready-to-use layout patterns.

Plugin 6.2.0 MCP Server 6.2.0 Oxygen 4 + 6
Download 6.2.0 Read the full story
Oxygen components
49
Schema properties
140+
Layout patterns
10
New capability
Fuzzy matching

Problem 1

Oxygen stores JSON with double-escaping, BOM bytes, and broken Unicode — AI tools choke on extraction

Shipped fix

Auto-repair pipeline: BOM strip, 3-pass unslash, Unicode fix, self-healing canonical rewrite

Problem 2

AI sends "backgroud-color" and nothing happens — no error, no feedback, silent failure

Shipped fix

Fuzzy matching via Levenshtein distance suggests "background-color" with actionable warnings

Problem 3

No way to tell if a site runs Oxygen Classic or Oxygen 6 — completely different architectures

Shipped fix

Dual detection: CT_VERSION for Classic, __JENGA_VERSION__ for Oxygen 6, automatic adapter selection

Builder coverage

Oxygen joins Bricks, Elementor, Divi, Gutenberg, Beaver Builder, Avada, WPBakery, Themify, Brizy, GeneratePress, and Flatsome as the 12th builder with Deep Intelligence — the full treatment of component registry, schema, validator, settings validator, and pattern library.

The Oxygen logo and brand identity are the property of Soflyy. Their use here is purely illustrative of product compatibility. Respira is not affiliated with, endorsed by, or an officially recognised solution of Oxygen Builder. All trademarks belong to their respective owners.

Deep Intelligence for Oxygen

Oxygen Builder deserved more than basic extract and inject. Now it gets full intelligence.

Oxygen Builder is one of the most powerful WordPress page builders ever made. Its JSON-based data model, shortcode rendering system, and granular CSS controls give developers complete control. But that same power made it the thinnest intelligence layer in Respira — a basic adapter that could extract and inject content, but lacked data repair, fuzzy matching, responsive awareness, nesting rules, and a complete component catalog.

6.2changes everything. The Oxygen intelligence layer now includes 49 cataloged components (up from 26), 140+ schema properties (up from ~90), a settings validator with Levenshtein fuzzy matching, a data repair pipeline that fixes corrupted JSON on the fly, nesting validation rules, parent consistency checking, and 10 full-structure layout patterns. It also detects Oxygen 6 — the Breakdance-based rewrite — alongside Classic installations.

The headline feature is the fuzzy matching settings validator. When an AI agent sends backgroud-color instead of background-color, the validator catches it and returns a “did you mean?” suggestion. When it sends display: flexbox instead of display: flex, enum validation catches it. When it forgets to include ct_content on a headline component, required property warnings flag it. These are the kinds of silent failures that make AI page editing unreliable — and now they are all surfaced with actionable feedback.

What changed

AI extracts Oxygen content with BOM bytes and double-escaped slashes — the repair pipeline fixes it silently and rewrites clean JSON.

AI sends backgroud-color: #333 to an Oxygen heading — gets a warning: “Unknown property. Did you mean background-color?”

AI creates a slider with div_block children instead of ct_slide — nesting validation warns that ct_slider expects ct_slide children.

AI uses type: "heading" instead of name: "ct_headline" — auto-mapping resolves it with a helpful hint about the native field name.

Every scenario above works automatically in 6.1. Oxygen intelligence activates when Oxygen is detected.

Problem 1 to Fix 1

Oxygen JSON was corrupted before AI even saw it.

Oxygen stores component data as JSON in ct_builder_json postmeta. In practice, this JSON is frequently corrupted: UTF-8 BOM bytes at the start that break json_decode, double or triple wp_slash escaping from WordPress serialization, and bare Unicode sequences missing their backslash prefix. AI tools would extract this data, try to parse it, and fail silently.

  • What the user experienced

    Content extraction returned empty results or malformed JSON. AI could not read or modify Oxygen pages reliably.

  • Why it happened

    WordPress wp_slash escaping compounds on each save. Migration tools add BOM bytes. Database transfers corrupt Unicode. The raw JSON in postmeta is rarely clean.

  • What shipped

    A multi-stage repair pipeline: BOM stripping, up to 3 wp_unslash passes, Unicode escape repair. On successful decode, the pipeline self-heals by rewriting canonical JSON back to the database.

  • Benefit

    Content extraction works on every Oxygen installation, regardless of how many times the database has been migrated, exported, or re-imported. Corrupted JSON is fixed permanently on first read.

Extraction behavior comparison

Extracting content from an Oxygen page with corrupted JSON

New in 6.1
Before (no repair) Result
extract_builder_content(page_id)

JSON has BOM + double-escaped slashes

Read
json_decode() fails

Returns null — extraction reports empty page

Failed

Page appears empty to AI. No error message, no guidance on what went wrong.

After (repair pipeline) Result
extract_builder_content(page_id)

BOM stripped, 2x unslash, Unicode fixed

Repaired
Self-heal: rewrite clean JSON

Canonical JSON saved back — next read is instant

Healed

Full component tree extracted. Database permanently fixed. No user intervention required.

The repair pipeline runs automatically on every extraction. Once healed, the clean JSON is persisted to ct_builder_json postmeta, so subsequent reads are instant.

Problem 2 to Fix 2

AI typos in property names silently did nothing.

When an AI agent sends backgroud-color instead of background-color, or display: flexbox instead of display: flex, Oxygen accepts the invalid data without complaint. The property is stored but has no effect. The AI thinks the edit succeeded. The user sees nothing changed.

  • What the user experienced

    AI confidently reported “Done! I updated the background color.” But the page looked exactly the same. No error, no visible change, no explanation.

  • Why it happened

    No validation layer existed between AI output and Oxygen data storage. Any property name was accepted, even misspelled or nonsensical ones.

  • What shipped

    Levenshtein-based fuzzy matching on all 140+ known properties. Enum validation for values. Required property checks per component. Responsive suffix parsing for breakpoint-specific styles.

  • Benefit

    AI gets immediate, actionable feedback. “Unknown property backgroud-color. Did you mean background-color?” — instead of silent failure that wastes tokens and user trust.

Validation behavior comparison

AI sets a misspelled CSS property on an Oxygen heading

New in 6.1
Before (no validation) Result
update_element({backgroud-color: "#333"})

Invalid property stored in options

Stored
Page renders unchanged

Property has no effect — AI reports success

Silent fail

AI wastes tokens retrying. User loses trust. The typo is never surfaced.

After (fuzzy matching) Result
update_element({backgroud-color: "#333"})

Validator: “Did you mean background-color?”

Warning
AI self-corrects and retries

Sends background-color: "#333" — applies correctly

Fixed

One warning, one retry, correct result. No wasted tokens, no confused users.

Fuzzy matching uses Levenshtein distance with a threshold of max(3, 40% of input length). This catches common typos while avoiding false positives on genuinely different property names.

Problem 3 to Fix 3

No way to tell Classic Oxygen from Oxygen 6 — two completely different builders sharing one name.

Oxygen 6 is a ground-up rewrite based on the Breakdance engine. It uses the Jenga namespace, class-based styling, Element Studio IDE, and a completely different data storage format. An AI tool configured for Classic Oxygen would silently produce invalid output on an Oxygen 6 site.

  • What the user experienced

    On an Oxygen 6 site, content extraction returned unexpected structures. Injected content did not render. No error indicated the version mismatch.

  • Why it happened

    Both versions call themselves “Oxygen” but have different PHP constants, class names, data formats, and rendering engines. No detection existed to distinguish them.

  • What shipped

    Dual detection: CT_VERSION / CT_Component / oxygen_vsb_signing_script for Classic; __JENGA_VERSION__ / Jenga\Base\Plugin / JENGA_PLUGIN_DIR for Oxygen 6. The is_oxygen_6() helper enables version-branching throughout.

  • Benefit

    Respira correctly identifies which Oxygen version is installed and adapts automatically. get_builder_info reports the exact version. Future Oxygen 6 intelligence can branch cleanly.

Detection behavior comparison

AI queries builder info on a site running Oxygen 6

New in 6.1
Before (single detection) Result
get_builder_info()

Checks CT_VERSION only — not defined in Oxygen 6

Miss
Builder reported as “unknown”

Falls back to generic WordPress editor — no intelligence

No support

Oxygen 6 site gets zero builder intelligence. AI treats it like a plain WordPress site.

After (dual detection) Result
get_builder_info()

Checks __JENGA_VERSION__ — detected as Oxygen 6

Detected
is_oxygen_6() returns true

Version-specific behavior enabled throughout adapter

Adapted

Correct version detected. Intelligence layer knows which Oxygen it is working with.

Detection checks multiple signals per version: PHP constants, class existence, and plugin directory paths. If any signal matches, the version is confirmed.

Closing

The deepest Oxygen Builder MCP integration available. For Oxygen 4 and Oxygen 6.

49 components. 140+ schema properties. Fuzzy matching. Data repair. Nesting validation. 10 layout patterns. Dual-version detection. No other AI tool — no other WordPress MCP server — offers this level of Oxygen-specific intelligence.

And unlike single-builder tools, these capabilities sit alongside Respira’s 131 core tools, 21 WooCommerce tools, and dedicated intelligence for 11 other page builders. The same AI assistant that deep-edits your Oxygen site can also manage WooCommerce, run accessibility audits, analyze SEO, handle media operations, and work with any other supported builder. One tool, one MCP connection, full WordPress control.

Whether you are running Oxygen Classic 4.x with its JSON-in-postmeta architecture, or exploring Oxygen 6 with its Breakdance-based engine, Respira detects what you have and adapts. The intelligence layer knows your builder. The AI knows your components. The validator catches mistakes before they reach your pages.

What shipped in 6.1

Deep intelligence across seven files: adapter, registry, schema, validator, settings validator, patterns, and loader.

The fuzzy matching settings validator and data repair pipeline are the headline features, but the component registry expansion and nesting validation matter for daily use. When AI knows that ct_new_columns must contain ct_column children, and that ct_headline requires a ct_content property, errors are caught before they reach the page.

Feature 1

Fuzzy matching settings validator

AI agents make typos. Before this release, a misspelled property like "backgroud-color" would silently do nothing. Now the settings validator uses Levenshtein distance to find the closest match and returns a "did you mean background-color?" warning. It also validates enum values (display, position, flex-direction), checks required properties per component type, and parses responsive suffixes automatically.

  • Levenshtein distance matching with configurable threshold (max 3 or 40% of input length)
  • Enum validation for 20+ properties with allowed value lists
  • Required property warnings per component type (ct_headline needs ct_content, etc.)

Feature 2

Data repair pipeline

Oxygen stores component data as JSON in ct_builder_json postmeta. In practice, this JSON is often corrupted: UTF-8 BOM bytes at the start, double or triple wp_slash escaping from serialization, broken Unicode sequences. The repair pipeline fixes all of these on extraction and self-heals by rewriting canonical JSON back to the database.

  • UTF-8 BOM stripping prevents json_decode failure on otherwise valid JSON
  • Up to 3 wp_unslash passes fix double-escaped and triple-escaped strings
  • Unicode escape repair converts bare uXXXX to proper \uXXXX sequences

Feature 3

Oxygen 6 dual-version detection

Oxygen 6 is a ground-up rewrite based on the Breakdance engine. It uses the Jenga namespace, class-based styling, and a completely different data format. Respira now detects both versions: CT_VERSION and CT_Component for Classic, __JENGA_VERSION__ and Jenga\Base\Plugin for Oxygen 6. The is_oxygen_6() helper enables version-specific behavior throughout the adapter.

  • Classic detection: CT_VERSION constant, CT_Component class, oxygen_vsb_signing_script
  • Oxygen 6 detection: __JENGA_VERSION__, Jenga\Base\Plugin, JENGA_PLUGIN_DIR
  • is_oxygen_6() helper for version-branching throughout the intelligence layer

  • 49-component registry

    Every Oxygen Classic component is now cataloged: structure elements (section, div_block, columns), header zones, interactive components (slider, accordion, tabs), WordPress dynamic elements (post excerpt, date, author, terms, comments, breadcrumbs), and advanced elements (superbox, flip box, table of contents, mega menu). Each component includes its category, description, and supported properties.

  • Nesting validation

    Oxygen has strict parent-child rules: ct_new_columns must contain ct_column, ct_slider must contain ct_slide, ct_header_row must contain header zones. The validator now checks these relationships and returns warnings (not errors) when nesting rules are violated. Parent consistency checking verifies that every ct_parent reference points to an existing component ID.

  • 10 layout patterns

    Full-structure JSON patterns for common layouts: three-column features with icons, call-to-action sections, testimonials, pricing tables, image-with-text columns, FAQ accordions, team grids, footers, and header bars. Each pattern uses respira_oxygen_create_component() with proper ct_id, ct_parent, selector, and option structures.

  • 140+ schema properties

    The property schema now covers flexbox and grid (display, flex-direction, justify-content, align-items, gap, grid-template-columns), backgrounds (image, size, position, repeat), borders (width, style, color, radius), shadows and effects (box-shadow, text-shadow, opacity, filter), transforms, transitions, position properties, and responsive breakpoint suffixes.

Try it

Example prompts for Oxygen Builder sites

These are real prompts you can paste into Claude, Cursor, or any MCP-connected AI agent. Each one leverages Oxygen Deep Intelligence under the hood.

Build a pricing section

build_page + Oxygen patterns

Prompt

Add a three-column pricing table to the pricing page. Use Oxygen columns with a pricing box in each column. Basic at $9, Pro at $29, Enterprise at $99.

What happens

  1. AI uses the pricing-table pattern as a starting template
  2. Creates ct_new_columns with 3 ct_column children, each containing oxy_pricing_box
  3. Nesting validation confirms the structure is valid
  4. Settings validator checks all properties before injection

Find and update content

find_element + update_element

Prompt

Find the hero heading on the homepage and change it to “Build faster with AI”. Also update the subheading font size to 18px.

What happens

  1. find_element locates the ct_headline in the hero section
  2. update_element changes ct_content and font-size in options
  3. Validator confirms font-size is a known property with valid value
  4. Cache cleared via oxygen_vsb_cache_page_update()

Create a full page layout

build_page + multiple patterns

Prompt

Build a complete About page for my agency. Include a hero section, team grid with 4 members, a testimonial slider, and a call-to-action section at the bottom.

What happens

  1. AI combines hero, team-grid, testimonial, and call-to-action patterns
  2. Each pattern uses proper Oxygen components with ct_id and ct_parent references
  3. build_page creates the page with full Oxygen JSON structure
  4. Page template meta set to ct_template so Oxygen renders it

Responsive styling

update_element + responsive suffixes

Prompt

Make the hero heading 48px on desktop, 36px on tablet, and 28px on mobile. Center-align it on all breakpoints.

What happens

  1. AI sets font-size: 48px (desktop default)
  2. Sets font-size_tablet: 36px and font-size_phone_portrait: 28px
  3. Validator recognizes _tablet and _phone_portrait as valid responsive suffixes
  4. All breakpoint values stored in the component options correctly

Validate before injecting

validate + inject_builder_content

Prompt

I have a JSON structure for a new FAQ section. Validate it against Oxygen's component rules before injecting it into the page.

What happens

  1. Validator checks all component names against the 49-component registry
  2. Nesting rules verify parent-child relationships are valid
  3. Settings validator checks every property name and value
  4. Any issues returned as warnings with suggestions before injection proceeds

Builder diagnostics

get_builder_info

Prompt

What page builder is this site using? Show me its capabilities, the version, and what intelligence features are available.

What happens

  1. get_builder_info detects Oxygen Classic or Oxygen 6
  2. Reports version, intelligence level, available components, and schema properties
  3. Shows template CPT support, responsive breakpoints, and class system info
  4. AI knows exactly what it can do before starting any edits

Technical details

What shipped

  • Component registry expanded to 49 components — structure, header, interactive, WordPress dynamic, and advanced categories fully cataloged
  • Schema properties expanded to 140+ — flexbox, grid, background, border, shadow, transform, position, overflow, and responsive suffixes
  • Settings validator with Levenshtein fuzzy matching — typos in property names get "did you mean?" suggestions instead of silent failures
  • Responsive breakpoint awareness — _tablet, _phone_landscape, _phone_portrait suffixes parsed and validated automatically
  • Nesting guidance rules — ct_new_columns expects ct_column children, ct_slider expects ct_slide, warnings prevent invalid structures
  • Data repair pipeline — UTF-8 BOM stripping, triple wp_unslash for double-escaped JSON, Unicode escape repair, self-healing canonical rewrite
  • Oxygen 6 detection — __JENGA_VERSION__, Jenga\Base\Plugin class, and JENGA_PLUGIN_DIR checks alongside Classic CT_VERSION detection
  • Parent consistency checking — validates ct_parent references point to existing component IDs in the tree
  • Enum validation for 20+ properties — tag, display, position, flex-direction, justify-content, align-items, object-fit, and more
  • 10 full-structure layout patterns — three-column-features, call-to-action, testimonial, pricing-table, image-with-text, FAQ accordion, team grid, footer, header bar
  • Cache clearing improvements — oxygen_vsb_cache_page_update(), ct_css_cache transient cleanup, oxygen_after_save_components_meta action
  • Auto-map format fields — AI can use simplified "type" field, automatically mapped to native Oxygen "name" with helpful hints
  • Page template meta on inject — sets _wp_page_template to ct_template so Oxygen renders instead of theme fallback
  • Required property warnings — ct_headline needs ct_content, ct_image needs src, ct_link_button needs ct_content + url

Breaking changes

None in this release

  • No breaking changes. Oxygen intelligence activates automatically when Oxygen is detected.
  • Data repair is transparent — corrupted JSON is fixed on extraction without user action.
  • All existing Respira settings, snapshots, and configurations are preserved.

Migration guide

What to do next

  • Update the plugin to 6.2.0 from your WordPress dashboard.
  • Update MCP server: npm i -g @respira/wordpress-mcp-server@6.2.0
  • Oxygen intelligence activates automatically when Oxygen is detected — no configuration needed.
  • Works with Oxygen Classic (3.x/4.x) and detects Oxygen 6 installations.
  • All existing Respira settings, snapshots, and configurations are preserved.

Version compatibility

Oxygen Classic 4.x and Oxygen 6 — two builders, one intelligence layer.

Oxygen Classic (3.x / 4.x) stores components as JSON in ct_builder_json postmeta with a shortcode fallback in ct_builder_shortcodes. It uses the ct_template custom post type for reusable templates. The full intelligence layer — all 49 components, 140+ properties, settings validator, and patterns — targets this architecture.

Oxygen 6 is a Breakdance-based rewrite with the Jenga namespace, class-based styling, Element Studio IDE, and a different data storage model. Respira 6.2 detects Oxygen 6 installations and reports the correct version. Full Oxygen 6 intelligence support will expand as the platform matures.

How to upgrade

Coordinated release — update both plugin and MCP server.

Plugin

WordPress Admin -> Plugins -> Update Respira for WordPress to 6.2.0

MCP Server

# Update to 6.2.0 for Oxygen Deep Intelligence
npm i -g @respira/wordpress-mcp-server@6.2.0
# Or use npx (always runs latest):
npx -y @respira/wordpress-mcp-server

Verify Oxygen Deep Intelligence

  1. Update to 6.2.0 from your WordPress dashboard.
  2. Ask your AI assistant to run get_builder_info and confirm Oxygen shows “Full Intelligence” with 49 components.
  3. Test fuzzy matching: intentionally misspell a property and check for “did you mean?” suggestions.
  4. Test data repair: extract content from an Oxygen page — corrupted JSON is fixed automatically.

Previous release

Before 6.2went deep on Oxygen, 6.0 brought real commerce to twelve builders.

Twelve builders. Real commerce. One layer. Flatsome UX Builder as Builder #12, 15 new WooCommerce Commerce tools, bundled entitlement for Studio and Founder.

Read the 6.0 Storefront story

Join the Community

Connect with other Respira users. Get help, share prompts, and see what others are building.

Respira for WordPress GitHub Community

Discussions, Wiki, Issues. Searchable. Permanent. Best for troubleshooting, prompt recipes, and feature requests.

Open Community Hub →

Respira Discord

Real-time chat. Quick questions. Voice debugging. Hang out with other builders.

Join Discord →