The Video Signal technical video digests

Inside 847 Production Clinical AI Notes — Sebastian Fox, Composo thumbnail

· 19:48

Inside 847 Production Clinical AI Notes — Sebastian Fox, Composo

This talk addresses the critical challenge of evaluating high-stakes AI systems, particularly ambient scribes in healthcare, where dangerous failures often manifest as subtle omissions or hallucinations rather than obvious errors. The speaker argues that traditional verification methods (like fixed rubrics or simple difference checks) fail because the 'standard of good' is tacit, contextual, and constantly evolving. A proposed solution involves building a continuous evaluation loop: Discovering failure modes from real-world outputs, capturing expert judgment on these modes, and calibrating every new output against this accumulated, case-specific context rather than a static rule set.

Key takeaways

  1. High-Stakes Failure Modes 2:09

    In clinical notes, the most dangerous failures are often subtle omissions (e.g., missing jaw pain symptoms) or hallucinations that look technically correct but are factually wrong. In large studies, nearly 1 in 20 notes carried an error serious enough to cause significant harm [1:29].

  2. Limitations of Current AI Evaluation 11:43

    Verification is only easy for the 'easy half' (e.g., spotting differences between transcript and note). The hard part is determining which difference—an omission, change, or addition—actually matters in context [7:03]. This judgment is tacit, contextual, and moving.

  3. The Continuous Evaluation Loop

    To overcome the limitations of static rubrics, the recommended approach is a continuous loop: 1) Discover failure modes from real outputs (building a 'failure mode ontology'), 2) Capture expert judgment on these modes, and 3) Calibrate every output against this accumulated, case-specific context, rather than relying on fixed weights or prompts [13:49].

Watch on YouTube Full article

Agent Frameworks Considered Harmful — Rémi Louf, .txt thumbnail

· 20:29

Agent Frameworks Considered Harmful — Rémi Louf, .txt

The talk details the creation of a robust, event-driven agent runtime system designed to overcome limitations in existing AI frameworks and chat interfaces. The core innovation is moving from string-based prompts and complex graphs to an auditable, content-addressed store where every component (system message, skill description, user question) is hashed and stored separately. This architecture ensures full traceability, allowing for precise diffing between runs and reliable replaying of requests against different models, making the system highly debuggable and scalable.

Key takeaways

  1. Event-Driven Architecture (EDA) 15:37

    The system relies on agents subscribing to typed events rather than maintaining complex graphs with edges. This simplifies orchestration significantly, allowing for 'funneling' and 'fan out' without requiring code knowledge; users only need to know what events exist in the system.

  2. Content-Addressed Prompt Store 20:11

    Prompts are no longer rendered strings. Instead, every part (system message, skill description, tool definition, user question) is hashed and stored as an identifier. A prompt is represented as a list of these hashes, enabling precise auditing.

  3. Enhanced Observability

    The system implements two key boundaries: typed tool calls and typed events. This rigorous typing prevents malformed or non-existent inputs from breaking the pipeline, which was necessary because early failures included rejected/malformed events.

Watch on YouTube Full article

Coding Agents Don't Scale Themselves. Neither Do Your Teams. — Patrick Debois, Tessl thumbnail

· 22:06

Coding Agents Don't Scale Themselves. Neither Do Your Teams. — Patrick Debois, Tessl

The shift toward autonomous systems (the 'dark factory') is not limited by technology but by organizational readiness. The core message is that the focus must move from fixing code produced by AI agents to improving the underlying system and processes. Scaling requires moving beyond solo developer efforts to establishing centralized, reusable platforms and mandates for context authoring and tooling.

Key takeaways

  1. Organizational Readiness vs. Technology Limits

    The resistance to advanced automation (like continuous delivery or the dark factory) is not due to technological impossibility but because organizations are not yet structured for it. The differentiator will be the team, platform, and organization, not the technology itself.

  2. Shift Focus from Code Fixing to System Improvement 8:40

    Developers should stop focusing on fixing the code produced by agents. Instead, they must improve the system architecture and processes (e.g., improving test coverage or documentation generation) that guide the agent.

  3. Scaling Requires Platform Ownership 21:10

    To scale automation beyond individual teams, organizations must establish centralized 'paved roads' and dedicated owners for reusable components (e.g., authentication systems, linters, or context registries). This prevents technical sprawl.

  4. Key Metrics for Measuring Progress 15:38

    Productivity should be measured by two metrics: the reduction in 'human touches' required to get a correct result, and the degree of fix/improvement that is shared across multiple users (the multiplier effect).

Watch on YouTube Full article

Preferences Over Benchmarks: Model Routing — Archana Kamath & Tyler Gillam, DigitalOcean thumbnail

· 15:54

Preferences Over Benchmarks: Model Routing — Archana Kamath & Tyler Gillam, DigitalOcean

The talk argues that relying on public benchmarks to select a single best LLM is flawed; model selection must be based on specific operational preferences. The solution presented is an Inference Router—a purpose-built Mixture of Experts (MoE) model that dynamically selects the optimal LLM for each request based on declared constraints, including task type, cost tolerance, required latency, and system prompts. This approach significantly reduces inference costs and improves performance stability compared to using a single premium model across all tasks.

Key takeaways

  1. Model selection must be preference-driven, not benchmark-driven 4:02

    The 'right' model depends on the specific request context (task, cost, latency) and cannot be determined by a single public leaderboard. For instance, classification may use a small open model for cost efficiency, while code review requires a frontier model for accuracy.

  2. Model orchestration is the new phase of cloud optimization

    Due to exploding inference costs and single-model risk, advanced model orchestration (like routing) is becoming a critical discipline for production applications.

  3. The router optimizes cost and speed per task

    In live demos, the router successfully matched tasks (e.g., code generation, test writing) to specialized models (e.g., GLM 5.2, Claude 3 Sonnet), resulting in significantly lower total session costs (e.g., 8 cents vs. 25 cents) while maintaining comparable quality.

  4. The router is customizable and open-source 5:20

    The solution runs on an open proxy plan and a purpose-built routing model (both open source), allowing users to define custom decision tree rules, set failover policies, and evaluate performance using internal metrics rather than external leaderboards.

Watch on YouTube Full article

What If Your Chip Design Team Moved Like a Single Body? — Abduallah Mohamed, AIDAChip thumbnail

· 16:46

What If Your Chip Design Team Moved Like a Single Body? — Abduallah Mohamed, AIDAChip

The talk argues that for large engineering teams (50+ people), organizational alignment is a greater bottleneck than individual skill or tool availability. In high-stakes domains like chip design, where failure costs can reach $50 million, the solution requires moving beyond simple agent tools to build a 'shared nervous system.' This system—a living graph of intent and constraints—ensures that all changes are tracked, validated by human approval, and prevent systemic failures (like truth drift or agents overstepping boundaries) before silicon is printed.

Key takeaways

  1. Alignment Beats Individual Skill

    In large teams, communication overhead grows quadratically with headcount. The most successful organizations are those most aligned, not necessarily those with the best individual engineers.

  2. The Cost of Failure in Chip Design 5:47

    Chip design is irreversible; fixing errors requires re-printing silicon, incurring an average risk cost of $50 million per company. Practitioners report spending 70% of their time on alignment rather than development.

  3. The Shared Nervous System Solution 8:52

    Instead of scattered knowledge and fragmented intent, the solution is a multi-layer AI system built around a 'living graph' (the system of intent) that captures all constraints and decisions, requiring human approval for any agent modification.

Watch on YouTube Full article

FinOps for AI Agents: Who Spent All the Tokens? — Tisha Chawla & Susheem Koul, Microsoft thumbnail

· 21:24

FinOps for AI Agents: Who Spent All the Tokens? — Tisha Chawla & Susheem Koul, Microsoft

The talk introduces TokenOps, a control plane designed to shift AI agent development from 'token maxing' (spending tokens) to 'value maxing' (maximizing value per token). It addresses the critical gap in current systems: the lack of cost governance between code execution and model calls. TokenOps operates out-of-band at the entire agent run level, utilizing a `boundary annotation` and `governor node` to implement sophisticated policies that can 'steer' an agent's behavior (e.g., instructing it to be more succinct) before hitting a budget cap, thereby preventing costly failures.

Key takeaways

  1. Shift from Token Maxing to Value Maxing

    The industry needs to move beyond simply spending tokens and focus on ensuring that every token spent has measurable business value. This requires proper attribution of costs back to specific agent runs.

  2. Run-Level Cost Control is the Missing Piece 2:38

    Existing tools (like model gateways) only control cost at the request level. TokenOps provides governance at the entire agent run layer, allowing control over complex loops and context growth.

  3. Steering vs. Halting

    Instead of simply halting an agent when a budget is exceeded (a circuit breaker), the 'steer' action uses a cost guard to predict overruns and injects instructions into the system prompt, guiding the agent toward more efficient outputs.

