When real-time generative models fail, software engineers rarely get the luxury of a clean back-end patch. At VB Transform 2026, Ryan Phillips, head of enterprise product at Runway ML, shared a story that every security & compliance analyst operating in cloud environments ought to examine closely.
Runway was building Runway Characters, a model designed for zero-latency, interactive AI avatars. Half a decade ago, producing synthetic video with low framerates and garbled text took digital artists hundreds of hours of manual frame stitching. Today, foundation models stream interactive video on the fly. But getting that real-time performance to production grade meant pushing model optimization to its physical and architectural limits—and that was where the trouble started.
When AI Avatars Drift: Front-End Hacks and Model Flaws
To deliver interactive video at speed, Runway couldn't just run a massive, resource-heavy foundation model. They had to compress it. The engineering team relied on distillation, training a smaller "student" model to imitate the larger "teacher" model. That single architectural step sliced generation latency by 80% to 90%.
To recover the visual crispness lost during distillation, Runway applied adversarial post-training (APT), forcing the distilled student model to continuously compete against an adversarial system built specifically to expose its weaknesses.
+-------------------+ +-------------------+ +-------------------+
| Teacher Model | -----> | Student Model | -----> | Adversarial |
| (Foundation Base) | | (Distillation) | | Post-Training APT |
+-------------------+ +-------------------+ +-------------------+
|
v
[Avatar Drift Bug]
|
v
[UX Workaround Feature:
"Optimize Image Quality"]
The compression worked, but it introduced a bizarre failure mode: generated avatars began swaying and drifting off-center during real-time video sessions.
Runway's engineering team spent weeks hunting down a model patch to fix the drift. Nothing stuck. During testing, however, they noticed something interesting. Whenever a user uploaded an input image that was already perfectly centered, the off-center drifting vanished entirely.
Rather than sinking another month into model retraining, Runway pivoted. They built a front-end feature called "Optimize for Image Quality." The tool silently re-centered and cropped the user's input image before passing it to the neural network. To the customer, it felt like an intuitive image enhancement toggle. Under the hood, it was a practical workaround for an unresolved model limitation, proving how critical practical boundaries are when going beyond AI video hype.
Why a Security & Compliance Analyst Cares About Distillation and APT
If you work as a security & compliance analyst managing cloud workloads or audit pipelines, Runway's avatar drift is more than just a clever UX trick. It reveals a fundamental truth about modern AI infrastructure: non-deterministic systems fail in subtle, cumulative ways.
Whether you are configuring rules in a security & compliance center office 365 environment, running backup verification through a security & compliance analyzer veeam integration, or auditing automated workflows, unpredictable model drift presents a major governance challenge.
When enterprise applications distill large foundation models down to smaller edge deployment units, safety alignment and boundary controls can warp—a risk echoed in recent findings on frontier AI agent breaches. Adversarial post-training might restore image sharpness, but it can also introduce unexpected behavioral drift.
Modern AI Failure Taxonomy
┌─────────────────────────┬──────────────────────────────────┬─────────────────────────────┐
│ Distillation Flaws │ Observability Anomalies │ Operational Risk │
├─────────────────────────┼──────────────────────────────────┼─────────────────────────────┤
│ • Loss of boundary rules│ • Frame rate drops (24 to 16 fps)│ • "Failure hell" stalls │
│ • Off-center spatial │ • Regional data center anomalies │ • Workaround-driven feature │
│ avatar drift │ • Hardware degradation (GPUs) │ debt in production │
└─────────────────────────┴──────────────────────────────────┴─────────────────────────────┘
For compliance teams, understanding these architectural shifts is essential. When an AI pipeline changes its spatial or logical orientation, input sanitization and boundary enforcement must step in. Runway solved their drift by constraining input parameters on the front end. In security operations, wrapping non-deterministic models inside strict input validation boundaries is often the only way to maintain a reliable defense.
Excel Spreadsheets, LLM Judges, and Non-Human Edge Cases
Building a reliable evaluation pipeline for non-deterministic output requires ruthless standardization. Phillips explained that Runway defines quality through cross-functional workshops involving product managers, designers, researchers, and sales teams. Everyone must agree on what constitutes a hard failure.
To test extreme boundaries, Runway developed edge-case test sets. One test character, named "Tooth," is a non-human avatar with no nose and abnormal facial structure. Testing against "Tooth" ensures the model maintains stability even when user inputs deviate wildly from standard human proportions.
Runway Quality Evaluation Loop
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐
│ Cross-Team Evals│ ──> │ Edge Case Sets │ ──> │ LLM Automated │ ──> │ Excel Tracking │
│ (Product/Sales) │ │ ("Tooth" Avatar) │ │ Visual Grading │ │ (Daily Pass Rate)│
└──────────────────┘ └──────────────────┘ └──────────────────┘ └──────────────────┘
Grading is strict. In one test run, an avatar's face generated perfectly, but a background net began morphing slightly. The team marked the entire generation as a failure.
To track these daily tests, Runway doesn't rely on bloated enterprise suites. They track failure rates in a simple Excel spreadsheet, setting strict percentage thresholds before any model code hits production.
For high-volume operations where human review creates a bottleneck, Runway uses LLMs as automated judges. By supplying the evaluator LLM with behind-the-scenes contextual data—such as structural layout sketches or reference ads—the judge model evaluates visual morphing and structural defects automatically.
Hardware Failure Hell: Replacing GPUs in US-East-1
Delivering 24 frames per second real-time interactive video requires tight integration across the entire hardware stack, including parallel decoding, custom caching, and low-level GPU kernel adjustments developed with partners like Nvidia.
Shortly after launching Runway Characters, telemetry flagged an anomaly: 8% of API calls dropped from 24 frames per second to 16 frames per second, causing severe video stuttering for enterprise clients.
Tracing the bottleneck required an advanced observability stack. Runway deployed an automated AI agent powered by Claude, paired with observability tools like Datadog and Sentry. The investigation isolated the degraded performance to a single data center in the us-east-1 cloud region.
Infrastructure Incident Tracing
┌─────────────────────────┐ ┌─────────────────────────┐ ┌─────────────────────────┐
│ 8% API Calls Stuttering │ ──> │ AI Agent (Claude) + │ ──> │ Physical Hardware Fault │
│ (24 fps -> 16 fps) │ │ Datadog & Sentry │ │ in AWS us-east-1 │
└─────────────────────────┘ └─────────────────────────┘ └─────────────────────────┘
│
v
[Physical GPU Replacement]
The resolution wasn't a software patch or a configuration tweak. The physical GPUs in that us-east-1 facility had degraded and needed physical replacement.
For any enterprise team building a cloud security incident response playbook or auditing autonomous AI threats in AWS environments, this hardware incident offers a vital lesson. Software telemetry can mask physical hardware failure as model degradation. When real-time pipelines drop frames or misbehave, incident response plans must account for raw silicon performance, regional cloud infrastructure, and hardware-level telemetry.
From Incident Response Playbooks to World-Building Workflows
Pushing real-time AI into production inevitably involves navigating what Phillips called "failure hell"—extended periods where engineering teams hit wall after wall with no immediate breakthrough in sight. Iterating through that friction is often the only way to reach exponential performance gains.
As real-time video models and autonomous agents mature, the daily responsibilities of technical teams are shifting. Designers and security analysts alike are moving away from reviewing static individual assets. Instead, they are defining baseline parameters, operational rules, and aesthetic boundaries inside which autonomous systems operate 365 days a year.
Whether you are configuring enterprise guardrails, managing machine identities, or auditing model behavior, the core principle remains unchanged: when the underlying model cannot be patched, secure the inputs, monitor the hardware, and build guardrails around the experience.
