# Understanding Hoody

**Page:** vision/obsolescence

[Download Raw Markdown](./vision/obsolescence.md)

---

# Understanding Hoody

**We're not building better computers: we're redefining what computing means.**

Your work is trapped on specific devices. AI can't actually use your computer. You pay per isolated server that sits idle. You can't truly collaborate in real-time. You can't access your real environment from anywhere. You want to go AI-first but you feel it's too shaky.

**Hoody changes everything: Spawn infinite isolated computers from one server. Every program, every file, every process is a URL. Where regular users, developers, enterprises, and AI agents all work in the same frictionless environment.**

This isn't an evolution. It's a replacement.

## Why We're Not Ready for What's Coming

Computers weren't designed to be shared, embedded, or operated by non-humans. Three forces demand this changes:

### AI must execute and observe

AI needs autonomy over the entire infrastructure—spawning containers, configuring networks, managing databases, deploying code, deploying other AI agents, testing interfaces. All through HTTP endpoints. But execution isn't enough. AI must watch every action to learn your patterns and anticipate needs. When everything is HTTP, your computer becomes AI's training data automatically.

### Teams and agents need entirely new ways to work

Not screen sharing. Not taking turns. Humans, AI agents, and automation working simultaneously in the same terminals, editors, processes. Real-time shared state, like Google Docs for entire computers.

### Your computing must exist everywhere, instantly

Phone, laptop, TV, watch—instant access to your actual computing state. Not synced copies. The real environment, already online, accessible from anywhere.

---

**HTTP solved this for websites.** Any device, any page, one protocol. Instant. Collaborative. *Why not for computers themselves?*


## Hoody: Everything Is a URL

With Hoody, you don't have one computer. You have infinite isolated computers, each with its own URL, accessible from anywhere.

Why can't you:
- **`<iframe>` your entire desktop** into a web page?
- **`curl` your filesystem** from anywhere?
- **Share your terminal with a URL** like you share a Google Doc?
- **Ask Agent** to interact with anything you are doing? 

The answer is simple: We're using 1970s architecture with 2020s connectivity.

**Hoody makes everything "web-native".** Your entire computer becomes a collection of HTTP endpoints, as embeddable and composable as the web itself. *We've abstracted everything.*

### These Are Your Computers

<div style="
  background: #f8f8f8;
  border: 1px solid #ddd;
  border-radius: 4px;
  padding: 6px 14px;
  font-family: var(--sl-font-mono);
  font-size: 0.6875rem;
  line-height: 1.5;
  color: #333;
  overflow-x: auto;
  margin: 1rem 0 1rem 1.5rem;
">
https://<span class="badge" title="24-character project identifier">67e89abc123def456789abcd</span>-<span class="badge" title="24-character container identifier">890abcdef12345678901cdef</span>-<span class="service-badge" title="Desktop display service">display-1</span>.<span class="badge" title="Your bare metal server provided by Hoody">node-us</span>.containers.hoody.icu
https://<span class="badge" title="24-character project identifier">234567890abcdef123456789</span>-<span class="badge" title="24-character container identifier">abc789abcdef01234567890a</span>-<span class="service-badge" title="Script execution service">exec-1</span>.<span class="badge" title="Your bare metal server provided by Hoody">node-us</span>.containers.hoody.icu
https://<span class="badge" title="24-character project identifier">cdef123456789abc01234567</span>-<span class="badge" title="24-character container identifier">890abcdef123456789abcdef</span>-<span class="service-badge" title="AI agent service">agent-1</span>.<span class="badge" title="Your bare metal server provided by Hoody">node-us</span>.containers.hoody.icu
</div>

One URL per computer. Isolated. Secure. Already online. Already multiplayer. Already embeddable.

**Why isolation matters:** In the AI era, when users blindly trust AI-generated code, isolation isn't optional—it's survival. Each project, each experiment, each AI task runs in its own container. One compromised computer doesn't touch the others.

**Every capability, every service type:**



Plus:
- **Workspaces** — Infinite floating WebOS, shareable desktops with window management that can display multiple containers
- **Containers** — Spawn infinite computers from one server
- **Realms** — API isolation scopes (`https://{realmId}.api.hoody.icu`) for safe multi-tenant automation
- **Storage Shares** — Files accessible across all containers
- **Proxy Aliases** — `your-app.com` → any container, any path
- **Permissions** — Open by default, locked when ready
- **Snapshots** — Time travel for entire computers
- **+100 endpoints** — Basically "Linux" as HTTP - everything can be done

### Your Computers Exist Across Time

```
Last Week ──→ Yesterday ──→ 3h ago ──→ 1h ago ──→ NOW
   ●             ●            ●          ●         ●
```

**Snapshot any moment. Restore instantly.** Everything returns: open browser tabs, running processes, file edits, database states, terminal history. Every computer, exactly as it was.

📸 Infinite snapshots
⚡ Restore in seconds
🌲 Branch like Git

Snapshot before AI rewrites code. Instant rollback if it breaks.
Snapshot before deployments. Restore everything in seconds.
Snapshot experiments. Branch computers like Git branches code.

**Isolation + Time Travel = Security for the AI era.**

### URLs Are Multiplayer by Default

Share a URL. That's it. Everyone's in.

Forget screen sharing and "can you see my cursor?" When everything is a URL, collaboration is instant. Multiple people in the same terminal with colored cursors. Editing the same files simultaneously. Controlling the same browser. Debugging together in real-time. It's Google Docs but for computers.

**Isolate what you share.** Give your team the staging environment URL, not your personal dev containers. Share the production monitoring computer, not the experimental AI playground. Precision multiplayer through URL-based access.