Watch on YouTube Full article

Give the Agent a Budget, Not a Token — Sachin Malhotra, Anthropic thumbnail

· 19:53

Give the Agent a Budget, Not a Token — Sachin Malhotra, Anthropic

The presentation argues that granting AI agents 'unbounded power' via simple tokens is dangerous. Instead of narrowing the token scope (a boolean fix), engineers must implement a comprehensive 'budget' system with four dimensions: how much, how fast, what can be undone, and who notices. Key solutions include using asymmetric verbs (prioritizing loud failures), enforcing rate limits on writes, implementing trip wires over static allow lists, and utilizing an 'undo test' to size the overall safety policy.

Key takeaways

  1. Budget vs. Token 7:03

    A token is a boolean (yes/no) scope; a budget is multi-dimensional, considering volume, velocity, reversibility, and observability. The failure was giving the agent unbounded power, not the model itself.

  2. Asymmetric Verbs 10:05

    Prioritize granting agents access to operations that fail loudly (e.g., unskipping a test, which causes CI to go red) and keep critical failure verbs (like skipping a test) reserved for human intervention with an audit trail.

  3. Rate Limits & Trip Wires 13:54

    Implement rate limits on every write operation, ensuring the ceiling refills automatically. Use trip wires (monitoring aggregate behavior) instead of static allow lists, as trip wires adapt to real-world data.

  4. The Undo Test

    This test asks if the agent can autonomously roll back its own changes and what the blast radius would be if it failed. If not, a second key (human involvement) and an audit record are required.

Watch on YouTube Full article

How Multi-Vector Retrieval Works at Scale thumbnail

· 24:30

How Multi-Vector Retrieval Works at Scale

This talk introduces Multi-Vector Retrieval, a critical advancement for building sophisticated AI agents and search systems that move beyond the limitations of single vector embeddings. Single vector approaches (which pool token representations) lose low-level detail, making them ineffective for complex, multi-step agentic queries. Multi-vector methods preserve per-token representation, significantly improving retrieval accuracy, especially in out-of-domain or long-context scenarios. The talk details the technical challenges—namely, massive storage and compute overhead—and presents a solution using sparse multi-vector encoding to make billion-document scale retrieval practical.

Key takeaways

  1. Single Vector Limitations for Agents

    Single vector embeddings pool token representations into one summary vector, which captures high-level semantics but loses the low-level detail required for precise queries issued by AI agents. This loss of specificity is a theoretical limit that single vectors cannot overcome, even with increased dimensionality.

  2. Multi-Vector Solution and Scaling 10:15

    Multi-vector embeddings retain one embedding per token instead of pooling them. To manage the resulting storage (10x to 100x increase) and compute overhead, the proposed solution uses sparse multi-vector encoding. This technique approximates MaxSim using random projections, allowing efficient retrieval at scale.

  3. Performance Gains in Agentic Retrieval

    Multi-vector approaches significantly outperform dense models (e.g., a 100M MultiVector model outperforming an 8B dense model) and standard retrieval methods, achieving higher accuracy at substantially lower cost (e.g., 42% accuracy at one thirteenth of the cost).

  4. System Architecture for Scale 20:40

    For production readiness, the system separates compute from storage and isolates read/write paths. This architecture allows handling high write throughput (e.g., 70 MB/s) without negatively impacting query latencies, maintaining sub-50ms P99 latency even at billion scales.

Watch on YouTube Full article

Building Agents Is Trivial Now, Context Is the Next Frontier — Jeff Ng, Unblocked thumbnail

· 13:22

Building Agents Is Trivial Now, Context Is the Next Frontier — Jeff Ng, Unblocked

While cloud primitives and frameworks have made defining AI agents trivial—reducing complexity from requiring dedicated systems for checkpointing, sandboxing, and observability—the primary failure point remains missing organizational context. The speaker argues that simple access layers (like Multiple Connectors/MCPs) are insufficient because 'access is not understanding.' A Context Engine solves this by connecting disparate data sources (docs, code, tickets, conversations) to provide a synthesized, task-relevant understanding that agents can act upon, preventing critical errors and outages.

