Chat AI asked what a model can do. Physical AI asks where it runs.
In my last piece I argued that AI-generated code will grow 100,000x, and that all that code has to run somewhere. That was a story about bits. The next jump is about atoms.
In five to ten years, the main AI story will not be chat or code. It will be machines that act in the physical world: robotaxis, humanoid robots, drones, and AI wearables (glasses, pins, and headsets with cameras and microphones that see, hear, and respond to the world around the person wearing them). The first signs are here. Waymo runs paid rides in about 14 US markets, and humanoid shipments in the first half of 2026 already passed all of 2025.
That shift changes what AI is. Every AI wave so far, from search to recommendations to chat to coding agents, has moved information. Text goes in, text comes out, and nothing in the world moves until a person acts on the answer. Physical AI moves atoms. Its output is a motion, and the world answers back. The information economy is large. The physical world is much larger.
This piece has three parts. Part I is about size: how big physical AI gets, and how much more inference (the work of running a trained model) it needs. Part II is about shape: why embodied AI is a different problem, and where its inference has to run. Part III is about the opportunity: what I learned building one of these systems, and the product I think Cloudflare should build.
Part I: How Big Physical AI Gets
Physical AI Contains Digital AI
A robot that folds laundry, or a car that drives itself, needs everything a chatbot has: language, vision, reasoning, memory. Then it needs a body, and the ability to act through that body in real time.
So physical AI is not a new market next to digital AI. It contains digital AI. Every robot is also a chatbot, a planner, and a coder. And it reaches the parts of the economy that digital AI never touches: manufacturing, logistics, transport, construction, agriculture, care. Agriculture and industry alone employ about half of the world’s workers, before counting drivers, couriers, and carers (World Bank).
Long-range forecasts are all over the map. Goldman Sachs projected a $38B humanoid market by 2035. Morgan Stanley projects a $5 trillion market by 2050. Jensen Huang has called physical AI a $50 trillion opportunity. When serious forecasts sit that far apart, nobody knows. And the low end is anchored on today, which is exactly how the 1992 internet traffic projections failed.
The Curve Is Already Here
Robots have been “five years away” for fifty years. What changed is that five things arrived at once: models that turn plain instructions into motion, simulation that trains robots before they touch the real world, fleet data, chips that fit in a body, and real labor shortages. Long-range forecasts are guesses. Production numbers are not. Look at what the last eighteen months already show.
Industry shipments are roughly tripling every year. About 18,000 humanoid robots shipped worldwide in 2025 (IDC). In the first half of 2026 alone, trackers count 19,000-25,000, up 270-430% year on year (SAG, Counterpoint, IDC). TrendForce expects more than 50,000 for the full year. Figure went from building one robot a day to one an hour in under four months.
Tesla is building for millions. Optimus production began on Tesla’s high-volume line in Fremont in the third quarter of 2026. That line is designed for about 1 million robots a year, and Musk expects it to take at least a year to reach about 20,000 a week. A second line in Texas, designed for a long-term capacity of 10 million a year, is under construction. Tesla plans to deliver to outside companies, starting with industrial customers, around the end of 2027. Musk’s timelines slip. But at 20,000 a week, Tesla alone would build about a million robots a year, which is where the industry curve puts the whole market around 2028.
Run the industry curve forward. The base case is the 3x a year we see now. The upside case is 4x, a doubling every six months:
| Year | Robots in service, 3x / year | Robots in service, 4x / year |
|---|---|---|
| 2028 | ~750k | ~1.2M |
| 2029 | ~2M | ~5M |
| 2030 | ~7M | ~20M |
| 2031 | ~20M | ~75M |
Either way: tens of millions of robots in the early 2030s. That does not count robotaxis or AI wearables.
How Much More Inference? About 100x
A chat user sends a few prompts a day. Then the model sits idle.
A robot never stops. Its cameras run all day. Its world keeps changing. Every second, it has something new to see, understand, and decide. Even if it asks a model off the device only once a second, with a camera frame and its context each time, that is about 100 million tokens a day (tokens are the small chunks of text or image a model reads and writes). A heavy chat user uses tens of thousands. One robot uses the inference of thousands of heavy chat users. As models move from turn-based to streaming (Part II), that rate climbs toward ten times a second.
Put that next to the fleet curve. Tens of millions of robots, each using the inference of thousands of chat users, means roughly 100x today’s total off-device inference within about five years, from robots alone. Robotaxis and AI wearables add more. The exact multiple depends on how fast the curve runs and how often robots call off the device. The direction doesn’t.
That can’t be delivered the way inference is delivered today. Almost all inference now is turn-based, served from a few large regions. Embodied inference is constant, streaming, and bound by the speed of a loop in the physical world. We need more compute to have enough, and we need it in the right place. That is why where matters as much as how much.
Who Wins
Map the winners by layer:
- On-device chips: NVIDIA, Tesla’s own chips, Qualcomm.
- Robots and vehicles: Tesla, Waymo, Figure, Unitree, and a long list of Chinese makers.
- Models for the body: Google DeepMind, Physical Intelligence, NVIDIA, Tesla.
- Training: NVIDIA and the hyperscalers.
- Connecting the levels: open.
That last layer is the one this piece is about. Tesla built it for itself. AWS and Google don’t lack compute. The question is how well placed each company is to make placement its primary service.
Part II: Where Inference Runs
A Slow Answer Is a Wrong Answer
Code runs, sends a request, and waits for a response. While it waits, the world doesn’t change.
A robot acts on the world, and the world responds. It pushes a cup, the cup slides, it feels the cup slide, it adjusts its grip. Think of a finger pressing on something: it feels the pressure, and the pressure changes what the finger does next. That loop never stops while the device is on. Fighter pilot John Boyd put it simply: the side with the faster loop wins. For a robot, loop speed is the main performance metric.
This changes how AI is served. Most LLM use today is turn-based: a query, a response, a wait. Embodied AI is stream-based: constant input, and constant updates to the output as the input changes. Streaming needs long-lived connections and session state (what the system remembers about this task so far) that lives next to the model. A stateless function in a distant region, one that forgets everything between calls, doesn’t fit.
The Device Has Limits
The obvious objection: robots run their AI on the device. Why send anything off it?
Because a device can only carry so much. The most capable models need more memory, power, and cooling than a battery-powered body can hold. Every watt costs battery life. Every chip adds cost and weight to every unit. And the chip is fixed the day the device ships, while models keep growing.
So the device runs what fits: small, fast models for the loops that can’t wait. Anything bigger has to run somewhere else. When it does, it can even be faster: in one 2026 robot-arm study, a large model took about 813 milliseconds per decision on the device and about 122 on a server GPU (RAPID). A factory study found that on-robot inference can cost up to 45% of battery life.
The device wins on latency. It loses on capacity.
Model size is moving too. We are starting to see many more small, fast models built for one task, in place of one large general model that does everything slowly. Figure’s Helix pairs an 80-million-parameter model (parameters are a rough measure of model size) that controls motion 200 times a second with a 7-billion-parameter model that understands the scene 7-9 times a second. NVIDIA’s GR00T N1 uses the same two-system design, and Google ships Gemini Robotics On-Device to run without a network. A specialist that answers in 5 milliseconds is often worth more than a generalist that answers in 800. That makes placement a choice per task: the small specialist runs on the device or nearby, and the large generalist gets called for the hard cases.
Edge Is Four Levels, Not Two
The usual debate is “on the device vs. in the cloud.” That is too simple. In my last piece I quoted Cloudflare’s own three-way split: on-device, edge, centralized cloud. For machines that move, it is four levels:
| Device Edge | Local Edge | Cloud Edge | Cloud | |
|---|---|---|---|---|
| Where | On the device | A machine in the same room, house, or site | Many sites close to the device | A few large regions |
| Link | None | Wi-Fi, Bluetooth, cable. No internet | Internet, short path | Internet, long path |
| Network delay | ~0 | ~1-10 ms | ~10-30 ms | ~50-200 ms |
| Compute | Small | Large (a desktop or server GPU) | Very large, shared | Effectively unlimited |
| Works with no internet | Yes | Yes | No | No |
| Idle cost | You pay for the chip even when unused | Same | Shared; pay per use | Shared; pay per use |
| Battery cost to device | High | Radio only | Radio only | Radio only |
You already see Local Edge in VR headsets with a cable to a gaming PC, and in the factory server from the study above: the heavy work runs nearby, but never crosses the internet. Cloud Edge is what Cloudflare runs, with GPUs in more than 200 cities. Cloud is the classic AWS and Google model.
The levels differ in more than speed:
- Idle compute. A chip on the device or a box in the house sits unused most of the day, and you paid for it up front. Shared compute at Cloud Edge or in the Cloud spins up when a task needs it and down when it doesn’t.
- Bursts. When a robot hits a hard problem, it can borrow far more compute than it could ever carry.
- Shared learning. A device alone learns only from itself. Off the device, what one robot learns can reach the whole fleet. A fleet that shares gets smarter faster than a thousand isolated machines.
Device Edge and Local Edge win on reliability and privacy. Cloud Edge and Cloud win on compute, scale, and learning from the whole fleet. Every serious embodied system needs both sides. The value is in the split.
Which Tasks Go Where
Sort tasks by how fast the loop must close:
| Task | Time budget | Level |
|---|---|---|
| Touch feedback, motor control, balance | 1-10 ms | Device Edge |
| VR and AR display update | ~20 ms | Device or Local Edge |
| Remote control of a humanoid or a car | ~50-300 ms | Local or Cloud Edge |
| Fast reasoning at 10 updates a second | ~100 ms | Local or Cloud Edge |
| Voice and conversation | ~1-3 s | Cloud Edge or Cloud |
| Retraining on fleet data | Hours to days | Cloud |
Only the top rows must stay on the device. Everything from about 50 milliseconds up can leave it.
So why not send everything that can leave the device to the Cloud? Because distance and latency still matter, and they will matter more over time.
- The loop has a budget. At ten updates a second, each lap has about 100 milliseconds. A 50-200 millisecond round trip to a distant region eats most or all of that before the model even starts. A 10-30 millisecond trip to Cloud Edge leaves room to think. Remote control, fast reasoning, and live conversation all live in this band.
- Compute shrinks. Distance doesn’t. Today, model time often dominates: hundreds of milliseconds or more. But small specialist models and faster chips cut that every year, toward tens of milliseconds. The speed of light does not improve. As the model gets faster, the network trip becomes the biggest part of the loop. Proximity matters more each year, not less.
- Hops add up. A hop is each service call between the device and the model. Every hop adds its own delay. Cloud Edge can hold the connection, the session state, and the model in one place, close to the device, so the loop pays for distance once.
Others are betting on the same idea. Google ran Stadia, its cloud gaming service, from servers in its edge locations inside internet providers’ networks, because a game is a sense-act loop. Google said it shut Stadia down because it didn’t get the traction it expected, not because the edge didn’t work. T-Mobile is piloting NVIDIA servers with Nokia software at cell sites and switching offices, aimed at physical AI. SoftBank has trialled AI inference on spare 5G capacity. SpaceX has filed for up to a million satellites for AI compute linked to Starlink: a bet on being close to machines that move, not just on more capacity.
Tesla Built Its Own Split
Tesla is the clearest example of the split in production.
The FSD (Full Self-Driving) computer in the car drives with no network at all. That is Device Edge, and it handles the reflex loop. When something rare happens, or when the car’s driving differs from what the human did, the car uploads a clip. Tesla trains on those clips in large GPU clusters: that is Cloud. New models ship back over the air. And the new Cybercab has a Starlink dish built in. Tesla says the car does not need it to drive. It is for navigation, fleet management, and support: the slow loop.
Today’s driving model fits on the car, so Tesla’s split is mostly Device Edge plus Cloud. But the off-device part is growing: an always-on satellite link, remote help, and a fleet that learns together. Tesla decided, task by task, where each piece of compute should sit, and built exactly what its problem needed.
Tesla can build this. A 50-person robot startup cannot. Most of what Tesla built is not specific to cars: device identity, data upload, model shipping, remote help, slow-loop inference, and the logic that decides which level runs which task.
Part III: The Router Cloudflare Should Build
What I Learned Building at Cloud Edge
Tesla shows the split at fleet scale. I ran into it at the scale of one device.
I built Lens, a real-time social coaching app for AI wearables. My test device is a pair of smart glasses, but any wearable with a microphone and a display works. The device listens to a live conversation. The system transcribes speech, notices the moments that matter (a question, a pause, someone trying to connect), runs an LLM with a personal profile of the wearer, and sends a short prompt back while the conversation keeps going.
It is a sense-act loop. Audio streams in every half second. A prompt that arrives after the moment has passed is useless.
The wearable could not run speech-to-text and an LLM itself. Too little compute, too little battery. My first version ran in the Cloud: device to a speech provider, to my app server, to a job queue, to an LLM, and back over a WebSocket. 1.6 to 5.8 seconds. Too slow for a conversation.
So I moved the whole loop to Cloud Edge. One WebSocket (a connection that stays open) from the device to one Durable Object (a small Cloudflare server that holds one session’s state) per session, with speech-to-text and the LLM running inside Cloudflare’s network. 1.2 to 3.0 seconds.
Where did the time go? The network trip to Cloud Edge was 10-30 milliseconds. Model inference was 700-2,500. The big win came from putting everything in one place close to the device: no queue, no calls between providers, state and inference and connection together. And as faster, smaller models cut that 700-2,500, the short network trip is what keeps the loop tight.
Three lessons:
- Latency is distance plus hops plus compute. Cut all three. Compute will keep getting faster; the platform has to remove the rest.
- Streaming AI needs session state next to the model. A stateless function can’t hold a conversation.
- Personal context has to live next to the model, not in a database in another region.
The Gap
Pieces of “the Tesla split for everyone else” already exist. AWS IoT Greengrass and Azure IoT Edge deploy code and models to devices. Robot platforms like Viam and Formant manage fleets.
What nobody sells yet is routing that spans the device and the network, driven by each robot task’s time budget. Greengrass deploys to the device but doesn’t decide per task where inference runs.
Cloudflare already has most of the parts, sold today for web apps and AI agents: Workers AI for inference close to the device, AI Gateway for routing across models, Durable Objects for session state, R2 for fleet data with no egress fees (no charge to move data out), Realtime for live video and audio, and Zero Trust for device identity. What it doesn’t have is the piece that ties them together for machines that move.
A Router That Routes by Location
AI Gateway today decides which provider and which model handle a request. Embodied AI needs a router that also decides where it runs: on the device, on a Local Edge machine if one is nearby, at Cloud Edge, or in the Cloud.
It would decide per task, based on the task’s time budget, the network right now, the device’s battery, cost, privacy rules, and whether the task needs data from the whole fleet. When the network drops, it falls back to the device. When the device is overloaded, it moves work up. It ships as an SDK on the device too, so the router runs at both ends of the link.
In practice:
- The robot maker owns the policy. It declares each task’s time budget and privacy rules. The router enforces them.
- One model family, several sizes. A small specialist on the device, a larger model at Cloud Edge, the largest in the Cloud. The router picks the size that fits the moment.
- State follows the task. A Durable Object holds each device’s session, so work moves between levels without losing context.
Who buys it: robot makers, wearable makers, and fleet operators who can’t build Tesla’s stack. What they pay for: per routed request and per connected device, the same way they already pay for inference and for device management.
Why Cloudflare, and not AWS, Akamai, or NVIDIA? AWS has the compute, but its architecture is a few big regions, and its edge products (Wavelength, Local Zones) are add-ons in a limited set of cities. Akamai is the closest competitor: its AI Grid, launched in March 2026, already routes inference across its edge and core sites by latency and cost. But it stops at the network. It has no device end. NVIDIA sells the chips on both ends and has reasons to stay neutral. Cloudflare already runs AI Gateway, already runs Cloud Edge in more than 200 cities, already has the session state that streaming needs, and already has millions of developers building on Workers. It is best placed to connect all four levels.
Two things follow from the router:
- The Tesla split, for everyone else. Router plus device identity, data upload, model shipping, and remote help, as one platform for any robot or wearable company.
- Partner with telcos, don’t fight them. GPUs at cell sites are one more level the router can send work to. A robot fleet crosses carriers and countries. No single carrier can serve it. A router across all of them can.
What Cloudflare should not do is compete with the hyperscalers on training clusters. Training stays in the Cloud. The opportunity is everything between the device and that cluster.
The Obvious Objection
“Robot makers will build their own.” Tesla did. Most can’t, the same way most companies don’t build their own data centers. And the ones that can will still want a network close to every device they ship.
Enough, and in the Right Place
Physical AI will need far more inference than anything we have built: about 100x within five years, and more after that. But scale alone isn’t the answer. A robot needs enough compute, and it needs that compute in the right place, task by task, at the speed of its loop.
The company that decides where each piece of thinking happens will matter as much as the companies that make the chips or build the robots. Tesla built that layer for itself. Someone will build it for everyone else.
I think it should be Cloudflare.
Sources
Market and production:
- Morgan Stanley: Humanoids, a $5 Trillion Market
- Goldman Sachs: robot market could reach $38B by 2035
- IDC 2025 humanoid shipments (Jiemian)
- TechRepublic: H1 2026 humanoid shipments, Chinese share
- TrendForce: 2026 humanoid forecast
- Figure: ramping Figure 03 production
- Tesla Q1 2026 update
- Tesla Q3 2026 update (SEC 8-K, Ex. 99.1)
- Tesla Q3 2026 earnings call recap (Not a Tesla App)
- World Bank: employment by sector
Device vs. off-device inference:
- RAPID: edge-cloud VLA inference (arXiv 2603.07949)
- Efficient VLA serving for robot factories (arXiv 2609.12075)
- Figure: Helix
- NVIDIA: Isaac GR00T N1
Latency budgets:
- Tactile Internet survey (arXiv 2009.12164)
- 3GPP TR 26.918: VR motion-to-photon
- Teleoperated driving latency (arXiv 2602.17381)
- ExtremControl: low-latency humanoid teleoperation (arXiv 2602.11321)
Fleets, edge, and competitors: