The HTTP Revolution

Hoody doesn’t just use HTTP—we’ve transformed the entire computing stack into HTTP endpoints.

Your terminal is an HTTP API. Your desktop is a URL. Your files are endpoints. Your database is JSON over HTTP. Even your browser automation is REST calls.

This isn’t about convenience. It’s about fundamentally reimagining computing for the AI era.

Why We Made Everything HTTP

The Problem We Solved

Every tool speaks a different language. Every integration requires specialized knowledge. Every AI agent needs custom adapters.

We asked: What if everything spoke the same language?

The Hoody Answer

We didn’t just add HTTP APIs to existing tools. We rebuilt the entire stack as HTTP-native services.

The Hoody Kit includes 18 services that abstract Linux and common tools into pure HTTP:

Terminal - Execute shell commands via HTTP endpoints
Files - Access filesystems as HTTP resources
Display - Desktop environments accessible through URLs
Browser - Chrome automation as REST APIs
Exec - Scripts that become HTTP endpoints
SQLite - Databases queryable via HTTP
Code - VS Code instances spawned via URLs
cURL - Complex HTTP operations simplified to GET requests
Notifications - Native alerts triggered via HTTP
Daemons - Background process management as HTTP endpoints
Cron - Scheduled tasks managed via HTTP
Pipe - Streaming data transfer between any devices via URLs
Notes - Collaborative notebooks with real-time sync
Watch - File and process watchers as HTTP streams
Run - Process lifecycle management (spawn, wait, tail) via HTTP
Tunnel - Reverse tunnels for Hoody containers
Proxy Logs - Request-level routing and audit logs
Workspaces - The web-based OS that ties every service into one URL

Every layer of computing, exposed as HTTP.

Why This Changes Everything

1. AI Understands Everything Instantly

LLMs were trained on the web. They understand HTTP natively. When your entire infrastructure is HTTP:

No SDK needed—AI already knows how to make HTTP requests
No documentation parsing—Request/response patterns are universal
No integration layer—Direct execution via HTTP calls

AI can orchestrate your terminal, files, browser, database, and more—all through HTTP.

@hoody.com proves the universality: any AI with web access — ChatGPT, Claude Code, Codex, Cline — visits that address and receives a Skill: structured HTTP documentation covering your entire infrastructure. No installation. No onboarding. The AI already speaks HTTP; Hoody just hands it the map.

2. AI Orchestrates AI (The Floating Architecture)

Here’s where it gets wild: Containers aren’t hierarchical. They’re peers.

No “host managing containers”. No parent-child relationships. Just URLs talking to URLs. An AI agent in Container A can directly control an AI agent in Container B—which can spawn and control Container C—which can orchestrate Container D.

This is “floating” architecture: containers exist as equals, accessing each other’s full capabilities via HTTP.

AI in Container A orchestrates AI in Container B. AI in Container B spawns Container C. AI in Container B directly reads Container C’s files, queries its database, executes commands in its terminal. AI in Container B reports findings back to Container A’s memory bank.

Multi-agent systems emerge naturally. No orchestrator needed. No message queue. No coordinator service. Just AI agents making HTTP calls to each other, spawning new containers as needed, accessing each other’s terminals, files, and databases directly.

This is Inception for AI: agents all the way down, each with full computing capabilities, all coordinating via HTTP.

3. Everything Is Embeddable

When everything has a URL, everything can be embedded anywhere.

Embed a live terminal in your docs. Put a desktop in your spreadsheet. Show live files in your presentation. No plugins. No special clients. Just iframes and URLs.

4. Multiplayer Becomes Automatic

HTTP is stateless and concurrent by design. When everything is HTTP:

Multiple cursors in terminals—just multiple HTTP sessions
Shared desktops—everyone hits the same URL
Collaborative debugging—same browser, multiple controllers
Real-time file editing—concurrent HTTP requests

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

5. Infinite Cascading via hoody-curl

Here’s the breakthrough: Any REST API can become a simple URL.

The hoody-curl service (part of the Hoody Kit in every container) transforms complex HTTP requests into pure GET URLs. This means you can cascade any operation, anywhere—even from restricted environments that only allow GET requests.

Want to make a POST request from a simple URL? Done. Need to call an API that requires authentication headers? Just parameters. Chain multiple HTTP services together? Pure composition.

This isn’t just convenience—it’s infinite composability. Every Hoody service can call every other service, which can call external APIs, which can trigger more Hoody services. All cascading through simple HTTP.

Because every container has hoody-curl, any operation anywhere can be transformed into a shareable, embeddable, callable URL. A chatbot, a QR code, a Slack message, an AI agent with link-fetching — any of them can trigger any workflow you’ve wrapped into a GET. The entire web becomes composable building blocks.

Man-In-The-Middle Everything

The Hidden Power: Total Observability