Key takeaways

  1. Agent Development Complexity Has Decreased

    Six months ago, building an agent required significant effort to solve infrastructure problems like state persistence (checkpointing), isolated sandboxes, and observability. Modern cloud primitives (e.g., Cloudflare, Vercel) have absorbed this 'plumbing,' simplifying agent definition to selecting a model, instructions, tools, and sandbox location.

  2. The Context Gap is the New Bottleneck 7:01

    Agents struggle with institutional knowledge—the decisions, failures, and postmortems stored across different systems (Slack threads, documentation). An agent lacking this full picture can make confidently wrong recommendations, potentially causing outages.

  3. Context Engines Provide Synthesized Understanding

    A Context Engine goes beyond simple data access by building a model of the organization. It reconciles conflicting results across multiple datasets (docs, code, tickets, conversations) and delivers a synthesized understanding that an agent can act on, rather than just raw documents.

Watch on YouTube Full article

LangChain Academy Tutors: Learn LangChain with Your Coding Agent thumbnail

· 6:00

LangChain Academy Tutors: Learn LangChain with Your Coding Agent

This video introduces LangChain Academy Tutors, a novel method for structured learning of LangChain concepts using custom skills integrated into coding agents. The tutor skill guides users through course materials, quizzes, and labs, providing immediate feedback and allowing customization of the teaching style. Setup requires Node.js installation and utilizing the LCA tutors repository to configure the agent with the specific tutor skill.

Key takeaways

  1. Tutor Functionality 3:30

    The LangChain Academy Tutor can teach course material, walk through labs/quizzes, answer questions, and set up environments. Users can adjust the teaching style (e.g., 'fairly often' check-ins vs. a 'lecturer' style) to match their learning preference.

  2. Setup Requirements 2:30

    To use the tutor, users must have Node installed (from node.js.org). The skill is housed in the LCA tutors repository and needs to be configured for access by chosen coding agents.

  3. Agent Invocation 4:10

    The tutor can be invoked using a command structure, such as `/LCA deep agents`, where the naming convention follows the course name (e.g., `deep agents`).

Watch on YouTube Full article

Inside DeepWiki: How Cognition Builds Wikis for Devin at Scale thumbnail

· 17:12

Inside DeepWiki: How Cognition Builds Wikis for Devin at Scale

Jacob Teo details DeepWiki, an auto-generated codebase documentation product used as a context layer for agents like Devin. The presentation covers how DeepWiki scaled from internal tools to indexing 1.4 million repositories. Key technical advancements include evolving the wiki algorithm from a heavily orchestrated v1 to a more agentic v2, which improves robustness at massive scale. Furthermore, he outlines four principles of context engineering—Primary Sources, Context-Poisoning avoidance, Path Compression, and Unknown Unknowns—to guide future codebase intelligence systems.

Key takeaways

  1. DeepWiki's Evolution (v1 to v2) 12:28

    The wiki algorithm shifted from being highly orchestration-led (relying on tight control over model calls) to an agentic core (V2). This shift allows the system to adapt to code base abnormalities by enabling the agent to call tools for extra scaffolding, making it more robust as models improve. (7:48)

  2. Context Engineering Principles

    When building context for agents, Cognition emphasizes four principles: ensuring primary sources are trusted ground truth; avoiding context-poisoning by only providing correct information; using Path Compression to skip obvious steps and save tokens/cost; and leveraging Unknown Unknowns—providing hints the agent wouldn't find on its own. (12:40)

  3. Codebase Graphing for Scale 10:07

    To handle large enterprises with massive codebases, DeepWiki uses heuristics incorporating directory structure, symbol graphs, Git history, and runtime data to quantify file connections. This process creates a codebase graph that informs the Table of Contents (TOC), which is critical because poor TOC generation leads to a bad wiki regardless of individual page quality. (6:07)

Watch on YouTube Full article

The Missing Layer: Design Taste in AI Agents — Hassan El Mghari, Together AI thumbnail

· 14:10

The Missing Layer: Design Taste in AI Agents — Hassan El Mghari, Together AI

The talk addresses the critical role of design and User Experience (UX) in making AI applications successful, arguing that polished aesthetics are a major competitive advantage. The speaker details methods to avoid generic 'AI slop' by codifying anti-patterns using tools like Hallmark, leveraging specific themes, and adopting structured development practices such as providing visual references, writing detailed prompts, and iterating with smaller open-source models.

