So did every agent I had.
I had my laptop open at Java on Ocean in the Ingleside neighborhood of San Francisco. I have a penchant for their dirty chai latte. At the time, I had a couple of agents working in parallel and a window of about an hour before I had to mobilize. And just as I took my first sip, the agent replies stopped coming in.
This was in June. I was five miles from my apartment with an immovable schedule: back-to-back appointments, none of them cancellable, none of them near home. What I didn't know yet, sitting there with a fleetingly warm beverage and a spinner that wouldn't resolve, was that my apartment's internet had gone out and would stay out for half a day. And that this single fact had just ended my ability to do any real work at all.
What I built #
Like a lot of people who've gotten serious about coding agents, I had moved mine off my laptop and phone and onto a homelab: a Raspberry Pi in my apartment, running Claude Code and Codex sessions inside tmux, reachable from anywhere over WireGuard. It felt like infrastructure. Sessions survived closed laptop lids. I could check on a long run from my phone. The Pi never ran out of battery and was accessible 24/7 (at first).
That morning it was grinding away on another of my projects while I watched from the café. Steady work on three different git repositories at once — ideas I'd sketched out and sent to the backlog.
Then the wire at home died. I got a ping from my ISP about an unplanned outage. Resolution time unknown.
ssh: connect to host pi port 22: Operation timed out
$ ping pi
--- pi ping statistics --- 12 packets transmitted, 0 received, 100% packet loss
And sitting there, enjoying my coffee, pondering the incident, powerless to deploy my army of agents, I came to a key insight.
Every path to the Pi ran through my home router — the WireGuard tunnel, SSH, the little web terminal I'd built on top — so my access was gone. But the less obvious half mattered more. A coding agent isn't a program that runs on your box; it's a loop between your box and a frontier model's API. No internet, no model, no agent. The Pi wasn't stranded mid-task, faithfully working while I was locked out. It was inert.
"Just start another session" #
I wasn't completely without options, and this is the part worth being honest about. Session resume is a solved problem: I could clone the repo onto my laptop, open Claude Code right there at the table, and be talking to a model in a few minutes. The model doesn't care which machine it's talking to.
But that session wouldn't be my setup. It was on a laptop on public wifi, without the compute, the environment, the guardrails, or the developer flexibility of the box I'd spent months shaping. It could write and edit code. It couldn't be the bespoke harness I had built for velocity and reliability.
And then there are the walls. Every agent user knows both. Sometimes the model just can't crack it. You can feel it circling, and no amount of re-prompting gets it there. That wall gets lower by the week as the models get better, but it hasn't disappeared. The other one is usage: you simply run out. The plan taps out, always mid-thought, and picking it back up is painstaking.
Both walls have the same exit. You take the work somewhere else: another agent, another model, another plan. And that part is genuinely awful: copy-pasting context into a fresh window, re-explaining what you were in the middle of doing, hoping you remember the pieces that matter. Twenty minutes of archaeology each time. And you never fully trust what comes out the other side.
So the failure wasn't that I lost files. It's that the work wasn't portable — not across machines when the network died, and not across agents when I hit a wall. And this wasn't even the Pi's first version of that lesson: run three Claude Code sessions at once, each comfortably using a gigabyte or more, and it OOMs and reboots, taking every session down with it. Same shape, different resource.
Sessions should be a medium, not a process #
I did look for something to buy, and there's more of them each month: hosted boxes you can rent, tools for reaching the machine you already own, orchestrators that run a dozen agents at once — several of them free and genuinely good. What I kept not finding was the part after the session starts. When I hit a wall I want to hand the work across — the conversation and the working tree, not a summary — to a different vendor's agent, mid-task, and get it back. I want a delegated side quest to come home as a merge, not a paste. And I want to know afterwards what the detour cost, per task, across both. That's the part I ended up building.
I'm a founding engineer shipping every day, across several repositories, usually with more than one agent going at once. I need the work itself to be the durable thing: able to outlive any single machine, to move to another agent when I hit a wall, and to be driven from one chat on whatever device I'm holding. A rented box and a remote terminal don't add up to that.
The tempting fix is a fatter tunnel into your house, an LTE backup route, a second VPN. That's patching the wrong layer. The real problem was that the work only existed in one place: bound to one machine, on one wire, reachable one way, movable nowhere.
The inversion that actually fixed it for me: treat a session as a medium, not a process. The durable part — the conversation, the working tree, the record of what's been done — lives somewhere always-on that your machines and your devices both connect to, instead of living inside one machine everything else has to reach. When a machine drops off, the work doesn't go with it. You can see where things stood, pick them up from somewhere else, or hand them to a different agent when you hit an inevitable wall. Your agents still run on compute you own, on your own plan.
That inversion is Bostrat. I went all in on building it within days of the outage, and the product plan still opens with the same reason:
"A local internet outage that stalled development and exposed the fragility of running agentic coding sessions on home infrastructure."
The Pi is still in the fleet — it's node #1 — but it isn't the whole fleet anymore, and it can't take a day down with it.
I still work from Java on Ocean — can't live without that latte. The difference is that if my apartment internet gives out, I find out from a status line while continuing to receive progress updates from my agent fleet, instead of from a chai going cold while a day's work sits idle, at least five miles away, waiting on something that had been within my control and suddenly wasn't.
Run your agents somewhere that survives
bostrat is in a code-gated beta. Leave your email and we'll send an access code in the next batch — your agents, your machines, your plan.
Codes go out in small batches. We never see your API keys or logins.