When everything is HTTP, everything becomes transparent. Every action, every data flow, every decision—all flowing through a single, inspectable protocol.

Your entire digital life becomes observable:

Every API call your containers make
Every file your team accesses
Every command executed in any terminal
Every database query, browser action, script execution
Every AI decision and tool use

This isn’t just logging. This is complete computational awareness.

The Hyperlever Era

Observing everything is the key to our future.

Tomorrow’s productivity doesn’t come from working harder—it comes from systems that understand your work completely. When every action flows through HTTP, AI can see patterns you can’t. It learns what you do, when you do it, why it worked.

Your workflows become training data—automatically.

Computing That Customizes Itself

Here’s where HTTP unlocks something unprecedented: Because Hoody API and every container service is HTTP, you can intercept and enhance ANY endpoint through hoody-exec.

Want to modify how the Hoody API behaves? Intercept it with hoody-exec. Want smarter file access? Intercept hoody-files with hoody-exec. Want database queries that optimize themselves? Intercept hoody-sqlite with hoody-exec.

Your Personal Platform Fork

Every user can build their perfect version of Hoody—without touching the core:

MITM the Hoody API - Auto-tag containers, track costs, enforce workflows, add custom validation—all through hoody-exec intercepting the API that creates containers
MITM Container Services - Add monitoring layers, rate limiting, caching, AI enhancement to any service through hoody-exec
MITM Files - Access a code file? hoody-exec intercepts the request, AI adds documentation comments, explains complex functions—before serving it to you
MITM Databases - Query SQLite? hoody-exec intercepts to optimize the query, suggest indexes, explain the result set
MITM Terminals - Execute a command? hoody-exec intercepts to safety-check, auto-document, learn your workflows

The platform adapts to you. Not you to the platform.

Infrastructure That Writes Itself

This is beyond customization. This is self-building infrastructure:

Non-Existent Endpoints Materialize

Visit /api/analytics/dashboard—it doesn’t exist yet? Your hoody-exec script asks AI “what should this return?” and generates it. Instantly. The endpoint now exists, perfectly tailored to your needs.

Files Document Themselves

Access a complex codebase? As you browse, hoody-exec intercepts file requests and AI adds explanatory comments in real-time. The code becomes self-documenting through observation.

Databases Optimize Themselves

Run a slow query? hoody-exec detects the pattern, asks AI to optimize, and injects better indexes automatically. Your database gets smarter the more you use it.

Features You Need, Instantly

The infrastructure doesn’t wait for feature requests. It creates features on-demand through AI-powered hoody-exec interception. You work, it adapts.

MITM the MITM: Infinite Extensibility

Here’s the meta-capability that breaks everything open:

Since hoody-exec scripts ARE HTTP endpoints, you can MITM your hoody-exec scripts.

Layer 1 (hoody-exec) intercepts and logs
Layer 2 (another hoody-exec) intercepts Layer 1 to add caching
Layer 3 (another hoody-exec) intercepts Layer 2 to add AI enhancement
Layer N intercepts Layer N-1 to add whatever you imagine

Cascading intelligence. Composable enhancement layers. Each hoody-exec script can be intercepted by another hoody-exec script, creating chains of capability that evolve with your needs.

You’re not configuring a platform. You’re growing an intelligence that learns and extends itself through pure HTTP manipulation.

Binary protocols hide this potential. HTTP exposes it:

Every action is JSON—human-readable, grep-able, audit-able
Every request shows clear intent
Every auth check, permission verification, access attempt—visible
MITM isn’t an attack—it’s how the platform learns, adapts, and becomes uniquely yours

This is computing that adapts to humans, not humans adapting to computing.

Universal Access

When everything is HTTP:

Your phone can run enterprise workloads (it has a browser)
Your TV can execute code (it has a browser)
Your smartwatch can control servers (it can make HTTP requests)
WebAssembly? Progressive Web Apps? They’re already home

The End of “Local vs. Remote”

There’s no difference between:

http://localhost:5000/terminal/execute
https://container.hoody.icu/terminal/execute

Local and cloud become deployment details, not architectural constraints.

Why Hoody, Why Now

Three forces converged:

AI needs structured communication—HTTP + JSON is the universal format
Browsers became operating systems—V8 runs everything, everywhere
Containers made isolation cheap—Spawn 1000 computers, each with HTTP APIs

We’re not fighting the future. We’re acknowledging reality:

Computing IS the web. Hoody just makes it official.

The New Reality

This is what changes:

Developers: Stop learning 50 protocols. Everything is HTTP.
DevOps: Stop configuring connections. Everything connects via URLs.
AI Engineers: Stop building adapters. AI already speaks HTTP.
Enterprises: Stop buying integration platforms. HTTP is the platform.

Every service. One language. Infinite possibilities.

We didn’t add HTTP to computing.
We rebuilt computing as HTTP.
And that changes everything.

Next: Multiplayer by Default →