Your PC Is the Agent

At Build, Jensen Huang described texting your PC from your phone and asking it to get some coding done while you are away. That is not a new interface. That is a loop, and it needs somewhere to put the work.

What was actually said

In his conversation with Satya Nadella at Microsoft Build, Huang described the machine on your desk becoming something you delegate to:

"I could be traveling and I'm on a phone, and I could text my PC and ask my PC to get some coding done, or some idea that I have, and it would fire up the tools on the PC and it would make the modifications or the changes or the design that I was... I told it to do. And it would iterate with me while I'm away from the PC."

The hardware claim underneath it is specific: a petaflop of local AI performance and 128 GB of memory, enough to hold a model of a couple of hundred billion parameters on the desk. Nadella called it "unmetered intelligence right at the edge." Huang made a second point that matters more to us than the first:

"The past CPUs were designed for humans and, you know, we're just more patient than agents are. Agents want low latency."

The interesting half is not the compute

Texting your PC is a demo. It is ephemeral, it is private to you, and it is gone if the machine sleeps. The moment more than one of these is running, or more than one person is involved, the interesting question stops being "can my PC do the work" and becomes "what is it working on, did someone else already do it, and what did it change."

That is an orchestration layer. Specifically it is a work queue with an atomic claim, so two agents cannot take the same task. A lease, so a machine that goes to sleep returns its work instead of holding it forever. Caps, so a runaway agent stops. A review gate, so what it produces is seen before it lands. An audit trail, so you can answer what an autonomous thing did on your behalf.

Cheap local compute does not make any of that less necessary. Twenty agents on free inference produce more unreviewed work per hour, not less.

We already run on your machine

xpntl loops are the version of this that exists today. You run xpntl loops watch on your own hardware. It registers the machine, leases work from the board, runs it through your harness, and reports back. Local execution is the default in onboarding, not a downgrade from a hosted tier.

The runner does not care which harness. It spawns the command you name and pipes the work to it, so Claude Code, Codex, or a model running locally on your own box are the same shape of thing to us. We did not build that for any particular chip. We built it because tying a coordination layer to one vendor's inference is a bad trade, and it happens to be exactly what an unmetered edge needs.

We were never selling you tokens

Hosted loops on xpntl run on your own subscriptions or keys, at cost, never metered or marked up. That has been our position since we shipped them.

It means a world of free local inference costs us nothing. There is no margin on resold compute for us to defend, because we never took one. We charge for the thing that stays scarce when compute does not: knowing what to work on, not duplicating it, and being able to review it afterwards.

If your agents move to the desk, we are still the place the work lives.

The latency point is the one to watch

Huang is right that agents are impatient, and it cuts toward us as much as anyone. An agent running at local speed and then waiting on a network round trip for every tool call has moved its bottleneck from the model to the wire.

Two things already help. xpntl is self-hostable with Docker Compose and a Helm chart, so the orchestration layer can sit on the same machine as the agent and the tool calls never leave it. And the sync engine is an op-log, so a client can catch up from where it left off rather than reloading the world.

We are not claiming that is finished. It is a real direction, and the architecture is already pointed at it.

Bring your own compute

The pitch has not changed, it has just gotten easier to say. Bring your own agents. Bring your own subscriptions or keys. Now, increasingly, bring your own hardware. Keep your data. We will keep the board, the queue, the guardrails and the history.

Read how loops work, or start free and point one at your own machine.