Overshoot and the Race to Give Machines Real-Time Sight
For the last few years, the story of AI vision has been a story about accuracy. Can the model read the sign? Can it count the people in the frame? Can it tell a golden retriever from a mop? The answer, increasingly, is yes. Vision language models can now look at almost any image and describe what they see in fluent, structured detail.
But accuracy was never the whole problem. The other half is timing.
A security model that flags an intruder ninety seconds after they've climbed the fence isn't security. A robot that recognizes the obstacle after it's already collided with it hasn't perceived anything useful. A referee-assist system that calls the play a full second late is worse than no system at all. For an enormous class of applications, the value of seeing something is inseparable from seeing it now—while there's still time to act.
That is the gap Overshoot is built to close.
Overshoot is real-time AI vision infrastructure. It lets a developer point a vision language model at a live video feed and get continuous answers back in as little as 200 milliseconds—faster than human reaction time, and roughly ten times faster than existing inference platforms. As the company puts it: it's the fastest API for real-time vision. And it takes about three lines of code to try.
The Modality Nobody Optimized For
To understand why Overshoot is a distinct kind of infrastructure, you have to appreciate a quiet assumption baked into most of today's AI tooling: everything is built for text.
The dominant model APIs, the inference engines, the batching strategies, the pricing—almost all of it was designed around the shape of a text request. You send a prompt, the model thinks, it streams back tokens, you're done. That request-response rhythm works beautifully for chatbots and copilots. It works terribly for a camera.
Video isn't a prompt. It's a firehose. A single 30-frames-per-second feed is generating new visual information continuously, forever, and the questions you want to ask of it—is anyone at the door? is the part on the conveyor defective? did the ball cross the line?—need to be answered against the stream as it flows, not against a snapshot you happened to upload. Bolting a live feed onto an inference stack designed for one-off image requests means paying encoding, upload, queueing, and generation costs on every single frame. The latency stacks up, and "real time" quietly becomes "eventually."
Overshoot's founding insight is that image and video are fundamentally different modalities from text, and treating them that way is where the performance is hiding. Instead of adapting a text-shaped pipeline to tolerate video, the company rebuilt the path end to end—from the video codec and streaming protocols up through the inference engine itself. The result isn't a marginally faster wrapper around someone else's API. It's a stack engineered from the transport layer up for the specific job of watching.
That's the sort of technical leap that only pays off if you commit to a single modality and refuse to compromise it. Overshoot committed.
Three Lines to a Watching Machine
The clearest way to understand what Overshoot does is to look at how little a developer has to do to use it.
You point it at a video source. You tell it, in plain English, what you're looking for. You get results continuously as the video plays. That's the whole mental model. Under the hood there's a great deal of engineering; on the surface there's a prompt and a callback.
The video source can be almost anything a real application actually uses: a device camera, front or rear facing; a video file; a screen capture; or professional streaming inputs like HLS, RTSP, and LiveKit rooms. That range matters more than it looks. It means Overshoot can sit behind a consumer mobile app pointed at the world, a warehouse camera on an RTSP feed, and a cloud video pipeline running through LiveKit—without the developer re-plumbing anything. The infrastructure meets the video where it already lives.
The instruction is just language. "Read any visible text." "Tell me when a person enters the frame." "Describe what the player is doing." There's no bounding-box schema to define, no custom model to train, no labeling pipeline to stand up. The vision language model handles the open-ended understanding; Overshoot handles getting the video to it and the answer back fast enough to matter.
And the model itself is a choice, not a lock-in. Overshoot exposes what it calls the largest collection of vision language models available for live video, letting developers pick the tradeoff their use case needs—a fast general-purpose model when responsiveness is everything, a text-specialized model when the job is reading a label on a camera feed, a more detail-oriented model when richness beats speed. Swapping between them is a parameter, not a rewrite.
Why 200 Milliseconds Is the Whole Product
It's tempting to file latency under "nice to have." For Overshoot's category, it's the entire proposition.
Two hundred milliseconds is roughly the threshold of human reaction time—the span between a light changing and your foot moving. Deliver a visual judgment inside that window and the machine can participate in events as they unfold rather than narrate them after the fact. Cross above it, and the whole class of live applications quietly falls apart.
Consider what actually needs real-time sight. In physical security and monitoring, the difference between a 200-millisecond alert and a two-second one is the difference between intervening and reviewing footage. In robotics, perception has to close the control loop; a robot that sees late acts late, and acting late in the physical world means knocking things over. In sports and fitness, the analysis is only interesting if it keeps pace with the motion—a form correction that arrives after the rep is a highlight reel, not a coach. In gaming, latency is the experience; a beat of lag is the difference between immersive and broken.
There's also a broad and less flashy category that simply becomes economical when latency and cost both drop: OCR on live camera feeds, retail analytics, structured data extraction pulled continuously from video, and accessibility tools that narrate the world for blind and low-vision users in the moment they need it. Even the homely example the company likes to cite—a video agent that watches your home and your pet while you're out—only works if "watching" happens continuously and cheaply, not as a batch job you review at night.
Every one of these lives or dies on the same axis. Overshoot picked that axis and optimized for it relentlessly. When the product is the latency, being ten times faster than the alternatives isn't a benchmark flex. It's the reason the application exists at all.
Pricing That Matches How Video Actually Works
A subtle but telling design decision sits in how Overshoot charges. It bills by stream duration, not by request count.
This sounds like an accounting footnote and is actually a philosophy. A per-request meter is a text-world artifact—it assumes discrete, countable calls. But a live video agent doesn't make requests; it watches. Trying to price continuous perception as a pile of individual inferences forces developers into awkward contortions, sampling fewer frames to save money and degrading the very responsiveness they came for. By metering the thing that actually maps to usage—how long you're watching—Overshoot aligns its pricing with the shape of the workload. You pay for sight by the second, the way you'd pay for any other stream.
It's the same instinct that made consumption-based pricing the default across modern developer infrastructure. The meter should match the resource. For real-time vision, the resource is time spent looking, and that's exactly what Overshoot charges for. The model also imposes sane operational guardrails—a bounded number of concurrent streams per key, a steady output-token budget per stream—so performance stays predictable as an application scales from one camera to many.
The Founders Behind the Frame Rate
Infrastructure this low-level is a bet on the team building it, because the moat is almost entirely in execution—codec choices, streaming internals, inference-engine tuning, the unglamorous milliseconds. Overshoot's founding pair is unusually well-matched to that fight.
The company was founded in 2025 by Zakaria and Younes El hjouji, cousins with complementary backgrounds that read like a spec sheet for exactly this problem. Zakaria spent seven years building pricing algorithms at Uber—systems that have to be right and fast at enormous scale—and wrote GPU kernels at Meta AI, which is about as close to the metal as machine-learning performance work gets. Younes, the company's CTO, is a former Intel computer vision AI frameworks engineer and was a founding engineer at Cosmonio, where he built a computer-vision training and serving platform from scratch before the company was acquired by Intel.
Put plainly: one founder has spent his career squeezing latency out of GPUs, and the other has already built and shipped a computer-vision serving platform end to end. Real-time vision infrastructure demands exactly that pairing of low-level performance engineering and applied computer-vision systems experience. It's the kind of background you'd assemble on purpose if you set out to make video inference fast.
The early traction is consistent with the thesis. More than 300 developers are already connecting live feeds to models through Overshoot, shipping video agents across gaming, robotics, sports, and security. The company is a Y Combinator company backed by Orange Collective, and it has leaned into developer-first distribution—public SDKs, a hands-on playground, and documentation you can act on in an afternoon—the same open, self-serve motion that tends to win infrastructure categories.
The Layer Being Built
Step back, and Overshoot is a bet on where AI is heading next.
The first wave of generative AI was about language—systems that read and write text. The wave now arriving is multimodal and, increasingly, agentic: software that doesn't just answer questions but perceives environments and acts in them. Agents that navigate screens, robots that manipulate objects, monitors that watch physical spaces, assistants that see what you see. Every one of those systems needs eyes, and eyes are only useful if they work at the speed of the world.
That's the layer Overshoot is claiming. Not another model, and not another vertical application, but the connective infrastructure that turns any vision language model into something that can watch a live feed and respond before the moment is gone. As more of software learns to see, the value of making sight fast, cheap, and three lines away compounds.
The last decade taught machines to recognize what's in a picture. The next one is about letting them keep their eyes open. Overshoot is building the infrastructure for exactly that—and betting that in a world of agents and cameras and robots, the fastest way to see becomes one of the most important calls software makes.