CloudSwarm: Agent-Native Cloud Infrastructure CAD

Humans and external LLMs co-design AWS/Azure/GCP topologies in real-time. Powered by WebMCP, CloudSwarm compiles production Terraform and executes live SecOps/FinOps audits with zero race conditions.

Comment

💡 Inspiration

Modern cloud architecture is trapped between two disconnected silos. On one side, solutions architects sketch static boxes on visual whiteboards (like Miro or Lucidchart) that are non-executable, drift from reality within days, lack cost awareness, and cannot be programmatically audited. On the other side, DevOps engineers spend weeks authoring thousands of lines of Terraform in text editors, reviewing complex infrastructure pull requests without spatial context—leading to silent security misconfigurations and budget blowouts.

When the Web Model Context Protocol (WebMCP) was introduced, the missing link became obvious to me: What if the web browser itself became an agent-native cloud workstation where a human engineer and external LLMs co-architect multi-cloud systems in real time?

Instead of brittle DOM-scraping or slow sequential click-bots, WebMCP enables external models to discover typed tools, inspect live spatial canvas state, and execute atomic architectural mutations right alongside human engineers.

🚀 What it does

CloudSwarm is an enterprise multi-cloud architecture CAD workstation built entirely around the WebMCP standard.

  • Simultaneous Human + AI Co-Design: Human architects drag primitives from a 108-item multi-cloud catalog (AWS, Azure, GCP) and wire dependencies with the mouse. Simultaneously, external LLMs (via ChatGPT Desktop or Claude) can inspect state, provision GPU clusters, attach WAF shields, and route fabrics over WebMCP JSON-RPC.
  • 4-Agent Concurrent Swarm: I natively route multi-agent workflows across specialized roles: Atlas (Compute/Infra), Breach (Security/WAF), Forge (Storage/Data), and Cost (FinOps).
  • Organic Hardware-Accelerated Cursors: AI cursors glide across the canvas displaying concise task badges (e.g., Linking 800G Fabric) letting humans watch the AI's physical workflow in real-time.
  • Bidirectional Terraform HCL2 Sync: Canvas topologies continuously compile into production-ready HashiCorp Configuration Language. Modifications to the live code editor automatically update the visual topology in real time.
  • FinOps & Zero-Trust Verification: Live multi-cloud rate cards compute hourly and monthly spend, while a continuous CIS Benchmark 1.5 engine audits security posture (e.g., 100/100 A+) with automated remediation.
  • Time-Travel Decision DAG: Every architectural change is an immutable commit in a Directed Acyclic Graph. You can rewind history, fork experimental branches, or view visual A/B diffs.

⚙️ How I built it

  • WebMCP Protocol Engine: I implemented 35 registered WebMCP tools over both window.modelContext and a high-performance local HTTP/SSE bridge (:3001/mcp) supporting JSON-RPC 2.0.
  • 64-Stripe Entity Lock Manager: To prevent race conditions and "last-write-wins" corruption when human architects and multiple external LLMs modify adjacent resources simultaneously, I built a highly-concurrent lock manager.
  • Optimistic State Engine: Mutations are evaluated as atomic RFC 6902 JSON-Patch transactions. Failed constraints or security violations roll back in microseconds without interrupting the human workflow.
  • Frontend Stack: Built with React 19, TypeScript Strict Mode, and Tailwind CSS.

⚡ Challenges I ran into

  • Single-Threaded State Contention: Coordinating simultaneous user mouse interactions and high-throughput external LLM tool batches without freezing the UI. I solved this with my 64-stripe fine-grained entity locking.
  • Cursor Lifecycle & Perception: Preventing AI cursors from flashing or unmounting prematurely. I engineered a persistent lifecycle where cursors glide smoothly (cubic-bezier CSS transitions) and display readable task badges before gracefully fading out to idle states.
  • Bidirectional AST Synchronization: Compiling unstructured graph topologies into clean, idempotent Terraform HCL2, while parsing raw text edits back into deterministic visual graph nodes.

🏆 Accomplishments that I'm proud of

  • True Multi-Agent Concurrency: Up to 4 external ChatGPT Desktop sessions can manipulate the exact same canvas simultaneously without deadlock or state corruption.
  • Zero Frontend API Keys: A fully sovereign architecture. The workstation holds zero API keys; external LLMs bring their own intelligence over the open protocol.
  • Massive Enterprise Catalog: 108 accurate, multi-cloud CAD primitives providing complete coverage across AWS, Azure, and GCP.
  • Production-Grade Reliability: Backed by 38 test suites and 510/510 passing unit tests (100% green) covering adversarial stress, CAS rollbacks, and multi-cloud compiler accuracy.

🧠 What I learned

WebMCP transforms autonomous agents from simple conversational assistants into active, spatial teammates. When AI models can observe live interface state and execute fine-grained tools over an open protocol, the boundary between human design and autonomous synthesis disappears. Giving an LLM a physical cursor in a CAD environment fundamentally changes how humans trust and verify AI actions.

🔮 What's next for CloudSwarm

  • Direct Cloud Deployment: Adding 1-click terraform apply executions via ephemeral runner containers to actually spin up the drawn infrastructure.
  • Live Reverse Ingestion: Importing existing AWS/Azure environments via terraform plan or CloudFormation into interactive, editable canvas DAGs.
  • Global Multi-Tenant WebSockets: Expanding from local WebMCP bridges to distributed cloud rooms so global engineering teams and AI swarms can collaborate in the same browser session.

Built With

Share this project:

Updates

Submission history