Topic

MLOps

All digests tagged MLOps

· 17:31

The Messy Reality of Scale: Synthetic Data and Pre-Training — Marah Abdin & Robert McHardy, poolside

The presentation details how poolside scaled their LLM training from smaller models (Laguna M/XS) to a massive 118 billion parameter model for agentic coding. The core strategy involves creating sophisticated synthetic data pipelines—which complement organic data by exposing implicit rationale and structure—and implementing extreme rigor in the pre-training process. Key technical challenges addressed include catching silent failures like broken GPUs, numerical precision loss during tensor parallel accumulation (BF16 to FP32 fixes), and race conditions via weight hashing checks. The resulting model, Laguna S, demonstrates competitive performance against industry leaders on coding benchmarks.

Key takeaways

  1. Synthetic Data for Feature Extraction 10:37

    Synthetic data is used not to replace organic data but to complement it by extracting and projecting implicitly hidden features (e.g., implicit rationale, planning, structure). Pipelines are modular, allowing complex tasks to be broken down into stages like multi-stage workflows, cross-domain porting (e.g., math problems to code), or multi-turn chats.

  2. Rigorous Training Validation: Trust Nothing 15:03

    To ensure correctness at scale, the team implemented model replica hashing checks; if hashes over weights do not match across distributed replicas, training is immediately halted. Failures observed include silent data corruption from broken GPUs and gradient corruption due to race conditions.

  3. Scaling Success: The 118B Parameter Model

    The final model, Laguna S (118B parameters), was trained on 30 trillion tokens across 4,000 GPUs. Early results show strong performance in agentic coding benchmarks (e.g., SWEETbench), outperforming models like GLM 4.5 Air.

Watch on YouTube Full article

· 21:39

Building Closed-Loop Evals for a Multimodal Agent at Scale — Soumya Gupta & Jai Chopra, Uber

Uber detailed its approach to building closed-loop evaluation systems for a multimodal agent designed to enhance food photography on Uber Eats. The system addresses the challenge of improving image quality at massive scale (90 billion run rate/year) while preserving merchant authenticity and avoiding homogenization. The architecture involves an end-to-end pipeline incorporating Image Understanding/Routing agents, iterative Image Editing agents, multi-dimensional QA gates, and sophisticated continuous learning loops that detect drift and auto-tune the system without human intervention.

Key takeaways

  1. Closed-Loop System Design 17:07

    The system operates on a closed feedback loop: production data is sampled, compared against human labels (golden source of truth), mismatches are diagnosed by an 'Umbrella Diagnosis Agent,' and the auto-tuning pipeline adjusts agent configurations. This process ensures continuous improvement without requiring constant human intervention.

  2. Handling Model Drift 20:03

    To prevent static models from failing in a live environment, the system uses production data sampling to detect drift. The 'Diagnoser' agent localizes the issue and triggers an auto-tuning pipeline that benchmarks against the golden dataset before deployment.

  3. Evaluation Metrics for Agents 21:05

    For routing agents, evaluation involves measuring precision and recall using a confusion matrix (potentially an N x N matrix if multiple branching paths exist). For the enhancement process, 'Pass at K' measures the pass rate after K iterations of refinement.

Watch on YouTube Full article

· 1:12:03

Coding Agents Are Secretly General Agents

The discussion posits that coding agents are inherently generalist, meaning proficiency in code translates into superior performance across all knowledge work tasks due to a concept called 'positive transfer.' The future of knowledge work is converging on single, integrated platforms (Systems of Record) that provide comprehensive context and surfaces for agent interaction. Key technical advancements include using verifiable code execution environments (like unit testing/linting) as the perfect training ground for agents, leading to autonomous workflows like ticket-to-pull request cycles.

