The vehicle is solved. The remaining failures are not vehicle failures.
A Waymo enters a flooded San Francisco intersection that several human drivers — and several other Waymos from the same fleet — had already routed around. A Cruise pulls over and drags a pedestrian whose legs were visible in its left-side camera. A fleet of robotaxis circles a residential SoMa neighborhood at 4 a.m. honking at each other in a parking lot, after a software patch had supposedly fixed it. Multiple vehicles get stuck at the same construction zone, hour after hour, while every passing human driver navigates it without confusion.
Read these incidents as failures of individual vehicles and you'll conclude that the perception stack needs more training, the policy needs more edge cases, the patch process needs more rigor. Read them as failures of coordination above the vehicle and you'll see what's actually going on.
Each vehicle is doing its job. The network has no job.
That is the single observation that explains the current pattern of robotaxi failures, the current operational suspensions, the regulator scrutiny, and the public sentiment trajectory. It also explains where the next billion dollars of value in the AV market is going to live — and which companies are going to capture it. Hint: it's not the companies that have spent the last decade making one vehicle smarter. It's the coordination layer above them.
This post is about that layer. Why it doesn't exist yet. Why it has to. What changes when it does. And why this is the rare AV market opportunity that doesn't require the underlying autonomy to improve — only the architecture above it.
Why each vehicle's autonomy can be right and the network still wrong
Consider what a single AV actually knows about its environment. It knows what its sensors see, in real time, within their effective range. It knows the high-definition map of the city it was trained on, updated on whatever cadence the operator pushes. It knows its current routing instructions from its centralized fleet management system. It does not know what other vehicles in its own fleet are observing, learning, or struggling with — in real time — except through whatever coarse fleet-wide policy updates the operator pushes out, typically as software-update cycles measured in days or weeks.
When the first Waymo of the morning encounters a flooded intersection, it makes a decision (route around it, fail safe, or commit and hope the puddle is shallow). That decision becomes a data point in some analytics pipeline at the operator. The data point will, eventually, inform a future OTA update. Maybe. What it does not do is propagate, in real time, to the second Waymo arriving at the same intersection ten minutes later — which encounters the same flooded intersection as if for the first time, makes the same decision, and produces the same data point. The third Waymo does it again. The fourth Waymo, too.
Meanwhile, human drivers have collectively learned about the flood within minutes — through Waze, through the radio, through visible brake lights, through their own observation of the cars in front of them. The flooded intersection becomes an avoided node in the human-driver routing graph almost immediately. The robotaxi fleet does not have the same property because the robotaxi fleet does not have a shared field.
The same architecture absence explains the residential circling. Each vehicle in the dispatch queue, given an "await next ride" instruction, defaults to a circling pattern in its locally-known map. None of them knows which other vehicles in the fleet are also circling nearby, what density of vehicles the neighborhood currently has, or whether the neighborhood's residents are filing complaints. So the fleet produces emergent behavior that no individual vehicle wanted, that the operator didn't intend, and that no architectural element can correct because there is no architectural element at the fleet level that exists to be corrected.
Construction zones are the cleanest illustration. The first vehicle to enter the new construction pattern at a particular site encounters cones, an unexpected traffic flow, and an ambiguous detour. It does its best, gets confused, takes 20 minutes longer than the planned route, and emerges. That experience is gone the moment the vehicle clears the zone. The next vehicle of the same fleet, arriving at the same construction zone an hour later, has no benefit from the prior vehicle's encounter. It enters the same zone, gets confused the same way, takes 20 minutes longer the same way. The vehicle's local autonomy keeps the vehicle safe. The fleet has no mechanism to keep the operation efficient.
This is the network problem. It is not a vehicle problem.
What the network architecture has to look like
The argument generalizes. A fleet of N vehicles produces N × experience per unit time. The fleet's marginal value over a single vehicle should be that the experience compounds — the second vehicle benefits from what the first one learned, the third from the first two, and so on. Today, the experience does not compound, because there is no architectural element where compounding could happen.
A shared semantic field is the architectural element where compounding happens. It is a persistent, queryable, time-decaying coordination state that every vehicle in the fleet reads from and writes to. The first Waymo of the morning that turns around at a flooded intersection writes a structured claim into the field: "flooded condition, intersection X, observed at 06:14, traction-loss tier 2, fleet-recommendation re-route." Every other Waymo in the fleet, when planning a route that would pass through that intersection, queries the field. The reroute happens before the second vehicle ever arrives. The third vehicle, too. The flooded intersection becomes a known-avoid node for the fleet within minutes — because the field treated the first vehicle's experience as a fleet-level observation rather than a private one.
The construction zone is the same architecture. The first vehicle to navigate the new pattern writes its experience into the field: cones at coordinates X1-X3, detour to lane 2, anticipated 14-minute time penalty. The second vehicle approaches the zone with that prior context. It enters more decisively, navigates the detour without confusion, and writes its own confirming observation back into the field, strengthening the claim. By the fifth vehicle, the construction zone is a structured, validated, time-decaying entry in the field. Confused circling at construction zones collapses to a one-time learning event for the fleet.
Emergency-vehicle priority is the same architecture, run in reverse. The 911 dispatch system enters a structured priority signal into the field: "EMS routing, corridor X, priority window 14:32-14:47, downstream vehicles clear right lane." Every AV in the relevant geographic region, before the siren is audible, has the field-level intent to clear that corridor. The lane-clearing happens proactively, not reactively. Secondary collisions from confused autonomous behavior in the presence of emergency vehicles — a well-documented failure mode — measurably drop, because the fleet was given operational intent rather than left to interpret a sound and a strobe in real time.
Civic infrastructure becomes a first-class participant. Public works enters a road closure into the field; every AV in the fleet routes around it before any individual vehicle has encountered it. Weather services enter a flash flood warning into the field; the fleet reroutes before the warning would have made it to a centralized weather API. Construction permitting enters a zone; the fleet has it the moment the permit is approved. Curb-management policy ("no pickups in this residential zone after 22:00") becomes a hard constraint in the field that every dispatch query has to honor, eliminating the residential-circling failure mode without any vehicle needing to be smarter.
The vehicle does not get smarter. The city gets smarter — because the fleet, the civic infrastructure, the emergency services, and the weather services are all writing to the same field.
Cross-fleet, cross-vendor, without anyone surrendering proprietary autonomy
A reasonable objection: no robotaxi operator is going to share its internal sensing, planning, or training data with a competitor. Cruise is not going to feed Waymo's training pipeline. Zoox is not going to expose its perception architecture to Tesla. Multi-fleet coordination cannot rest on operators surrendering competitive moat.
The architecture answers this directly. The shared field is not the operators' autonomy stacks. The shared field is the coordination state above them. Operators contribute structured semantic observations — flooded intersections, construction patterns, emergency-vehicle routing, route blockages — without exposing the perception or planning machinery that produced those observations. The field is the abstraction layer; the autonomy stays proprietary. Operators read the field's claims and condition their own routing behavior on what the field says.
This is exactly the abstraction layer needed to make cross-fleet coordination possible without requiring cross-fleet integration of the underlying autonomy. Each operator's vehicles contribute observations through a standardized claim format. Each operator's vehicles consume observations through the same format. The field knows nothing about how Waymo classifies pedestrians or how Cruise plans pull-overs. The field knows only the operational claims and constraints both operators have written into it.
For cities, this is the only architecture that ever produces a coherent civic operational picture. The city does not run on one fleet. The city runs on multiple operators, public-safety agencies, public-works contractors, weather services, and infrastructure owners — all of whom have to coordinate. The field is the substrate that makes that coordination structurally possible without requiring any party to give up internal autonomy.
(We've written separately about the architectural mechanism of stigmergy-based coordination and why it has the structural properties that make this work.)
Regulator-grade evidence as a property of the field
Every routing decision, every constraint enforcement, every operator override is captured in the field as a signed evidence event. When the NHTSA or a local regulator asks what happened at a specific intersection at a specific time, the answer is a query against the field — not a months-long forensic reconstruction across the operator's internal systems.
This matters more than it sounds like it should. The Cruise wind-down was partly a regulatory failure. The Quinn Emanuel report explicitly named lack of accountability and transparency to government and the public as causes. The architecture that produces signed evidence as a property of the data structure removes the entire class of regulatory failure mode that came from "we'll get back to you with the data" delays. The data is the data. The signatures are the signatures. The chain is the chain. The audit is a query.
For an industry that is going to spend the next decade under increasing regulatory scrutiny, this is the wrong cost to keep paying. Every operator that is currently relying on internal post-hoc reconstruction is one incident away from a regulatory crisis. The architecture that makes evidence a first-class element of the substrate is the architecture that survives that crisis.
We've written more about evidence-grade autonomy as a security and compliance property, because it's the same architecture that defense and infrastructure customers need.
What this is worth
The current generation of robotaxi failures is the failure of single-vehicle autonomy in the absence of a coordination layer. The next generation of robotaxi success requires the coordination layer to exist. The companies that build it own the next phase of the industry. The companies that don't are going to keep adding sensors to vehicles that the network problem will keep defeating.
For fleet operators, the unit economics are direct. Lower incident rate (cross-vehicle learning shared in the field rather than waiting for next OTA): typically 0.3× of baseline incidents per million miles in coordinated deployments versus uncoordinated baselines. Lower weather-event reroute latency (first vehicle's observation becomes every vehicle's input): from ~45 minutes in centralized-weather architectures to ~2 minutes in field-coordinated architectures.
For cities, the value is operational — predictable autonomous behavior that respects civic priorities, faster reaction to emergencies, structurally less neighborhood disruption — and political. The pattern of community pushback against robotaxis is largely the pattern of "the fleet does not respect the neighborhood." The field architecture is the one that allows the neighborhood to be respected, because the neighborhood's policy becomes a first-class entry in the substrate.
For regulators, the architecture is the answer to the audit-and-evidence question every recent investigation has surfaced. Signed evidence as a property of the substrate is what makes regulatory oversight tractable at the scale autonomous fleets are heading toward.
Where this goes next
Cascade Dynamics is building the coordination layer above autonomous vehicles. The same architecture that runs defense ISR, that runs wildfire perimeter coordination, that runs industrial inspection at scale, runs the urban mobility coordination problem. The substrate is the same. The semantic field, the policy runtime, the signed-evidence chain, the heterogeneous fleet integration. Different vehicles, different vendors, different operators, different agencies — same architecture.
The deployment posture for mobility starts with single-fleet coordination (one operator's vehicles sharing experience through the field), expands to civic infrastructure participation (emergency services, weather, construction, traffic management as first-class field contributors), and then to multi-fleet (multiple operators, multiple vendors, multiple modes, all coordinating through the same field while preserving proprietary autonomy).
The current Cascade product is live and shipping the coordination architecture; the mobility deployment is the natural extension and the most public-impact application. If you operate a fleet, run dispatch for a public-safety service, manage civic infrastructure that would benefit from being a field participant, or work in regulatory oversight of autonomous mobility — come talk to us.
The next mile is not perception.
It is coordination.