Frequent Self-Driving Accidents: Is the Root Cause Car Companies Using “19th-Century” AI Technology?

Preface: The “physical AI” stacks currently used by all car companies for autonomous driving essentially still rely on 19th-century discrete time steps (Δt) combined with three-dimensional space computations to approximate a continuous physical world. In fact, adopting a continuous time solver could fundamentally solve this problem. But the question is: why are car companies unwilling to use it?

I. What Are 19th-Century Discrete Time Steps + Three-Dimensional Space Computation?

The underlying computational paradigm of all mainstream autonomous driving systems (such as Tesla FSD, Xiaomi NOP, Waymo, etc.) depends on an outdated approach: “discrete time steps” (Δt) plus separate processing of pure 3D space. This originates from 19th-century numerical methods (e.g., the 1883 Adams-Bashforth integration method and the 1895 Runge method), when mathematicians could only slice time into small steps to approximate solutions for continuous physical equations (like motion trajectories).

In simple terms: AI first scans a static 3D world (generating point cloud maps with cameras/LiDAR), then scans again every Δt (typically 0.03–0.1 seconds), comparing frames to guess “something moved.” Space and time are completely separated — like an old-fashioned movie projector: individual static film frames flick by quickly, appearing continuous but essentially a jerky slide show.

The problem lies in the Δt dilemma:

• Δt too large: The world becomes a “slide show,” missing rapid changes (e.g., sudden road narrowing or instant obstacles).
• Δt too small: Computation explodes, overwhelming on-board hardware.

This prevents neural networks from truly “understanding” the continuous physical world, contributing to many accidents — like high-speed collisions with barriers.

Human brains, however, fuse space and time into one, perceiving the world like a smooth high-definition movie and naturally predicting changes.

For example, in autonomous driving:
You’re traveling at 100 km/h (28 m/s) on the highway, and a child suddenly crosses 50 meters ahead. You have less than 2 seconds to react (1.8s). The human brain detects and starts braking in 0.4–0.6 seconds.

But AI must capture many frames, process massive data per frame (multi-camera, high-res 3D point clouds), then run complex networks to judge “That’s a child! Brake!”

Current Tesla systems use ~36 frames/second (Δt ≈ 0.028s), with optimized latency in tens of milliseconds and on-board power ~100–200W — barely real-time.

To capture every subtle motion (e.g., 1–2 ms per frame, 500–1000 fps, approaching human continuous perception), computation could explode 50–100x or more — requiring thousands of watts and 10–50 top data-center GPUs (like NVIDIA H100 at 700W each). Impossible in a car.

In summary, car companies are still using 19th-century “discrete time” to approximate a continuous world.
Human and animal brains natively handle continuous physics. But today’s AI architectures act like 19th-century mechanical calculators — step-by-step discrete approximation. This creates an irreconcilable dilemma: large Δt loses details/accidents; small Δt can’t compute/power explodes.

This is a deep-rooted reason why autonomous driving still has accidents!

II. The Solution Exists: Adopt a Continuous Time Solver

The fix is straightforward — use a Continuous Time Solver, enabling AI to compute directly in continuous space-time rather than discrete frames.

How it works: Time is no longer an external “step” but an intrinsic part of the state. The system adaptively adjusts compute density — sparse and efficient in calm scenarios, automatically dense and precise during intense changes. Result: AI predicts physical trajectories continuously like the human brain, eliminating perception delays and compute explosions.

Details and open-source implementation available in this NVIDIA Developer Forums post:
https://forums.developer.nvidia.com/t/eliminating-tunneling-jitter-in-isaac-sim-without-sub-stepping-or-performance-loss/354859?u=liuzc19761204

III. Why Car Companies Are Unwilling to Adopt It

Continuous time solvers are not science fiction — open-source implementations exist — but car companies have been slow to adopt them. Main challenges include:

-Computational efficiency and data representation convenience: Time discretized into frame sequences (T steps) works well with spatio-temporal attention or convolutions — higher efficiency and easier data handling.

-High refactoring costs: Existing AI stacks (neural networks + sensor fusion) are deeply optimized for discrete modes; switching requires redesigning the entire system.

-Compatibility issues: Current hardware (GPUs/chips) is tuned for frame rates; the new paradigm needs new architectural support.

-Lack of standardization: No industry consensus; companies fear first-mover risks (supply chain compatibility, regulatory certification).

-Short-term interests: Stacking more data + larger models can “get by” at low frame rates — sufficient for marketing “full self-driving.”

These are not insurmountable technical barriers, but rather engineering costs and business considerations.

Conclusion: Governments and Organizations Should Promote Standards to Encourage Continuous Time Solvers and Reduce Accident Tragedies

Autonomous driving was meant to save lives, yet outdated paradigms lead to frequent tragedies.

Governments and international organizations (e.g., NHTSA, EU AI regulatory bodies) should act: establish physical AI safety standards, encourage/require adoption of advanced technologies like continuous time solvers, and drive industry transformation.

Share this article — let’s work together to advance AI safety!

This article is dedicated to tingting. In remembrance of the victims of preventable self-driving accidents.

Author: ZuoCen Liu

2025/12/17