Introducing the Future of Streaming: MOCK (Media Over Conjectural Kinetics) 

Our team has made tremendous progress with our MOQ (Media over QUIC) implementation over the last year. Now that we are set to go live on Red5 Cloud with globally distributed MOQ relays running on CacheFly, we are now ready to discuss what’s coming next. If any of you have followed how quickly we like to move and stay on top of the latest in streaming technology, you know that we simply can’t just stand still. 

It so turns out that in parallel with our MOQ development and innovative AI VLM (Visual Language Model) work, we’ve been spending years of rigorous research where we’ve developed a completely new approach to video delivery. We’re proud to unveil MOCK — a groundbreaking protocol that redefines live media delivery using a surprisingly simple Newtonian physics equation.

We’ve spent years moving bits over UDP based protocols like RTP, and QUIC, but what wasn’t as obvious on the surface was that we weren’t looking at the actual movement of these bits. It turns out that applying one of the simplest physics concepts to bit delivery is the answer. 

Watch my short talk on this topic on YouTube.

MOCK: A Kinetic Model for Packetized Media Transport

At the core of MOCK is a reinterpretation of packet transport not as discrete transmission events, but as continuous kinetic systems operating across a probabilistic network field.

Traditional protocols such as RTP over UDP or QUIC treat packets as atomic units subject to routing, buffering, and retransmission. MOCK instead models each media fragment as a kinetic particle, assigning it “mass” and “velocity” within a dynamically shifting transport medium.

This allows us to apply the classical equation:

KE = ½mv²

Where:

• m (mass) represents the encoded complexity of a media fragment
  (bitrate density × entropy coefficient × frame dependency index)
• v (velocity) represents propagation speed across the network
  (inverse latency gradient adjusted for congestion vectors)

The Conjectural Kinetics Layer (CKL)

MOCK introduces a new transport abstraction: the Conjectural Kinetics Layer (CKL), which sits above QUIC but below application-level streaming logic.

Rather than transmitting packets, CKL computes trajectory envelopes for media particles. These envelopes predict the most probable path a packet would have taken, allowing endpoints to reconstruct streams even before full delivery is completed.

Key components include:

• Inertial Buffering
  Replaces traditional jitter buffers by maintaining momentum continuity across frames. Instead of waiting for late packets, CKL extrapolates their expected arrival vector and pre-renders frames accordingly.
• Mass Rebalancing (MRB)
  Dynamically adjusts packet “mass” to prioritize perceptual importance. I-frames carry significantly higher “mass” than B-frames, ensuring higher kinetic persistence under network turbulence.
• Velocity Shaping (VS)
  Applies micro-adjustments to packet velocity based on real-time congestion gradients, effectively “steering” media flows through lower-resistance network paths.

Extremely Low Latency Through Predictive Momentum

One of the most significant breakthroughs in MOCK is its ability to achieve perceptual negative latency.

By combining CKL trajectory modeling with AI-assisted inference (leveraging our internal VLM pipelines), MOCK predicts the future state of a stream based on motion vectors, scene transitions, and user interaction patterns.

Instead of waiting for packets to arrive, clients reconstruct frames using projected kinetic states, then reconcile with actual packets upon arrival. This creates the effect of:

• Playback beginning before transmission completes.
• Seamless continuity even under extreme packet loss.
• Near-zero startup delay across global distances.

The main issue we ran into in our initial tests is that to run the prediction algorithm on pure CPU proved to be too taxing, so instead we ended up rewriting the system to run on NVIDIA’s CUDA platform allowing us to predetermine the motion vectors, scene transitions, etc. with a dedicated GPU. Probably the most interesting thing about the use of the GPU in this way is that it also opens up the possibilities of running additional learning algorithms that can further optimize the predictions theoretically creating true negative latency.

Once we had locked down our approach to our predictive algorithm, we then realized we needed to solve for stabilization of the stream state.

Entropy-Normalized Bit Mass (ENBM)

To stabilize the system, MOCK introduces Entropy-Normalized Bit Mass (ENBM), a derived metric that ensures consistent kinetic behavior across varying codecs and resolutions.

ENBM is calculated as:

ENBM = (bits × entropy) / temporal coherence

This normalization allows MOCK to:

• Maintain consistent “mass” across H.264, HEVC, VP9, AV1, and emerging codecs.
• Optimize transport for both high-motion sports and low-motion talking heads.
• Eliminate traditional ABR ladder switching in favor of continuous kinetic scaling.

Transport Field Dynamics

Unlike static routing, MOCK treats the network as a dynamic field of resistance and acceleration.

Each edge node contributes to a shared field model that includes:

• Congestion vectors (directional packet pressure).
• Latency gradients (spatial delay differentials).
• Thermal noise factors (randomized packet loss behavior).

Using this model, CKL continuously recalculates optimal trajectories, allowing packets to “flow” rather than route.

This is particularly effective when deployed across globally distributed relays such as those running on CacheFly, where edge proximity and density amplify field accuracy.

Why MOCK Matters

By reframing media delivery as a kinetic system rather than a transactional one, MOCK fundamentally changes how we think about real-time streaming:

• No more discrete packet retries — only trajectory correction.
• No buffering — only momentum continuity.
• No bitrate switching — only mass redistribution.

The result is a system that behaves less like a network protocol and more like a physical law.

Final Thoughts

MOCK represents a fundamental shift in how we think about media transport—not as packets moving through a network, but as energy propagating through a dynamic system. While it challenges long-held assumptions about delivery, buffering, and latency, the early results are difficult to ignore.

We’re actively exploring how MOCK can integrate alongside our existing MOQ and WebRTC workflows, and we look forward to sharing more as the research evolves.

As a company dedicated to open-source development and supporting our great community of developers, we plan to release our early research and implementation under an Apache 2 license. We are profoundly excited about welcoming your contributions to the future of MOCK. Stay tuned for the release in the near future, or get in touch sooner if you think you can contribute.