Overshoot

Vision-Language Models have unlocked real applications in physical security, safety, gaming, robotics, and consumer products. Soon, video agents will watch your home and your pet when you're away. The model side of that future is already here.

The infrastructure side is not. Developers building real-time vision applications face three compounding problems: slow inference, limited model availability, and infrastructure that breaks at scale.^[13] Existing inference platforms were designed around text — they treat image and video as awkward attachments rather than first-class modalities, and they leave transport, sampling, and stream lifecycle entirely to the developer.

The result: every team building a video agent ends up re-inventing the same stack from WebRTC ingest down through sampling policy and output budgeting. The work isn't novel and it isn't differentiated. It's plumbing — and it's preventing the applications from ever shipping.

Hyperscalers standardized low-latency model I/O. Gemini Live^[1] and OpenAI Realtime^[2] shipped streaming multimodal interfaces in the last 12 months. The model boundary is now a solved problem with documented latency targets.

WebRTC is the de facto transport. WebRTC^[4] and LiveKit^[3] have hardened into the default real-time media stack. Battle-tested SFUs, agents frameworks,^[14] and reconnect semantics now exist — but they're general-purpose, not vision-specific.

The layer in between is still missing. What hasn't been built is the piece that takes a live feed, samples it intelligently against a latency budget, routes it to the right VLM, enforces a schema on the output, and survives jitter. That's the gap Overshoot fills.^{[5] [13]}

Sampled inference by design. Most real-time vision workloads are event-driven, not continuous. Overshoot exposes targetFps, clip length, clip delay, and interval_seconds as explicit parameters — so developers trade thoroughness for latency budget at the API surface rather than discovering the limits in production.^[13]

Model surface and routing. Overshoot hosts the largest collection of Vision-Language Models behind a single API, with a "gemini" passthrough backend when direct model access is preferred.^[1] Schema enforcement supports structured outputs for downstream systems — no parsing, no half-formed JSON, no retries.^[13]

Reliability primitives. Stream lifecycle and reconnect semantics, observability hooks, and latency-aware callbacks keep developers inside their latency budgets even on imperfect networks — the "last mile" work that vision teams otherwise own end-to-end.^[5]

Zero infra headache. Developers connect live video feeds to VLMs with 3 lines of code and get responses in less than 200ms — roughly 10× faster than any existing inference platform. The interface itself is a tell: it exposes the real production constraints, not the demo path.^[13]

Video analytics software is on track from ~$12.7B (2024) to ~$37.8B (2030).^[6] Video surveillance — hardware, software, and services — moves from ~$73.8B to ~$147.7B over the same period.^[7] Computer vision overall: ~$19.8B to ~$58.3B.^[8]

These markets are already monetized. What's changing is how the applications get built. The previous generation required custom models and bespoke deployments per camera per use case. VLMs collapse that to a prompt — but only if the infrastructure underneath can handle live streams. Overshoot is the developer-infrastructure category that makes the next generation of these applications buildable in days instead of quarters.

Streaming workloads are event/sampling-driven, not continuous 24/7 — even when the camera is always on. AWS's Rekognition Streaming Video Events architecture and per-minute pricing^[9] is the existence proof: revenue scales with minutes analyzed, not wall-clock stream time. Overshoot's event-driven sampling design lines up directly with that billing shape, which means margin discipline is built into the product, not bolted on.

Initial ICPs: physical security and monitoring, QA and inspection, robotics and tele-operations, and interactive consumer products. The common thread: latency is a hard requirement, cameras or WebRTC sources already exist, and the application logic is "show the VLM what's happening, structure the response, act on it."^{[1] [2]}

Company materials cite 1,000+ developers engaged with the platform at YC W26 launch.^[13] Public docs lead with the "3 lines to live video → VLM" demo and LiveKit room ingest.^[3] Responses arrive in under 200ms — roughly 10× faster than existing inference platforms for comparable workloads.

Early adoption is concentrated in the ICPs the product is built for: video agents in gaming, robotics, and physical security. The interface itself is a tell — sampling knobs, output token budgets, latency callbacks. This is what an API designed by people who have run video inference at scale looks like, not what a demo path looks like.^[13]