Key takeaways

  1. Coding Agents are Generalist Agents 22:00

    The core thesis is that improving an agent's ability to write and execute code makes it better at everything else. This 'positive transfer' capability means agents with coding skills are effectively AGI-complete, as they can write their own tools and interact with various systems.

  2. Verifiability is Key for Agent Training 17:15

    Code provides an ideal training ground because its output (e.g., a function, schema) can be programmatically verified (linted or passed through unit tests). This verifiable feedback loop allows agents to learn and refine their performance iteratively, which is crucial for autonomous workflows.

  3. Convergence of Platforms Wins 23:40

    The most successful platforms will be those that achieve convergence—integrating context, surfaces, and unit economics into a single system (a 'System of Record'). Fragmentation (e.g., Slack's data walls) is identified as the primary enemy to agentic workflow adoption.

  4. The Future is Autonomous Knowledge Work 26:40

    The trend suggests that much of today's office work will be handled by agents. This shift means platforms must evolve from being communication hubs (like Slack) to becoming the central operational layer where all data and tasks reside.

Watch on YouTube Full article

· 46:40

Logs Are All You Need: Rethinking Observability with AI Agents

Sherwood Callaway introduces Sazabi, an AI-native observability platform designed to disrupt traditional tools like Datadog by focusing on logs as the primary source of truth. The core philosophy is that in the age of coding agents, engineers should interact with production data via natural language chat rather than complex dashboards. Key technical innovations include using Git for persistent agent memory across multiple threads and implementing a read-only sandbox environment to safely execute investigative tasks.

Key takeaways

  1. Logs are Sufficient: Rethinking Observability 22:20

    The traditional 'three pillars' (metrics, logs, traces) are considered overkill for modern agentic workflows. By focusing solely on logs, instrumentation becomes significantly simpler, requiring only basic logging statements, as the platform can reconstruct metrics and traces from log data.

  2. AI Agents Generate Alerts, They Don't Evaluate Them 28:00

    Instead of using AI to triage noisy alerts (alert fatigue), Sazabi autonomously generates actionable alerts directly from logs and codebase analysis. The agent determines what is meaningful to the user at runtime.

  3. Agent Memory via Git for Shared State 34:05

    Sazabi maintains persistent, shared memory across multiple parallel sub-agents and threads by committing findings (e.g., issue lists, facts) to a dedicated Git branch within the sandbox environment. This allows agents to benefit from collective findings.

  4. Sandbox Isolation and Read-Only Access 30:30

    The platform operates in a read-only system with no public internet access, ensuring security. All actions are routed through an isolated sandbox environment (e.g., using `bash` tools) to prevent data exfiltration or unauthorized changes.

Watch on YouTube Full article

· 42:20

Autonomous Agents at Work: From OpenClaw Hype to Enterprise Reality

Autonomous agents represent a significant shift from simple chat interfaces to systems that actively perform actions. To transition these agents from experimental hype (like the OpenClaw movement) to reliable enterprise production models, organizations must implement rigorous governance and control frameworks. PwC outlines a comprehensive approach focusing on risk classification, establishing a minimum control stack (Identity, Input/Output Controls, Auditability), and implementing multi-faceted evaluation processes across Quality, Performance, Safety, Cost, and Business Impact.

Key takeaways

  1. 3-Tier Work Classification for Risk Management 1:45

    Agents must be classified based on the potential blast radius: 1) Reversible work (e.g., ticket enrichment); 2) Sensitive work (affecting system stability, requiring tighter controls); and 3) Consequential work (touching legal or customer policy documents, highest risk).

  2. The Minimum Control Stack for Production Agents 4:00

    Before deployment, four non-negotiable controls must be in place: Agent Identity (credentials treated as first-class data with strict expiration/authorization); Input Controls (guardrails against prompt injection and ensuring tool allow-listing); Output Controls (limiting tool calls, retries, and preventing toxic output); and Auditability.

  3. Five Pillars of Agent Auditability 5:10

    Auditing must go beyond simple logging. A comprehensive framework requires monitoring Quality (using LLM-as-judge), Performance (focusing on P99 latency), Safety (PII redaction/filters), Cost (tracking expenditure at the run level), and Business Impact (logging the agent's chain of thought decision process).

  4. Ownership and Architecture are Paramount 8:00

    Engineers must maintain ownership over the system architecture, even if AI generates the code. The core logic and blueprints must be human-owned to ensure accountability and proper review processes.

Watch on YouTube Full article