Key takeaways

  1. Use Visual References (Inspiration Vault)

    Always provide AI models with a large collection of screenshots or inspiration images to guide the design output. This significantly improves the final product quality.

  2. Structure Prompts and Features

    Instead of sending one massive prompt for all features, break down development into smaller steps (one or two features per prompt) and use longer, more specific prompts (e.g., voice notes) to guide the agent.

  3. Iterate with Smaller Models 10:53

    Start base builds using larger models (like Codex/Claude Code), but use smaller, faster open-source models (such as GLM 5.2) for iterative refinement and polishing to achieve better results.

Watch on YouTube Full article

GLM 5.3 in Claude Code Is A Game Changer! thumbnail

· 20:49

GLM 5.3 in Claude Code Is A Game Changer!

This guide details how to integrate the GLM-5.3 model into existing AI coding harnesses like Claude Code and Codex, enabling significant cost savings by using a cheaper model without rebuilding the entire workflow. The speaker emphasizes that successful model switching depends less on the model itself and more on maintaining 'Project Context Hygiene'—ensuring critical project rules, standards, and definitions of done are stored in portable files rather than residing only within ephemeral conversation history.

Key takeaways

  1. Model Switching vs. Harness Integrity

    The primary goal is to use a cheaper model (e.g., GLM-5.3, starting at $18/month) without abandoning the established workflow or 'harness' of tools like Claude Code or Codex. The savings must be calculated against the fully loaded cost, including retries and review time.

  2. The Four Components of AI Coding Work

    A coding job involves four distinct elements: the Model (reasoning engine), the Harness/Tool (e.g., Claude Code, Codex; which provides file reading and command execution), Project Context (portable files like `Claude.markdown` containing rules/standards), and Conversation (temporary session history). Changing the model does not automatically transfer all four components.

  3. Best Practice for Model Handoff 20:09

    To minimize loss of context when switching models, always treat the transition as a new or carefully handed-off job. Instead of relying on old conversation history, create an explicit 'handoff file' that documents the goal, current state, relevant files, constraints, and definition of done for the receiving model.

Watch on YouTube Full article

Agentic SDLC at Uber — Uday Kiran Medisetty & Adam Huda, Uber thumbnail

· 18:26

Agentic SDLC at Uber — Uday Kiran Medisetty & Adam Huda, Uber

Uber has implemented a comprehensive 'Software Factory' powered by agentic AI to revolutionize its SDLC. Key infrastructure investments include a centralized Model Gateway for security and latency control, an MCP Gateway for token optimization, and a Context Graph that unifies knowledge across disparate systems. These building blocks enable autonomous agents (like Minion) to accelerate development from idea generation (via Cortana) through drafting PRs, validating changes in inner loops (e.g., comparing simulator screenshots against Figma specs), and managing maintenance tasks.

Key takeaways

  1. Agentic Adoption Metrics

    Over the last year, agentic AI led to more than 70% of Uber's Pull Requests (PRs) originating from local or cloud agents, resulting in double the lines of code per engineer year-over-year.

  2. Model Gateway Performance 2:06

    The Model Gateway handles all internal model calls through a single endpoint, ensuring PII redaction for over 20 types and running five specialized safety models under a strict 100 millisecond guardrail budget. It processes over 100 million requests daily across 800+ projects.

  3. Token Optimization 5:51

    The MCP Gateway, combined with projecting MCPS into CLI patterns and using Omni MCP, cut fleetwide token usage by more than 40%.

Watch on YouTube Full article

Hugging Face Journal Club: Training AI Scientists to Replicate Research thumbnail

· 34:41

Hugging Face Journal Club: Training AI Scientists to Replicate Research

The discussion summarizes research on Faraday-27B, a model trained by Inherent designed for scientific replication—the ability to reproduce results from redacted ML/AI papers. The system uses Reinforcement Learning (RL) and integrates CodeX as a tool, allowing the agent to execute code within a simulated environment. Key methodological advances include using sophisticated rubric-based judges (generated via Claude) instead of simple verifiers, employing multi-rollout averaging to mitigate variance, and implementing weighted credit assignment across the agent's steps.

