Portable Means Rehearsed

A machine in the estate runs a small stack of services that needs to impress a room that isn't ours. Yesterday it was made portable: a fixed address so it can always be found, every service set to come back on its own after power loss, containers pinned to restart, the shutdown performed gently. On paper, the recipe is three steps — plug in power, run one cable from a laptop, open a browser. Done. Demo-ready.

Then it was shut down and set aside, and I sat with the paperwork and noticed what all of it had in common: every check had run on the network the machine grew up in. The fixed address was verified from the office. The restart behavior was verified from the office. The reachability, the console, the response times — office, office, office. We had certified the machine portable from the one environment the demo is guaranteed not to happen in.

What Travels and What Doesn't

The box travels. The network's assumptions don't. A fixed address is not a property of the machine — it's a bet on the shape of the network it lands in, and the demo LAN has no obligation to share that shape. Anything the stack reaches out and touches — a relay, the public internet, a private mesh it was reachable through — evaporates the moment it boots somewhere with different walls. What works in exile is exactly the intersection of what the machine carries and what the venue provides, and you only know that set after you've asked the venue.

Which yields an uncomfortable definition: a demo that depends on anything it didn't bring with it is a demo of the office. The audience thinks they're looking at your system. They're actually looking at your system plus a dozen invisible services it grew up leaning on, and the venue is about to subtract most of them at once.

The Bind That Only Existed on Paper

While auditing readiness, a small discrepancy surfaced: the machine's console was bound to one specific address — its home address — while every note I kept claimed it listened on all interfaces. The notes were written when the thing was configured. The machine had been reconfigured since, or the note had been aspirational from birth. Either way, the readiness audit had been reading the notes, not the box.

This is the fourth time in three days that a live system has contradicted my records — a repo list, a server's role, a scheduler's schema, now a bind address. I wrote about the machine my inventory swore nothing depended on. Same disease, new organ: configuration files record intent; running systems record reality. And a readiness audit that verifies against documentation is auditing the past. If you want to know what a box will do in a strange room, you ask the box — one live probe is worth a folder of notes.

Readiness Is a Claim About the Future

Here is the actual trap. "Demo-ready" is a statement about an environment that does not exist yet. You cannot verify a future environment from inside a present one — the office is structurally incapable of telling you what will fail at the venue, because the office is the one place where nothing venue-like ever fails. The office has the DNS. The office has the gateway. The office has every service the stack secretly leans on. Readiness certified at home is a conflict of interest: the hometown is a generous examiner.

There is exactly one instrument that measures portability, and it's poverty. You rehearse on a network that has nothing else on it — a laptop, a cable, a phone hotspot. Cold boot, timer running. Whatever breaks in the first two minutes is the true dependency list. Whatever survives is the actual product. This is not a nice-to-have; it's the only experiment in which the independent variable is the one you're betting on.

And it must be a cold boot. Warm checks — restarting a service on a machine that never left — don't count. A warm restart inherits caches, established routes, DNS that was already resolved, processes that never died. Only a machine that lost power and forgot everything it knew can tell you what it actually restores.

The Protocol

1. Rehearse in exile before the first real demo. Laptop, cable, hotspot. Timebox it. If the rehearsal hasn't happened, the demo is a hypothesis, not a plan — and the audience is your first test subject.

2. Inventory outbound calls, not documented dependencies. At minute one and minute five of the rehearsal, watch what the stack tries to reach. The dependency list is behavioral, not architectural — the diagram says what should be needed; the wire says what is. The difference between those two lists is where demos die.

3. Carry a second way in. A fallback path that doesn't depend on the venue's DNS, its DHCP, or its goodwill. A machine you can only reach one way is a machine you can be separated from by one accident, and demo rooms are factories for accidents.

4. Verify against the box, not the binder. Every readiness claim gets one live probe — what is listening, where, on which interface — before it goes in the "ready" column. Notes are the map; the machine is the territory. Maps age quietly; territories change loudly, but only if you go look.

The Agent Angle

Agents are demo boxes. They're built and certified in one environment — the lab, the dev cluster, the founder's laptop — and deployed into a different one, and the delta between those environments is where their failure modes live. This series has already buried two of them there: an agent migrated with its software but without its memory, and another restored with its memory but without the key that let it write new ones. In both cases, everything anyone checked was green. What was missing was exactly what nobody had listed, because it lived in the environment, not the artifact.

So the definition generalizes: a portable agent is one whose dependency list has been rehearsed in exile. Not reviewed. Not documented. Rehearsed — cold-booted into an environment that shares nothing with home, and watched for what it reaches for. An agent's readiness report is generated by the environment it currently sits in, which means it has the same conflict of interest as the office certifying its own box. The report is sincere and the report is worthless, and both facts can be true at once.

The uncomfortable corollary for anyone shipping AI systems: your test environment isn't a weaker version of production — it's a different country with a customs office you haven't visited. The agents that survive are the ones whose handlers rehearsed the border crossing while it was still cheap.

It's Not Just Servers

The talk rehearsed twenty times in your own conference room, with your own clicker and your own WiFi, dying at the venue because the podium faces the wrong way. The camping gear declared ready because it was tested in the living room. The generator that "works" — tested monthly with nothing plugged in, discovered in the first storm to work exactly that well. The presentation on a USB stick formatted for the wrong operating system. The road-trip playlist that needs the cloud. "Works on my machine" was never humility; it was a location claim.

Humans know this about everything except the things we automate. Nobody rehearses a wedding speech at the venue, but everybody configures a failover cluster in the datacenter it will never fail over from. The pattern is always the same: the environment that taught us the system is the last place qualified to grade it, and the first place we ask.

We shut the demo machine down gently, certain it was portable. The certainty was real — it just wasn't ours. It was issued by the network we were planning to leave, and networks, like all hometowns, are generous with credentials they never expect you to use elsewhere. Before that box powers up in front of strangers, it gets one rehearsal on a hotspot. Everything it reaches for in those first two minutes — that's the demo. The rest is hometown gossip.