What is Respira for WordPress?

Choose your character

You are at the threshold. Pick the role that matches your world, then step into a version of your workflow where change is faster, safer, and easier to trust.

← Back to personas

The Architect

WordPress Plugin + MCP Server + WebMCP Bridge

You evaluate systems by tradeoffs, not slogans.

You need to see interfaces, safety constraints, and operational behavior before trusting the stack.

Your call to adventure: map the full request path from model tool call to controlled production publish.

Featured Scenario: Builder-Aware Price Update

Technical architecture and context interface visual

Before: A simple pricing change risks broad HTML regressions across builder content.

After: AI performs a targeted, structured update and returns a controlled approval path.

Ordinary World (Before)

  • WordPress AI tools often feel opaque.
  • Safety guarantees are vague or UI-only.
  • Extensibility points are hard to audit.

Transformed World (After)

  • Single backend capability surface across MCP and WebMCP.
  • Duplicate-first safety enforced at operation level.
  • Hookable architecture with predictable integration seams.
01

The Skepticism

Claims are high, implementation details are hidden.

02

The Trace

You inspect request flow, safety gate, and extension seams.

03

The Confidence

You adopt based on observable architecture, not hype.

54,885 lines of code
102 REST endpoints
1,214 commits

Architecture Overview

Single backend capability surface with multiple front-door clients is the core architectural pattern.

  • WordPress plugin: PHP core, REST endpoints, approval/duplicate workflow, builder abstraction
  • MCP server: TypeScript tool registry, schema validation, endpoint mapping
  • WebMCP bridge: browser ability discovery/execution mapped to same backend operations

Request Flows

MCP Client -> MCP Server -> /wp-json/respira/v1/* -> Controller -> Duplicate Gate -> Operation -> Response

Browser AI -> /wp-json/webmcp/v1/tools -> /execute/{ability} -> Permission + Nonce -> Same respira/v1 flow

Builder Abstraction

Builder interface standardizes detect/extract/inject/update operations with per-builder implementations.

Module-level precision is strongest where builder structures are predictable and mature.

  • Supported: Divi, Elementor, WPBakery, Oxygen, Bricks, Beaver Builder, Brizy, Visual Composer, Thrive Architect, Breakdance, Gutenberg

Safety Workflow

  1. Auto-duplicate is checked for write calls.
  2. Changes are applied to duplicate by default.
  3. Approval URL is returned for manual review.
  4. Force path requires explicit confirmation checks and is audited.

Security

  • API key auth for MCP path
  • Capability-based permission callbacks
  • Input validation and sanitization by endpoint args
  • Rate limiting and audit logs
  • WebMCP execution checks (nonce/permission/rate constraints)

Performance Notes

  • Key validation and list operations can become hotspots at larger scale
  • Caching and pagination opportunities exist in approval and expensive analysis paths
  • Prepared query patterns and transient/object cache usage improve common cases

Extensibility

  • Filters for exposed tools and limits
  • Hooks before/after operations and approval lifecycle events
  • Builder registration interface for custom integrations

Known Gaps / Roadmap Themes

  • Broader module-level support across more builders
  • Expanded test coverage and schema consistency
  • Further performance optimization for key lookup and audit queries
Read Architecture Docs

Built by One Person

Respira was built by Mihai, a solo founder from Brașov, Romania.

After 22 years building products for others, Mihai finally had the tools to build what he'd always wanted: a bridge between WordPress (43% of the web) and modern AI.

Not because he became a "real developer." He's what he calls a "gringo vibe coder"—building with AI through feel, not formal training.

Which makes sense when you think about it.

Someone using AI to build... is building AI tools for WordPress.

The name comes from Latin: re-spirare—to breathe again.

The philosophy: simple systems that breathe.

Not complex dashboards. Not hustle-culture "10x your output" bullshit. Just: duplicate before you edit. Approve when ready. Don't break things.

This isn't backed by venture capital. No team of engineers. One person, building in public, driven by a simple belief: AI should make WordPress better—not replace human craft, but amplify it.

Better accessibility. Cleaner code. Faster workflows.

If Respira saves you time or fixes something that matters—that's the whole point.

— Mihai
Brașov, Romania
Newsletter • LinkedIn

Subscribe for product updates and builder notes.

1,214commits
54,885lines of code
3 monthsto v3.0
1 personbuilding