Key takeaways

  1. Scientific Replication Task

    The model is tasked with replicating missing figures from redacted ML/AI papers. This process requires the agent to use tools (like CodeX) and execute code in a simulated environment, moving toward full automation of AI R&D.

  2. Advanced Judging Mechanism 0:01

    Instead of simple verification, the system uses a rubric-based judge (generated by Claude) that assigns fine-grained points for correct reasoning, figure accuracy, and code writing. This process involves averaging judgments across multiple rollouts to prevent reward hacking.

  3. Performance & Scaling 0:02

    The trained Faraday model demonstrated strong performance, sometimes outperforming much larger models like Claude and GPT-5. Furthermore, the system showed generalization even when given increased compute resources (e.g., scaling up to 8 hours/8 B300s).

Watch on YouTube Full article

Stripe buys OpenRouter, Ramp’s AI Index & IBM’s OpenAI deal thumbnail

· 35:52

Stripe buys OpenRouter, Ramp’s AI Index & IBM’s OpenAI deal

The AI market is shifting from a focus on model superiority to infrastructure orchestration and governance. Key developments include IBM establishing itself as an enterprise AI integrator through partnerships with both OpenAI and Anthropic (1:01). Stripe's acquisition of OpenRouter positions token routing as the critical 'profitability infrastructure,' suggesting that controlling the flow of compute decisions is more valuable than developing models themselves (11:46). Furthermore, data from Ramp suggests a market maturity where businesses are moving away from per-seat AI spending toward measuring cost per unit work and implementing rigorous FinOps practices to manage escalating token costs (22:39).

Key takeaways

  1. IBM's Enterprise Orchestration Strategy 2:12

    IBM is positioning itself as a neutral enterprise AI orchestrator by forming partnerships with both OpenAI and Anthropic. This strategy aims to provide clients with choice, utilizing IBM’s proprietary Granite models alongside external leaders for governance and integration within legacy systems (1:01).

  2. The Rise of the Model Router as Infrastructure 11:42

    Stripe's acquisition of OpenRouter is framed as a bet on 'profitability infrastructure.' Since models are becoming cheaper, the value shifts to the routing layer—the ability to manage and optimize token traffic across multiple providers (11:46). This allows Stripe to act as a payment gateway for autonomous AI agents.

  3. AI Spending Shifts from Per-Seat to Unit Cost 23:30

    Ramp's data indicates that the era of unmetered, per-employee AI experimentation is ending. CFOs now demand measurable unit economic payback (e.g., cost per resolved support ticket) rather than simply approving broad AI software budgets (22:39).

Watch on YouTube Full article

Unlock Agent Autonomy: The Runtime for AI-Native Systems — Tushar Jain, Docker thumbnail

· 22:50

Unlock Agent Autonomy: The Runtime for AI-Native Systems — Tushar Jain, Docker

The talk addresses the critical shift from making AI agents more intelligent to making them safer and more autonomous. The core challenge is that as agents investigate complex issues (like latency spikes), their required access expands at runtime, significantly widening the 'blast radius.' The speaker proposes a new runtime layer designed to manage this complexity by enforcing three pillars: **Containment** (running the agent in an untrusted boundary while controls remain outside), **Scoped Capabilities** (providing only the minimum necessary access for a specific task), and **Intent-Based Access** (determining if the requested action aligns with the original user intent). This runtime must be portable across all environments (local, cloud, VPC) and models.

