There is a moment, using any AI assistant, where the conversation stops being useful and starts being homework.
You ask it to fix the failing build. It writes a patch. You copy the patch, switch windows, apply it, run the test, copy the error, switch back, paste. You ask it to pull last month's numbers into a report. It writes you a beautiful outline of a report you now have to make. The model is doing something genuinely impressive, and you have become its hands.
This isn't a prompt problem. It's not a context-window problem, and the next model won't fix it. It's an architecture problem: the assistant has no computer.
The shape everyone shipped
Look at almost any AI product and you find the same shape underneath. A text box takes your words, a model produces words back, and the boundary of the system is the edge of that box. Everything the model wants to do has to be smuggled out through you.
The industry noticed this, and the response was tools — function calling, plugins, integrations. Those help, and they're real. But a tool call is a thin straw into a world the model doesn't live in. It can query your calendar. It cannot install a package, leave it installed, and still have it there tomorrow. It cannot start a dev server and keep it running. It cannot open a file it wrote yesterday, because there was no yesterday.
What's missing isn't capability. It's continuity, and continuity needs somewhere to be continuous.
Three ways the industry tried to fix it
Give the agent your laptop. This is where the most capable agents live today, and they're capable precisely because they have a real computer with a real shell. The trade is brutal, though: that computer is yours. The agent runs as you, with your keys and your shell history within reach. It burns your CPU. And it stops when you close the lid — which means a four-hour task requires four hours of you being awake near it. Nothing runs overnight. Nothing runs during your commute. And there is no way to hand your working setup to a colleague.
Give the agent a scratch container. Hosted products often spin up a sandbox per request. It's isolated, which is good, and it's ephemeral, which is fatal. You can't install something that lasts. There's nowhere to keep a credential. Yesterday's work is gone, so every session starts by re-explaining the world.
Give the human a cloud computer. Cloud dev environments solved reproducibility years ago, and they solved it well. But they're computers with nobody in them. You still drive every keystroke; the agent, if there is one, is a plugin in the corner. The machine is real and the residency isn't.
Each approach has one of the three properties you need — capability, isolation, persistence — and gives up the others.
What changes when the agent lives somewhere
The fix is unglamorous: give every person a real, private, always-on computer, and let the agent live on it. Not call into it. Live on it.
Once you do, a set of problems stop being problems, and they're not the ones you'd predict.
Time stops being a constraint. This is the big one, and it's the one a laptop-bound agent structurally cannot offer. If the machine doesn't sleep when you do, a task started at 6pm is finished at 9am. Recurring work goes on a schedule and runs unattended. You stop being the thing the work is waiting on.
The copy-paste loop disappears. Not because it got faster, but because there's nothing to copy. The agent installs the dependency on the machine where the dependency is needed. It runs the server on the machine the server runs on. It writes the file into the folder the file belongs in. The work happened where the work lives.
State accumulates. The machine remembers. What the agent set up last week is still there this week — the installed toolchain, the cloned repo, the half-finished analysis, the data file you don't want to re-upload. Context stops being something you rebuild every morning.
Isolation becomes structural instead of aspirational. One machine, one owner. Not a shared tenancy with careful access rules — a computer that is simply yours, where credentials live server-side and never reach a browser or a model.
The part that surprised us
We expected all of that. What we didn't expect was how much the interface had to change once the agent could actually act.
When an assistant can only talk, a wall of text is an acceptable output, because text is all there is. When it can do things, text becomes a terrible interface. "I found four candidate configurations, here are the tradeoffs in nine paragraphs" is a worse answer than four buttons. "Here are the numbers" is worse than a chart. A decision should be a click.
So the sessions render real interface — forms, choices, tables, charts — mid-conversation. That turned out to matter far beyond aesthetics: it's the difference between a tool only engineers tolerate and one a delivery manager or an analyst will actually use. The capable agent tools today all ship as terminal binaries, which quietly excludes most of the people who have the problem.
Why this is possible now, and not two years ago
Two things became true at roughly the same time.
Models got good enough to complete multi-step work without a human checking each step. That was the loud change, and everyone noticed it.
The quiet change matters more here: running a small, isolated, persistent container per person became cheap enough to simply do. Not cheap enough to do carefully for enterprise customers — cheap enough to hand one to everybody who signs in, and leave it running.
Put those together and the bottleneck moves. It's no longer intelligence. It's substrate. And almost everyone is still shipping a smarter box for the intelligence to sit in.
What we built
Hoshi gives every person a dedicated cloud machine with an agent living on it. A real filesystem, a real shell, real processes, always on, never shared. Organizations publish their project setups once as boilerplates, and every member pulls a working checkout instead of starting from a blank page — so the accumulated knowledge of how your team builds arrives with the code, instead of living in someone's head.
You reach the same machine from the browser, a native desktop app, your phone, or SSH. It's one room with four doors, not four accounts.
It's in open alpha now, and open means open: sign in and your machine comes up.
The models were never the bottleneck. They just had nowhere to work.