The Embeddability Revolution

Forget everything you know about iframes.

They’re not for embedding videos anymore. They’re for embedding computers. Hundreds of them. All at once.

Why Embeddability Is The Future

The future requires universal communication between three actors:

Humans - Working from any device with a browser (phones, tablets, watches, smart glasses, laptops, TVs)
AI Agents - Executing autonomously, orchestrating systems, making decisions
IoT Devices - Sensors, cameras, wearables feeding data and triggering actions

Right now, they can’t talk to each other. Your phone can’t easily control your datacenter. Your AI can’t access your desktop. Your smart watch can’t trigger deployments.

Embeddability changes this. When everything has a URL, any device can access any capability. The phone in your pocket becomes a window into infinite computers.

The Browser Won

Not as a content platform. As the universal computing interface.

Every device has a browser. Every browser speaks HTTP. Every browser is sandboxed, secure, multiplayer by default.

When computers are embeddable via URLs, the browser becomes your operating system.

Your phone isn’t limited anymore—it’s a window into infinite computers:

Smart Watch → [iframe] → Full Linux Desktop
Phone → [iframe] → VS Code + Terminal + Database
Smart Glasses → [iframe] → Your Entire Infrastructure

Device limitations disappear. Capability becomes universal.

AI Needs Embeddable Infrastructure

LLMs can’t execute without real infrastructure. The AI era requires:

Execution environments - Real computers to run on
Observability - AI must see what it’s controlling (terminal iframes, display iframes)
Isolation - Each agent in its own container
Coordination - Multiple agents working together via HTTP

Embeddability transforms AI from advisors into executors.

Proof: Hoody OS — Built in 5 Days

We built Hoody OS: a complete multiplayer web-based operating system with floating windows, AI agents, terminals, code editors, file browsers, and display viewers.

Under 5 days. Production-ready. We run Hoody itself from this OS.

How? Pure embeddability:

Every window = iframe to a container service
Every tool = embedded via URL
Zero custom rendering — web standards only

Screenshot Needed Hoody OS Workspaces — floating windows showing terminal, code editor, AI chat, and display viewer arranged in a custom layout

Hoody OS: A web-based operating system built on pure embeddability

Hoody OS includes three applications:

Hoody Home — Dashboard, project launcher, quick access
Hoody Console — Server management, container administration, monitoring
Hoody Workspaces — Floating-window desktop with drag-and-drop arrangement

The inception: Hoody OS itself runs on a Hoody container. The OS that manages your containers IS a container. It’s embeddable, shareable, and multiplayer. You can embed the OS inside another OS. And because every process on your server is an HTTPS URL — with HTTP/2 and HTTP/3, automatic certificates, zero configuration — you can embed literally any program you run. A Jupyter notebook. A game server dashboard. A custom admin panel. An AI agent’s workspace. If it runs, it has a URL, and that URL works everywhere.

Want to build your own OS? Because everything — containers, files, terminals, displays — is HTTP, AI can orchestrate your entire infrastructure conversationally. That’s not a demo. That’s how we built Hoody OS itself.

`ssh hoody.com` — The Lightest Client Possible

And then we went further. We built a full terminal-based browser that renders the entire Hoody OS as a TUI.

ssh hoody.com

That’s it. Full operating system, in your terminal. Same floating windows, same AI chat, same file browser — rendered in characters. Access from:

A laptop with no browser
A Raspberry Pi over SSH
A server in a datacenter
Your phone’s terminal app
An ESP32 (yes, really — if it can hold an SSH connection, it can run Hoody OS)

Screenshot Needed ssh hoody.com — Hoody OS rendered as a TUI, showing floating windows with terminal, AI chat, and file browser in pure text characters

ssh hoody.com — Your entire OS, from the lightest possible client

No username. No password. It shows a login screen just like any browser would. The lightest possible client for the most powerful possible computing environment.

That’s the power of universal embeddability.

You Have Infinite Computers. They’re All `<iframe>`able.