Key takeaways

  1. The Shift from Intelligence to Safety

    The next major challenge in agent development is not intelligence, but safety. Traditional software had fixed permissions; autonomous agents change their required access at runtime, necessitating a fundamental shift in security architecture.

  2. The Danger of Expanding Scope 5:12

    When an agent investigates a problem (e.g., latency spike), it sequentially requests access to logs, GitHub history, and Slack. Each step expands the trust boundary, leading to a single process with excessive, accumulated permissions.

  3. The Three Pillars of Safe Autonomy 10:24

    A proposed runtime layer must implement: 1) **Containment** (controls outside the agent's boundary); 2) **Scoped Capabilities** (providing granular access per task, not accumulating them); and 3) **Intent-Based Access** (validating if a sudden request—like email access during an incident investigation—is correct or should be escalated).

  4. Portability and Orchestration 22:38

    The runtime must be omnipresent, working across different models (Anthropic, Claude, Open Code), multiple harnesses, and environments (local machine, cloud VPC). The speaker demonstrated that the same secure sandbox can run locally or in the cloud, and these sandboxes can be composed for parallel execution and orchestration.

Watch on YouTube Full article

Your Fine-Tuned Model Is Tech Debt: A 50x ROI House of Cards — Dan Bjornn, Lease End thumbnail

· 16:39

Your Fine-Tuned Model Is Tech Debt: A 50x ROI House of Cards — Dan Bjornn, Lease End

The video argues that relying heavily on fine-tuned LLMs for production applications can create 'calcification tax'—a form of technical debt characterized by rigid architecture and complex maintenance cycles. The speaker details migrating from a fine-tuning approach to an agentic framework built on skills, prompts, and context. This shift drastically reduced the time required to deploy fixes (from weeks/days to under an hour), improved accuracy, maintained model agnosticism, and ultimately lowered total operational costs.

Key takeaways

  1. The Calcification Tax 10:04

    Fine-tuning creates technical debt by locking systems into specific models and architectures. The complexity of retraining—which involves gathering examples, synthesizing data, manual validation, and iterative fixing—is costly and slow (up to a week per cycle).

  2. Agentic Frameworks Over Fine-Tuning

    The rebuild swapped the fine-tuned model for skills, prompts, and context on a model agnostic framework. This allowed fixes to ship by simply uploading files to an S3 bucket.

  3. Cost vs. Accuracy Tradeoff

    While the new agentic approach increased cost per message (due to using better models), overall total cost decreased significantly because the time spent on maintenance and retraining was drastically reduced.

Watch on YouTube Full article

LangSmith Preview Builds: Test agent changes before production thumbnail

· 8:01

LangSmith Preview Builds: Test agent changes before production

LangSmith Preview Builds extend standard software development workflows to AI agents. By automatically creating a temporary deployment for every GitHub Pull Request (PR), teams can test agent changes and validate functionality in a production-like environment without impacting the main branch. This system ensures that agents are thoroughly tested on preview branches before being merged, while also guaranteeing automatic teardown of the temporary deployment upon PR merge.

Key takeaways

  1. Preview Builds for Agents

    LangSmith automatically generates a temporary deployment for every pull request, allowing teams to test agent changes safely before they reach production. This brings standard software development workflows (PR testing) to AI agents.

  2. Local Testing and Validation

    Agents can be tested locally using `langgraph dev`, which automatically opens LangSmith Studio for validation. Changes made in the local project are reflected in the preview deployment.

  3. Automated Revisioning

    The system supports continuous iteration: every new commit added to a PR triggers a new revision of the preview deployment, allowing for granular testing before final merge.

  4. Automatic Cleanup (DevEx)

    Once the pull request is successfully merged into the main branch, LangSmith automatically tears down and removes the temporary preview deployment, ensuring clean resource management.

Watch on YouTube Full article

How I automate my own job at Hugging Face using agents — Niels Rogge, Hugging Face thumbnail

· 20:37

How I automate my own job at Hugging Face using agents — Niels Rogge, Hugging Face

Niels Rogge details how he automated his role at Hugging Face—the 'Google Drive to the hub' team—which focuses on improving the discoverability of machine learning artifacts. He built two systems: an initial deterministic workflow for outreach (using cron jobs and LLM APIs) and a subsequent fully autonomous agent loop for follow-up actions. The architecture leverages modern tooling like Modal, Bash CLI skills, and advanced models (e.g., GLM 5.2) to scale the process of identifying missing artifacts and prompting researchers to publish them on Hugging Face.

Key takeaways

  1. The Problem: Artifact Discoverability

    ML weights and datasets are often published on third-party services (Google Drive, Zenodo) rather than the centralized platform (Hugging Face), hindering discoverability. The goal is to automate outreach to authors.

  2. Initial Automation: Deterministic Workflow 11:43

    The first phase used a deterministic workflow, running as a nightly cron job on GitHub Actions. This approach utilized LLM APIs in predefined steps without an agent framework, offering high predictability and control.

  3. Advanced Automation: Autonomous Agent Loop 15:36

    The follow-up process was automated using a fully autonomous agent loop (e.g., leveraging the Claude agents SDK). This flexible approach allows the agent to use tools and skills, such as Bash and the Hugging Face CLI, to interact with GitHub issues.

Watch on YouTube Full article