@Scale
Mobile decoders routinely misreport hardware capabilities, forcing developers to build defensive runtime fallbacks and autonomous agent loops to prevent creator churn.
AI-assisted summary of Preview Player Reliability and the Agentic Defense Loop on Edits | Bhumi Sabarwal & Ravi Shah — original source. Check the original for full context.
Source published:
Key ideas
- Meta's Edits app launched offensive engineering initiatives that cut unrecoverable playback failure rates by over 80% across platforms—dropping from >2.5% to ~0.38% on Android and 0.25% on iOS. (8:57)
- Android playback stability suffered from OEM decoders misreporting capabilities, which caused 32% of Android decode failures before being addressed via codec leak fixes, smart software fallbacks, and bundled audio decoders. (5:36)
- To prevent feature release regressions, the engineering team introduced Prepmate, an agentic defense loop running parallel sub-agents across diffs, error traces, and A/B experiments to deliver root-cause verdicts with confidence scores. (12:05)
- Rather than fully automating incident response, the defensive system relies on a human in the loop to make final triage calls, such as rolling back an experiment or releasing a targeted fix forward. (13:13)
Detailed notes
## Background Published on YouTube by @Scale on October 30, 2026, this technical presentation features Meta engineers Bhumi Sabarwal and Ravi Shah discussing playback stability and automated triage on the mobile editing suite Edits. No additional show notes or description were provided with the release.
## TL;DR Bhumi Sabarwal and Ravi Shah outline their two-pronged strategy to fix preview player failures in Meta's Edits app, where unrecoverable playback errors initially affected over 2.5% of users. The team first launched an offensive engineering initiative addressing asymmetric platform bottlenecks, deploying recoverable projects, Android decoder fallbacks, and automated iOS AVFoundation composition resets to slash error rates by over 80%. To prevent feature velocity from introducing new regressions, they built Prepmate, an agentic defense system that deploys parallel sub-agents to analyze code diffs, error traces, and A/B experiments before escalating recommendations to a human engineer. Ultimately, they demonstrate that defensive architecture and zero-trust assumptions around low-level hardware decoders directly fuel creator trust and product growth.
## Atmosphere & style The presentation carries a crisp, pragmatic, and deeply technical engineering tone, moving seamlessly between macroeconomic creator stakes and low-level pipeline debugging. Bhumi and Ravi maintain a collaborative, disciplined rhythm, pairing systemic frustration over fragmented OEM decoders with calculated architectural triage. Watching the session feels like sitting in on a candid post-mortem and systems architecture review, blending hard-won mobile media debugging lessons with cutting-edge AI incident automation.
## Bulletin - [08:57](https://www.youtube.com/watch?v=btS_gNt5kEc&t=537s) Meta's Edits app launched offensive engineering initiatives that cut unrecoverable playback failure rates by over 80% across platforms—dropping from >2.5% to ~0.38% on Android and 0.25% on iOS. - [05:36](https://www.youtube.com/watch?v=btS_gNt5kEc&t=336s) Android playback stability suffered from OEM decoders misreporting capabilities, which caused 32% of Android decode failures before being addressed via codec leak fixes, smart software fallbacks, and bundled audio decoders. - [12:05](https://www.youtube.com/watch?v=btS_gNt5kEc&t=725s) To prevent feature release regressions, the engineering team introduced Prepmate, an agentic defense loop running parallel sub-agents across diffs, error traces, and A/B experiments to deliver root-cause verdicts with confidence scores. - [13:13](https://www.youtube.com/watch?v=btS_gNt5kEc&t=793s) Rather than fully automating incident response, the defensive system relies on a human in the loop to make final triage calls, such as rolling back an experiment or releasing a targeted fix forward.
## Key takeaways - [00:05](https://www.youtube.com/watch?v=btS_gNt5kEc&t=5s) Creator tooling reliability is directly tied to retention and livelihood, as 96% of creators earn under $100,000 annually and cannot tolerate broken creative progress. - [00:05](https://www.youtube.com/watch?v=btS_gNt5kEc&t=5s) Roughly 50% of content consumed on Instagram is driven by algorithmic recommendations rather than follower graphs, elevating the importance of raw production quality. - [02:43](https://www.youtube.com/watch?v=btS_gNt5kEc&t=163s) In H2 2025, telemetry showed that over 2.5% of Edits users experienced unrecoverable playback failures across file, codec, and renderer stages. - [05:36](https://www.youtube.com/watch?v=btS_gNt5kEc&t=336s) Failure root causes diverged heavily by platform: Android issues were spread across assets (43%), decoders (34%), and renderers (23%), whereas iOS failures were 93% player-level errors. - [05:36](https://www.youtube.com/watch?v=btS_gNt5kEc&t=336s) Edits introduced recoverable projects so missing or moved assets no longer hard-crash compositions, allowing users to relink or remove missing files directly in the timeline. - [05:36](https://www.youtube.com/watch?v=btS_gNt5kEc&t=336s) A core principle for Android media engineering is assuming lower layers lie about their capabilities, requiring smart runtime fallbacks and resource leak remediation. - [08:57](https://www.youtube.com/watch?v=btS_gNt5kEc&t=537s) On iOS, automatic re-instantiation of AVFoundation composition objects during Apple Media Services resets reduced player errors by 50% and boosted export success by 10%. - [12:05](https://www.youtube.com/watch?v=btS_gNt5kEc&t=725s) Offensive engineering work successfully lowered historical error baselines, but rapid feature velocity introduced continuous regression risks that manual triaging took over a week to resolve. - [13:13](https://www.youtube.com/watch?v=btS_gNt5kEc&t=793s) Prepmate orchestrates parallel AI sub-agents to analyze code diffs, error traces, and running experiments simultaneously when an alert triggers. - [13:13](https://www.youtube.com/watch?v=btS_gNt5kEc&t=793s) Agentic defense systems are bounded by telemetry fidelity, multi-experiment confounding interactions, and production-only regressions that evade pre-production detection. - [14:53](https://www.youtube.com/watch?v=btS_gNt5kEc&t=893s) Player reliability operates as an engagement growth metric, showing direct correlation between playback stability and increased user session activity. - [14:53](https://www.youtube.com/watch?v=btS_gNt5kEc&t=893s) AI acceleration shifts the engineering bottleneck from mechanical trace analysis to navigating semantic ambiguity and complex edge cases.
## Detailed walkthrough ### [00:05](https://www.youtube.com/watch?v=btS_gNt5kEc&t=5s) Why Creator Reliability Matters: The Stakes of Mobile Creation
The creator economy has transformed into a primary source of livelihood for millions around the world, backed by massive macroeconomic growth. Goldman Sachs projections indicate that the creation economy will near half a trillion dollars by 2027. At the same time, platforms like Instagram have shifted heavily toward algorithmic distribution: roughly 50% of the content consumed on Instagram is recommended algorithmically rather than driven by follower graphs. This shift places enormous weight on raw production quality. However, the economic reality for individual creators remains unforgiving, with 96% of creators earning less than $100,000 per year. Because profit margins are exceptionally thin and time is directly tied to income, creators cannot afford tooling issues.
To empower these creators, Meta launched Edits in 2025—a comprehensive, free mobile video editing suite. The app packs over 100 creative tools, supporting projects up to 10 minutes long with watermark-free exports that can be saved locally or shared directly across Instagram and Facebook. Core features include multi-clip timelines, filters, seamless transitions, and a standout AI cutout capability that quickly became a creator favorite, all underpinned by responsive playback and scrubbing.
Yet, creator loyalty in mobile software is fragile. A single playback freeze or unrecoverable error destroys creative progress and breaks user confidence. When a creation tool fails, users abandon the app and migrate to competing suites, directly hurting platform engagement and retention.
> “Reliability is user trust. The creator will come to the app once, but if they notice failures, they will not come again.” — Bhumi Sabarwal
> “You do not get a second chance to be the creator's creation app.” — Bhumi Sabarwal
- Creator economy market projection: Close to $500 billion ($0.5T) by 2027 (Goldman Sachs). - Instagram algorithmic mix: 50% of platform content is algorithmic rather than follower-driven. - Creator earnings: 96% of creators make under $100k annually. - Edits suite specifications: Launched in 2025; 100+ creative tools; supports up to 10-minute projects; watermark-free export across Meta apps and local storage.
---
[02:43](https://www.youtube.com/watch?v=btS_gNt5kEc&t=163s) Inside the Preview Player Architecture and Failure Modes
Bhumi introduces the session roadmap—spanning the internal preview player mechanics, the offensive engineering workstream, the defensive agentic loop, and upcoming roadmap items—before passing the stage to Ravi Shah to dissect the player under the hood.
The Edits preview player is constructed around three primary pipeline stages operating on an input media composition: 1. **Input Validation:** Inspects media compositions, checking asset validity, file availability, and platform read permissions. 2. **Demuxing & Decoding:** Extracts audio/video streams from containers and passes them to hardware or software decoders. 3. **Render & Composite:** Assembles decoded video frames, applies effects/cutouts/transitions, handles timing ranges, and pushes frames to the screen as a fluid preview.
```mermaid flowchart LR accTitle: Edits Preview Player Architecture accDescr: Pipeline showing media composition passing through validation, demux and decode, rendering, and final preview output.
subgraph Pipeline["Player Pipeline"] A["Media Composition"] --> B["Validate Input"] B --> C["Demux & Decode"] C --> D["Render & Composite"] end
D --> E["Preview Frames Display"] ```
When any of these pipeline stages break, the preview player freezes, leaving users stranded with generic "something went wrong" banners. In the second half of 2025 (H2 2025), telemetry revealed that over 2.5% of users experienced completely unrecoverable playback failures when playing videos in the Edits app.
These errors broadly map into three categories: - **File / Asset Errors:** Input validation failures caused by missing media assets, corrupted source files, or file-system permission rejections. - **Codec Errors:** Demuxing and decoding failures triggered by formats incompatible with the target device hardware or decoders misreporting capabilities. - **Renderer Errors:** Composition crashes caused by invalid trim ranges, out-of-bounds frame math, or `NaN` (Not-a-Number) time ranges.
---
[05:36](https://www.youtube.com/watch?v=btS_gNt5kEc&t=336s) Offense Engineering: Diagnosing Platform Asymmetries and Android Codec Pitfalls
To aggressively lower the >2.5% failure rate, the engineering team launched an "offense" workstream targeting root causes across platforms. Telemetry uncovered striking divergences between Android and iOS failure distributions: - On **Android**, failures were broadly distributed: 43% were asset-related (missing files, revoked access permissions), 34% were player/decoder-related, and 23% were renderer-related. - On **iOS**, the profile was heavily skewed: 93% of user failures were player-level errors, while asset errors accounted for only 5%, and renderer errors were virtually negligible at roughly 1%.
The team implemented distinct fixes for each platform's architectural bottlenecks.
#### Fix 1: Recoverable Projects (Asset Handling) Instead of hard-crashing an entire project when a source video was deleted from device storage or moved, Edits introduced "recoverable projects." The app exposes in-line UI enabling creators to directly salvage their composition by either deleting the unresolvable asset reference or relinking/replacing it with a compatible file, preserving the rest of the edit timeline.
#### Fix 2: Android Codec Defenses Android OEMs frequently misreport media decoding capabilities. As Ravi explains: “The device lies about what it can decode.” Android devices presented fragmented decoder configurations, strict concurrency limits, and OEM drivers claiming support for video formats they could not decode in practice, accounting for 32% of Android user decode failures. The team deployed three specific interventions: 1. **Codec Leak Remediation:** Plugged resource leaks where media codecs failed to release hardware instances, yielding a 40% reduction in codec errors. 2. **Smart Codec Fallback:** Dynamically switches between hardware and software decoders based on real-time runtime state, device tier, and format compatibility, driving an additional 22% error reduction. 3. **Bundled Decoders:** Bundled dedicated audio decoders directly alongside video decoding pipelines, cutting decoding failures by another 13%.
---
[08:57](https://www.youtube.com/watch?v=btS_gNt5kEc&t=537s) Fix 3 on iOS: AVFoundation Resets and Massive Platform Gains
On iOS, the dominant failure was the notorious `AVPlayer` / Apple Media Services reset error, where underlying media daemons crash or disconnect, corrupting active `AVFoundation` objects. Rather than failing the session, Edits implemented an automated system that reconstructs the entire media composition from scratch on the fly. When a Media Services reset occurs, the player re-instantiates clean `AVFoundation` objects (`AVAsset`, `AVPlayer`, composition tracks) and feeds a fresh copy of the asset back into the pipeline without user-facing disruption.
This iOS reset mechanism produced outsized wins: - A 50% direct reduction in iOS player errors. - A 2% latency/performance improvement across the timeline playback. - A 10% increase in export success rates. Transcoding pipelines—which perform heavy background rendering during exports—frequently crashed when inheriting degraded or corrupted asset handles; feeding fresh, recreated assets gave export workers significantly more headroom to finish encoding reliably.
Across both mobile platforms, the offensive campaign drove error rates down by more than 80%: - **Android Error Rate:** Reduced by 82%, dropping from >2.5% down to approximately 0.38%. - **iOS Error Rate:** Reduced by 90%, falling from 2.5% down to 0.25%.
> “Offense definitely raises the bar but we also need defense to continuously hold the bar.” — Bhumi Sabarwal
---
[12:05](https://www.youtube.com/watch?v=btS_gNt5kEc&t=725s) Transitioning to Defense: Introducing Prepmate
While the offense workstream successfully knocked down historic baseline errors, rapid feature development introduced a new operational crisis. Rapid product adoption and feature velocity meant an influx of code diffs into every release train. Production regressions spiked, causing fatal SEVs (site events). Manually triaging, identifying culprit commits, and resolving these regressions routinely took more than a week per incident.
To automate incident mitigation and sustain reliability gains, the team engineered **Prepmate**, an agentic defense loop designed around three core operational stages: 1. **Real-Time Detection:** Continuous monitors across pre-production and production channels that fire automated alerts whenever anomaly thresholds are breached. 2. **Parallel Agentic Fan-Out:** Upon alert triggering, the system dispatches three autonomous AI agents simultaneously, powered by custom AI recipes: - *Error Analysis Agent:* Deconstructs stack traces, exception logs, and failure signatures. - *Code Diff Agent:* Analyzes recent repository commits and landing diffs to pinpoint potentially causative changes. - *Experiment Analysis Agent:* Evaluates running feature gates and A/B experiments to isolate regressing test groups. 3. **Synthesis & Mitigation:** Collects findings across all three parallel agents to deliver rapid, actionable diagnostics.
[13:13](https://www.youtube.com/watch?v=btS_gNt5kEc&t=793s) The Agentic Defense Loop: Workflow and Limitations
Bhumi Sabarwal walks through how the agentic defense loop operates when an actual issue occurs in the system. The workflow begins when an alert fires in pre-production. In response, an on-call agent automatically triggers three specialized sub-agents running in parallel: one dedicated to diff search, another performing error analysis, and a third conducting experiment analysis. Once these parallel sub-agents return their findings, the central orchestrator synthesizes and cross-references the data to isolate the root cause. Crucially, the system does not act entirely autonomously without oversight; rather, it produces a verdict accompanied by a confidence score, bringing an engineer into the loop at the very end to decide whether to deallocate the offending experiment or push forward a targeted fix. As Bhumi Sabarwal explains, “Once there is a verdict, it will be sent across with a confidence number and that is the first time the human is involved to take the decision forward.”
```mermaid flowchart TD accTitle: Pre-Production Agentic Defense Loop accDescr: An alert in pre-production triggers an on-call agent which runs three parallel sub-agents before an orchestrator synthesizes the results for human decision-making.
subgraph Detection["Detection Phase"] A["Pre-Production Alert Fires"] --> B["On-Call Agent Triggered"] end
subgraph ParallelAgents["Parallel Sub-Agents"] B --> C1["Diff Search Agent"] B --> C2["Error Analysis Agent"] B --> C3["Experiment Analysis Agent"] end
subgraph Synthesis["Synthesis & Resolution"] C1 --> D["Orchestrator Synthesizes & Cross-References"] C2 --> D C3 --> D D --> E["Verdict with Confidence Number"] E --> F{"Human in the Loop"} F --> G["Deallocate Experiment"] F --> H["Pick Up Fix Forward"] end ```
Despite the efficiency of this multi-agent setup, Bhumi outlines several clear boundaries and operational limitations that prevent full automation. First, the agents are inherently limited by telemetry quality; uninformative stack traces that omit granular error details leave the agents without sufficient signal. Second, there are insidious "slow boiling" regressions that manage to bypass pre-production testing completely and only manifest under the volume and variety of real-world production traffic. Third, complex interactions spanning multiple concurrent experiments can confound the system, making it nearly impossible for an agent to disentangle which specific experiment triggered the regression. Finally, the tool is only as effective as its configuration: if the diagnostic lens and agent specialization are not tailored precisely to the domain, the system will fail to uncover the regression.
- **Trigger:** Pre-production alerts initiate the automated on-call triage loop. - **Parallel processing:** Three sub-agents simultaneously investigate code diffs, error traces, and active experiments. - **Human-in-the-loop validation:** Human intervention is reserved for final decision-making, informed by synthesized root-cause verdicts and confidence ratings. - **Known limitations:** Gaps in trace details, multi-experiment interaction confounds, production-only regressions, and improperly tuned agent lenses.
---
[14:53](https://www.youtube.com/watch?v=btS_gNt5kEc&t=893s) Core Takeaways and Creator Impact
Ravi Shah takes over to summarize the broader architectural and organizational lessons learned from hardening preview player reliability and building the agentic loop on Edits. His first major takeaway is that reliability functions directly as a growth metric; the team observed that as performance and playback stability were systematically resolved, user engagement climbed in tandem. His second principle stems directly from their experiences debugging hardware and lower-level media stacks: always assume that the lower system layers are being untruthful about their operational state. As Ravi Shah puts it, “As we mentioned earlier in our talk that decoder they might claim something but does not work as the same way. So we always assume the layer below is always lying.”
His third takeaway addresses the role of machine learning in engineering operations: AI acceleration does not eliminate bottlenecks, but rather shifts where they sit. While automated agents eliminate massive amounts of manual diffing and trace analysis that engineers struggle to execute quickly at scale, the ultimate bottleneck shifts to handling edge cases and semantic ambiguity, preserving an indispensable role for human engineers. Ravi concludes by highlighting the direct response from content creators using Edits. Creators have felt a clear transformation in day-to-day usability, noting marked gains in speed and preview reliability. This shift has altered product sentiment, elevating Edits into a dependable, mature creative tool where frequent complaints about broken or unplayable videos have largely disappeared.
- **Reliability drives growth:** Resolving playback performance roadblocks led to measurable, sustained increases in user engagement. - **Zero trust for lower layers:** Decoders and platform-level APIs frequently report incorrect states, requiring defensive validation higher up the stack. - **AI shifts the bottleneck:** Automation absorbs mechanical analysis, while humans remain essential for resolving high-ambiguity edge cases. - **Creator sentiment turnaround:** A steep decline in core playback failure reports ("my video is not playing" or "it is broken") has repositioned Edits as an advanced, reliable editing platform.
## Notable quotes > [00:05](https://www.youtube.com/watch?v=btS_gNt5kEc&t=5s) You do not get a second chance to be the creator's creation app. — Bhumi Sabarwal
> [05:36](https://www.youtube.com/watch?v=btS_gNt5kEc&t=336s) The device lies about what it can decode. — Ravi Shah
## Mentioned Bhumi Sabarwal, Ravi Shah, Edits, Meta, Instagram, Facebook, Goldman Sachs, Prepmate, AVFoundation, AVPlayer, Apple Media Services, Android
[Source](https://www.youtube.com/watch?v=btS_gNt5kEc)