Everything has a URL. Everything is multiplayer. Everything is already online.

## Hoody OS: Your Operating System Lives on the Web

We didn't just make computers accessible via HTTP. We built an entire **operating system** on top of them.

**Hoody OS** is a floating-window web-based OS running on servers you own, built by a team with years of privacy and security engineering behind it. It includes:
- **Hoody Home** — Your dashboard, project launcher, and starting point
- **Hoody Console** — Server management, container administration, monitoring
- **Hoody Workspaces** — A full desktop environment with draggable windows — terminals, code editors, file browsers, AI agents, displays, databases — all arranged however you want

Every app is a URL. Every process inside your container is a URL. Every one of those URLs is HTTPS with HTTP/2 and HTTP/3, automatically, forever. You'll never configure a certificate, never think about TLS, never debug an SSL handshake. That era is over.



Here's what makes it revolutionary: **Hoody OS itself runs on a Hoody container.** The OS that manages your containers is running in a container. It's embeddable, it's shareable, it's multiplayer. You can `<iframe>` the OS inside another OS. It's Hoody running inside Hoody.

And it gets crazier. Open your terminal anywhere on Earth and type:

```bash
ssh hoody.com
```

**Full Hoody OS in your terminal.** We built a complete terminal-based browser (`hoody-terminal-browser`) that renders the same floating-window OS as a TUI. Same functionality, same interface, rendered in characters. Access from a Raspberry Pi, a server with no GUI, your phone's terminal app, or — technically — an ESP32 if you're feeling adventurous.



No username required. No password. It shows a login screen like any browser would. Then you're in your full computing environment.

## Work From Anywhere Means ANYWHERE

On your phone at a café, pull up Hoody OS. On your friend's laptop, open a browser tab. On a plane, `ssh hoody.com` from the seat-back terminal. Your computers are already in the cloud — no syncing, no uploading, they're just there.

This isn't remote desktop. These are isolated computers, native to the web, with a full OS layer on top. The distinction between local and cloud disappears because everything is born online and stays online.

**Each computer is isolated.** AI experiments don't contaminate production. Personal projects don't leak into client work. Every context has its own secure boundary.

## The Economic Revolution

**The VPS model just died.** Today you pay $40/month per isolated server. Dev, staging, production? That's $120/month for three boxes sitting idle 90% of the time. This is insanity—it's like Gmail charging you per email address.

### The New Economics

**One Bare Metal Server → Infinite Containers**

With Hoody, you acquire one physical server and spawn unlimited containers. They share 100% of resources. The economics shift from:
- **Old:** $40 per container, forever
- **New:** $0 per infinite containers after server cost

This isn't a discount—it's a paradigm shift that makes experimentation free and scaling instant.

### Why Bare Metal Changes Everything

**Security Through Physical Control**

When you control the physical machine, you eliminate an entire threat vector. Your containers run on hardware **you own**—not shared with strangers, not in a neighbor's virtual partition. The host OS isn't shared. The hypervisor isn't shared. The bare metal is yours.

**This matters for:**
- **Zero-knowledge architecture** — Your data never touches shared infrastructure
- **AI-era security** — When AI generates code you can't review, isolation must be absolute
- **Compliance and sovereignty** — Data residency isn't a checkbox, it's physical reality
- **Performance** — No "noisy neighbor" problems, no resource contention

The container isolation model only works when the underlying hardware isn't compromised. Bare metal provides that foundation.

## Infrastructure+Code from Conversation

Tomorrow's software development: You describe what you want. AI writes code, builds, buys and sets up infrastructure, and it starts orchestrating everything, including you. It *all* happens through HTTP calls.

**Start from zero.** Tell the agent your budget. It rents a server instantly—bare metal under $20/month, provisioned in seconds. You provide decisions when asked. AI handles everything else.

You watch everything (and intervene) through `hoody-workspaces`—a WebOS in your browser. Your workspace shows everything:
- `hoody-agent` writing code in real-time and spawning dozen more dedicated agents
- `hoody-exec` deploying API endpoints  
- `hoody-terminal` installing packages
- `hoody-sqlite` setting up databases
- `hoody-browser` testing across Chrome versions

When AI needs decisions, `hoody-notification` pings your phone. You answer from anywhere. Work continues, 24/7.

**Here's what changes everything:** The AI begins orchestrating you too. It knows when to request your creativity—"Review this UX flow," linking to `display-1`. "Explain your vision for this feature," opening `code-1` to the exact function. You're not just directing AI; it's directing you to where human insight matters most.

Before production, a security agent implements defense in depth—network isolation, least-privilege access controls, rate limiting, audit logging. Enterprise-grade security by default.

Every agent works in isolated containers. Experiments can't affect production. When something works, snapshot everything. Agents connect your domains and clone to production in seconds.

Any AI on the internet joins this party too. Give ChatGPT, Claude Code, or Codex the address `@hoody.com` — it fetches a Skill, structured instructions for controlling your entire infrastructure via HTTP. Like `ssh hoody.com` opened your OS to any human with a terminal, `@hoody.com` opens it to any AI with a browser. No SDK. No integration. Just HTTP.

**Tomorrow, solo founders will compete with enterprises.**


## Join the Revolution

In 2 to 5 years, everyone will orchestrate AI to build their ideas. The platform that enables this orchestration owns the future. That platform must be HTTP-native so AI understands it naturally, containerized by default for security in the no-code era, infinitely scalable without per-unit costs, completely auditable for the AI safety era, and embeddable everywhere from phones to VR headsets.

> *That platform is Hoody.*