<iframe src="https://dev-computer-1.hoody.icu" />
<iframe src="https://staging-env-7.hoody.icu" />
<iframe src="https://prod-cluster-42.hoody.icu" />
<iframe src="https://ai-agent-99.hoody.icu" />
<iframe src="https://customer-demo-231.hoody.icu" />

Not mockups. Not remote desktop. Actual computers. Running. Live. In your browser.

Spawn 1000 containers. Embed them all in one page. Your dashboard IS your infrastructure.

Infinite Scale, Infinite Possibilities

One person. 100 projects. 500 containers. One screen.

Each project gets its own set of containers. Each container is an iframe. Your workspace shows them all:

Project Alpha: 5 iframes (frontend, backend, db, monitoring, docs)
Project Beta: 8 iframes (microservices, each in its own container)
Project Gamma: 12 iframes (full Kubernetes simulation, local)
AI Experiments: 47 iframes (each AI agent gets its own playground)

Switching projects? Just change which iframes are visible. Everything keeps running.

HTTP Control, Automatic Reflection

Forget postMessage. Forget parent-child relationships.

Your iframes are displaying computers. Those computers ARE HTTP. When you change the computer via HTTP, the iframe automatically reflects it.

No special iframe manipulation needed. Just regular HTTP requests:

// Execute command in container displayed in iframe
const box = await hoody.withContainer(container);
const result = await box.terminal.execution.execute({
  command: 'npm run build'
});

// The iframe showing the terminal automatically updates
// You didn't touch the iframe. You changed the computer.
// The iframe just shows what the computer is doing.

Try It Live

Type a command below and watch it execute in the live terminal iframe. You’re making HTTP requests. The iframe reflects them automatically.

The iframe below shows a live terminal. Your HTTP request changes the computer. The iframe reflects it.

The breakthrough: Because containers are HTTP-native, any change via HTTP instantly appears in any iframe displaying that container.

Deploy code via HTTP? The display iframe shows the new version
Execute terminal command via HTTP? The terminal iframe shows the output
Update a file via HTTP? The file browser iframe reflects the change
Start a service via HTTP? The monitoring iframe shows it running

Control from anywhere:

Phone makes HTTP request → iframe on TV updates
AI agent makes HTTP request → iframe on laptop updates
Smart watch makes HTTP request → iframe on tablet updates
Script makes HTTP request → all iframes everywhere update

No parent. No postMessage. No special iframe APIs. Just HTTP to the computer. The iframe is just a window.

Your Phone Is Now 1000 Computers

Open your phone browser. Type a URL. You’re now looking at computer #473 of your fleet.

Swipe left: Computer #474. Swipe right: Computer #472. Pinch: See all 1000 as thumbnails.

Each one is a full computer. Each one is an iframe. Each one is already running.

The future is nomadic. Work from a café in Tokyo. Continue from a beach in Bali. Pick up mid-conversation on a train in Switzerland.

Your AI agents keep working while you travel. They don’t pause because you changed locations. They don’t lose context because you switched devices.

Zero friction. Your phone at the airport is the same environment as your laptop at home. Same agents. Same conversations. Same infrastructure. Just different windows into the same infinite compute.

You’re not syncing. You’re not reconnecting. You’re not resuming. You’re just there. Because everything is already online, always accessible, from anywhere.

Your phone didn’t get more powerful. It became a window into infinite compute that travels with you.

The End of Local vs Remote

There’s no difference between:

Iframe on your laptop
Iframe on your phone
Iframe on your TV
Iframe in VR headset

They’re all just windows into the same infinite compute fabric. The computer isn’t “here” or “there”—it’s everywhere, accessible via URL.

This Changes Everything

No more installation. Embed the URL.
No more deployment. It’s already live.
No more integration. Everything speaks HTTP.
No more limitations. Spawn infinite computers.

Your infrastructure isn’t managed. It’s composed. With iframes.

The future isn’t cloud computing.
It’s infinite computers, everywhere, embedded in everything.
Welcome to the embeddability revolution.

Next: Security Model →