EST. THE DESIGN PHASE
The Hobo Herald
PRICE: ONE BINDLE
Workloads seen packing a single Bindle and boarding any provider that passes policy — cost, region and uptime gates all reported intact upon arrival.
THE OPEN ROAD — Sources close to the control plane confirm that once an app is described, its placement becomes a standing decision: when a better-value home opens up, HoBo plans the move, gates it, and rides. Landlords could not be reached for comment.
"A closed platform is easy," the letter reads, "right up until the rent triples — one runtime, one bill, and the exits are decorative." Of the other landlord: "raw cloud gives you full control… of a second job. Every app team slowly becomes a part-time platform crew."
I. Pack the Bindle — everything the app owns. II. Declare policies — cost, region, uptime. III. Board the Camp that passes every gate. IV. When the rent turns, ride again. No rewrite, no war room.
CLASSIFIEDS
PUBLIC NOTICE — HoBo is pre-release. The surfaces documented in this edition are the contract the product is being built to. Consult the record.
LO — THE WANDERING APP,
WEARY OF RENT,
PACKS ITS BINDLE.
IT RIDES AT MIDNIGHT.
THE CHEAPEST HOME THAT
PASSES POLICY AWAITS.
WHEN THE RENT TURNS —
IT SIMPLY RIDES AGAIN.
SCENE II
TWO LANDLORDS. ONE OWNS YOU.
THE OTHER WORKS YOU.
SCENE III
PACK · DECLARE · BOARD ·
AND WHEN THE RENT TURNS — RIDE AGAIN.
CAST OF CHARACTERS
— THE END IS NOT WRITTEN. (PRE-RELEASE) —
DISPATCH BOARD · every app a scheduled departure
DEPARTURES
| 14:10 | closed-paas → open-road | ON TIME |
| 14:22 | pricey-east → cheaper-west | GATED |
| 14:31 | own-metal ⇄ any-provider | STANDING |
STATUS: PRE-RELEASE · LOCAL LANE LIVE · DEPLOY LANES CREDENTIAL-GATED · full board
Dear folks — found the app a cheaper room out west. Landlord never even saw us pack. It's got its bindle, it's got its policies, and when the rent turns, we'll ride again. — Bo
packing list
Before we left — the old landlord owned the walls, and the new one wanted us doing his chores nights and weekends. So we packed. One bindle. That's the whole trick. — Bo
🎫 ADMIT ONE — the open road (pre-release: the road's still being laid) · see how far it goes
Pre-release — not on npm; clone the repo and build
@hobo/hobo. Default apply is an in-memory Pulumi
stand-in. HoBo continuously migrates your app to the
cheapest home that passes your policies. Describe
it once; when a better deal opens up — on any provider, a mix of
them, or your own metal — HoBo plans the move, gates it, and rides.
import { bindle } from "@hobo/bindles";
import { app as helloApi } from "./api";
import { app as helloWeb } from "./webapp";
// Pack once — provider-agnostic by construction.
export default bindle("hello-bindle", (b) => {
const api = b.api(() => helloApi.fetch);
const web = b.web(() => helloWeb.fetch).dependsOn(api);
return { api, web };
});Modern teams pick between a closed PaaS that owns them and raw IaC that consumes them. HoBo's founding grudge: your code shouldn't pay a loyalty tax to its landlord.
A closed PaaS is easy right up until the rent triples. One runtime, one bill, and the exits are decorative.
Raw cloud + IaC gives you full control — of a second job. Every app team slowly becomes a part-time platform team.
Travel light. Describe intent, not infrastructure, and let
policy, price, and reliability goals pick the home. Need
provider-native power? It's one typed
.with(...) away.
Other platforms deploy your app and call it a day. HoBo keeps watching the market: when a cheaper home passes your policy gates, it plans the move, rehearses it, and rides — with your blessing or on full auto.
01 · PACK
Everything your app owns, rolled into one provider-agnostic
bundle: services, resources, wiring, and inline
.allow() least privilege. If it's not in the
bindle, it doesn't ship.
02 · SETTLE
A Camp is the environment shape your app occupies (prod, staging, …) and the durable runtime substrate. Pitch one to pin env semantics — or write none and HoBo infers a camp. Provider selection lives on the Yard.
03 · RIDE
Price drops, credits appear, a region gets flaky — HoBo replans
placement continuously and moves the bindle when it's worth it.
Same convergence loop as hobo up, so a
move is never a special event.
MigrationPlanned Gated Migrated Every hop is an event in an append-only log — replay the journey, audit every fare, roll back any move. How the moving works →
HoBo's primitives are named for the life: pack a bindle, pitch a camp, work a yard, meet at the junction — plus stations for control isolation and trails for continuous moves. Start with the bindle.
The app, packed: services, resources, wiring, policies, and deployment intent — provider-agnostic by construction. The same bindle unpacks anywhere, which is exactly what makes it cheap to move.
Pack your first bindle →
Environment shape and runtime requirements — not the cloud account. Pitch one to pin prod/staging semantics, or skip it and HoBo infers a camp on the local lane.
Pitch a camp (optional) →
Provider selection point: one provider, zero or more camps, shared policy and identity. Self-hostable — the Yard is itself a bindle.
Run a yard →
Where yards meet: cross-cloud federation for hybrid and multi-cloud — peer yards, no shared mutable state.
Wire a junction →
Hard isolation boundary a Conductor occupies — rails, connections, fail-closed setup. Not app topology.
Init a station →
App-owned continuous migration recipes: duals, rebinds, cutover — composing identity continuous when you need it.
Plan a trail →
Every deploy, migration, and token grant is an appended event. Time travel isn't a feature, it's the data model.
Ports are WIT interfaces; apps are wasm components (with an OCI fallback); providers are capability providers. That thin, typed port contract is what makes moving homes cheap — any Component-Model language rides the same rails.
HoBo splits cleanly along the lines teams already have. Each role owns one kind of artifact — and nobody has to touch the others'.
WRITE BINDLES
Describe the app — services, resources, wiring, permissions — in plain code. No YAML, no infra tickets, no cloud console.
HoBo for Developers →
WRITE CAMPS · YARDS · JUNCTIONS
Own where apps live: approved providers, camp templates, yard policy, and the junctions that federate clouds.
HoBo for Platform Engineers →
WRITE POLICY
Decide what's allowed to run where — and what may cross a junction. Every decision is enforced at the gate and logged as an event.
HoBo for DevSecOps →
Every capability is reachable via SDK, CLI, and MCP. Agents aren't a chat box bolted on — they're principals with their own scoped, short-lived credentials.
Agents self-provision exactly the credentials a task needs through a machine-readable capability standard — and every token issued is an auditable event like everything else.
SRE, Endpoint Monitor, GitOps, Platform Engineer, SWE, UX Designer, and FinOps ship as policy-gated Yard operators — HoBo ships the operators, not just the APIs they'd call. Built-in operators →
Declare a @component class whose
@operation methods carry intent, a typed
contract shape, and an optional rubric enforced as policy —
then hand it to b.api(...). Stubbed operations
run day one, and the generation pipeline grows the real
implementations — promoted only past conformance, eval
thresholds, and policy.
Declare first, generate the code →
Missing an adapter for your favorite discount host? The generation pipeline writes it; the port's contract suite certifies it. More homes on the map, cheaper moves for everyone. Build a custom provider →
Welcome, fellow traveler. This whole site is written to be as useful to you as to the humans you work for: stable headings, copy-pasteable snippets, canonical CLI verbs.
Start with the machine-readable briefing at
llms.txt (or the whole
site in one document at
llms-full.txt),
then the
agent docs for the MCP surface
and how to earn credentials.
Cloud-agnostic options are IaC-flavored, Kubernetes-bound, or not AI-native. AI-native options are single-runtime and locked in. Nobody else keeps looking for a cheaper home after move-in day.
| Product | Category | Cloud-agnostic | Runtime model | AI-native | Self-host |
|---|---|---|---|---|---|
| Lakebed | Agent-native PaaS | ✗ own runtime | sync RPC | agent-readable contracts | ✗ |
| Vercel + Workflow SDK | PaaS + durable execution | partial | durable workflows/steps | DurableAgent | runtime only |
| Nitric | Infra-from-code framework | ✓ | functions/resources | ✗ | ✓ |
| SST (v3 "Ion") | IfC framework (Pulumi/TF) | ◐ AWS-centric | serverless + containers | ✗ | ✓ OSS core |
| Crossplane | K8s control plane | ✓ | reconcilers (CRDs) | ✗ | ✓ (k8s) |
| wasmCloud | Wasm runtime (HoBo's default host) | ✓ | components + providers | ✗ | ✓ |
| HoBo | AI-native meta-cloud | ✓ ports & adapters | wasm components + actors + durable workflows + sagas | agents as principals · generation pipeline · MCP | ✓ the Yard is a Bindle |
And the HoBo-only column: continuous migration — placement is re-decided for as long as your app lives, not once at deploy time.
Pack a bindle — that's the only must — and let your app find its way home. Pitch a camp if you're picky about the spot. Yards and junctions can wait until it starts collecting passport stamps.