There’s a default architecture for building a live map of the physical world, and it’s expensive on purpose. You buy cameras. You mount them. You run their feeds back to a data center where a rack of GPUs watches every frame, and you pay for that rack whether anything interesting is happening or not. Coverage is a line item: every new intersection you want to see is more hardware, more bandwidth, more compute. The map scales with the budget, and only with the budget.
Thyseus is a live map of detected vehicles, people, and infrastructure, and it’s built the other way around — the cheap way, which turned out to also be the interesting way. It buys no cameras and rents no GPUs. It runs on things that already exist and were already switched on, and getting there meant questioning two assumptions the default architecture never examines.
The cameras are already there
The first assumption is that you need to deploy sensors. You don’t. Point a browser at the public web and there are already thousands of live camera feeds streaming right now — state DOT traffic cameras, port and bridge feeds, city intersection cams — publicly accessible, publicly funded, and mostly watched by no one. The physical sensing layer for a national map already exists. It’s paid for. It’s on.
What’s missing isn’t cameras. It’s attention. A feed nobody is looking at is just bandwidth going nowhere. So the actual problem Thyseus set out to solve was never “how do we see the world” — the world is already on camera — but “how do we look at thousands of feeds at once without building the data center that would normally imply.”
The compute is already there too
That’s the second assumption, and the one that makes the whole thing work: that the watching has to happen on a server you pay for.
Every person who opens Thyseus is sitting in front of a device with a capable GPU that is, at that moment, doing almost nothing. Modern browsers can run a real object-detection model directly on that hardware — WebGL and WebGPU turned the machine you already own into an inference engine, no install, no driver, no account. So Thyseus runs the detection in the contributor’s browser. Their tab pulls a public feed, runs the model on the frames locally, and the server never sees the video at all.
Every open browser tab is a sensor. We didn’t build the sensor network. We noticed it was already assembled, plugged in, and idle, and wrote the software that lets it agree on what it’s seeing.
This is the inversion the product is built on. In the default architecture, compute is centralized and scarce, so coverage costs money. Here compute is distributed and volunteered, so coverage costs interest. Ten people watching feeds is a small map. A thousand people watching feeds is a big one, and the bill to us barely moves, because the expensive part — looking at every frame — is happening on a thousand machines we don’t own and don’t pay for. The map scales with the community, not the budget.
Detections, not video
There’s a detail in there that’s easy to skim past and is actually load-bearing: the browser streams detections, not video. It doesn’t ship frames back to us. It ships the small structured result — a car, here, now, this confident — and throws the pixels away.
That choice pays off three times over. It’s cheap, because a detection is a few bytes where a video stream is megabytes a second. It’s private, because raw footage of public streets never pools up on our servers; the only thing that leaves the contributor’s machine is “something was detected,” not the picture of it. And it’s honest about what a map is for — nobody wants to scrub through a thousand simultaneous video feeds. They want to know what’s where. The detection is the useful part. The frame was just how you got it.
From “on camera 12” to a point on the earth
A detection that only knows which camera saw it isn’t a map, it’s a list. The step that turns Thyseus from a feed aggregator into an actual map is geometry.
Each public camera has a known position and a known view. A detection arrives with a location within the frame — this car is in the lower-left, this far down. Combine the camera’s placement and orientation with where the object sits in its field of view, and you can compute where the object actually is: real latitude and longitude, a pin you can drop on a shared map next to pins computed from hundreds of other feeds. A “car on camera 12” becomes “a car at this corner,” which is the difference between raw footage and situational awareness.
Do that continuously, across every feed every open tab is watching, and the separate cameras stop being separate. They fuse into one surface — a single live map of a region, stitched from feeds that have no idea they’re part of it.
Being honest about the seams
We’d rather show you the seams than pretend there aren’t any, which is the same discipline that keeps code-results from dressing up a correlation as a proof. Thyseus is exactly as live as the tabs that happen to be open. A corner nobody is watching goes dark until someone points a browser at it. Public cameras have their own outages and blind spots. Detection at the edge trades a sliver of accuracy for an enormous gain in reach — a browser model is not a rack of A100s, and we don’t claim it is. These aren’t bugs to hide behind a loading spinner; they’re the honest shape of a map made of volunteered attention, and the contributor leaderboard exists precisely because more attention is the thing that makes the map better.
Why a two-person studio ships something this ambitious
On paper, a live national object-detection map is infrastructure-company work — the kind of thing that usually comes with a warehouse of GPUs and a funding round to pay for them. We took neither, and we could build it anyway for one reason: we refused the architecture that would have required them.
That refusal is a habit, not a one-off. It’s the same instinct behind believing the fastest page is the one already there — the cheapest sensor is the camera already streaming, the cheapest GPU is the one already glowing in a contributor’s laptop. The engineering that mattered wasn’t a bigger machine. It was noticing that the machine was already built, already on, and waiting in a browser tab for someone to write the software that would let all the tabs agree on what they were looking at.
That’s the studio’s whole bet, really, pointed at the physical world instead of a screen: most of what you’d go out and buy is already sitting there, switched on, unused. The product is what you build once you stop trying to own the parts.