What if the most consequential decision about where AI agents actually run isn’t being made in a chip design lab, but in a telecom pricing meeting?
Reliance Jio, the telecom arm of Mukesh Ambani’s conglomerate, is offering to turn aging computers into AI-ready PCs through cloud services for roughly $11 over two months. The pitch is straightforward: don’t buy a new laptop, keep the one you have, and let the intelligence arrive over the wire. The stated goal is extending the lifecycle of existing hardware. Reliance has separately earmarked 10 trillion rupees, about $110 billion, for its AI expansion plans.
I want to set aside the consumer story, which is mostly about affordability, and look at what this implies architecturally. Because the industry has spent the past two years telling a different story entirely.
Two competing theories of where an agent lives
The dominant narrative around “AI PCs” has been local inference. Put a neural processing unit in the machine, run a small model on-device, keep the data local, cut the round trip. That story requires new silicon, which conveniently requires new hardware sales. It also has real technical merit: latency for interactive tasks, privacy for personal files, and no dependency on connectivity.
Jio’s approach inverts every one of those assumptions. The endpoint becomes a rendering surface. The keyboard, the screen, and the network stack are the only local requirements. Everything above that — the operating environment, the model, the tool-calling loop, the memory — sits somewhere else and streams down.
This is the thin client, returning under a new banner. And for agent systems specifically, it may be the more natural fit.
Why agents behave differently than chatbots
A chat interface is bursty and interactive. You type, you wait a second, you read. Latency is felt directly, which is why local inference looks appealing.
An agent is not that. An agent is a long-running process that plans, calls tools, waits on external APIs, retries failures, and accumulates state across minutes or hours. The bottleneck in a real agent loop is rarely token generation on the last hop to your eyes. It’s the tool calls, the retrieval steps, the sequential dependencies between actions.
That workload profile has some awkward consequences for the on-device story:
- Persistence. An agent that runs for forty minutes shouldn’t die because a laptop lid closed. Server-side execution gives you durable sessions for free.
- Memory footprint. Agent memory — vector stores, conversation history, intermediate artifacts, execution traces — grows in ways that a decade-old machine’s storage and RAM cannot absorb.
- Tool proximity. Most tools an agent calls are network services anyway. Running the orchestrator next to those services, rather than at the far end of a consumer connection, removes a hop from every single step in the loop.
- Model swapping. Routing between a small fast model and a large capable one is trivial server-side and painful on fixed local silicon.
Put plainly: the parts of an agent that benefit from being local are the interface, and the parts that benefit from being remote are almost everything else.
What this costs you
I don’t want to oversell the centralized model. It carries real architectural debt.
Connectivity becomes a hard dependency. An agent that can’t reach its brain isn’t degraded, it’s dead. Offline capability isn’t a nice-to-have for a productivity machine; it’s the difference between a tool and a subscription that occasionally works.
Then there’s the trust boundary. When the operating environment itself is remote, every keystroke, document, and credential passes through infrastructure you don’t control. For agents, this is sharper than for ordinary cloud apps, because agents hold delegated authority. They act on your behalf, with your permissions. Multi-tenant isolation on a shared execution substrate becomes a security property that users cannot audit and mostly won’t think about.
And the economics of a low monthly price cut both ways. Cheap access is genuinely expansive — it puts capable computing in front of people who would otherwise be locked out by hardware costs. It also concentrates the dependency. The party that runs the substrate decides which models are available, what the rate limits are, and what the loop is permitted to do.
The signal worth watching
Sustainability is the framing Jio leads with, and extending hardware lifecycles is a defensible goal on its own. But the architectural signal underneath is more interesting to me: a large operator is betting that the agent’s home is the network, not the device, and pricing that bet at a level designed for mass adoption.
If that bet works at scale in a market of this size, it reframes the AI PC conversation. The question stops being how many trillions of operations per second your local chip can manage, and becomes how much of your computing you’re willing to rent.
Those are very different questions, and only one of them sells silicon.
🕒 Published: