The Video Signal technical video digests

How to Cut Your LLM Classification Costs by 90% thumbnail

· 25:42

How to Cut Your LLM Classification Costs by 90%

This session details the Model Cascade architecture, a technique to drastically reduce LLM classification costs (by over 90%) while maintaining high accuracy (e.g., 95%+). Instead of running an expensive 'Oracle' model on every record, the cascade uses a cheap proxy model for initial predictions and only escalates to the Oracle when the proxy's confidence score is low. The optimal decision threshold ($\tau$) is found offline by simulating performance across samples.

Key takeaways

  1. Model Cascade Architecture 8:31

    The pipeline first sends every record (e.g., support ticket) to a cheap LLM API (the proxy/nano model). It generates a prediction $P(x)$ and a confidence score $C(x)$. A decision point then determines if the score $C(x)$ is high or low, routing only low-confidence records to the expensive 'Oracle' model.

  2. Cost Optimization Principle 17:31

    The goal is to find a threshold $\tau$ that minimizes cost while maintaining a target accuracy (e.g., 95%) relative to the Oracle model. Lowering $\tau$ increases cost savings but risks dropping below the required accuracy.

  3. Threshold Determination 20:48

    The optimal threshold $\tau$ is found offline by simulating the cascade using a labeled sample of tickets, calculating the resulting accuracy and cost for various potential thresholds $C(x_i)$.

Watch on YouTube Full article

LLM Knowledge Bases: a practical guide — Ben Holmes, Warp thumbnail

· 21:17

LLM Knowledge Bases: a practical guide — Ben Holmes, Warp

The talk outlines a comprehensive pipeline for transforming disorganized raw notes into structured, navigable LLM knowledge bases. The process begins with maximizing raw data capture via voice dictation (suggested over typing) and progresses through automated enrichment steps using AI agents. Key stages include enriching notes by adding timestamps, fixed-list tags, web research backlinks, generating wikis of People/Concepts/Sources, and finally visualizing the entire network structure using graph views. The entire system is designed to run on an automated schedule in a cloud sandbox environment.

Key takeaways

  1. Raw Data Capture Priority 5:25

    The most critical step for building a knowledge base is generating high volume of raw material. Voice dictation (approx. 200 words per minute) is presented as the fastest method for capturing thoughts, even if they are 'scrappy' or rambling.

  2. The Enrichment Pipeline 9:53

    Notes can be enriched using an agent skill (e.g., 'enrich note') to add structure: timestamps, tags from a fixed reference list (to prevent agents from inventing new categories), web-researched sources, and backlinks found via key term search.

  3. Automated Knowledge Generation 13:40

    The system can generate a wiki structure (People, Concepts, Organizations) from raw notes. This process is highly automated and can be scheduled to run in the background (e.g., daily), ensuring the knowledge base remains fresh.

  4. Automation and Scheduling 17:45

    To maintain the knowledge base, the entire flow must run on a schedule using cloud sandboxes (e.g., Oz.dev). The process involves syncing markdown files down, running the agent skill, and syncing the updated notes back up.

Watch on YouTube Full article

Adaption Labs: Gradient-Free Continual Learning — Sara Hooker, Adaption thumbnail

· 20:51

Adaption Labs: Gradient-Free Continual Learning — Sara Hooker, Adaption

The talk argues that the frontier of AI development is shifting away from relying solely on massive, co-located pre-training compute (the 'Death of Scaling'). Instead, democratization and innovation are being driven by automating model training loops and optimizing for distributed, post-training customization. The speaker introduces AutoScientist, a system designed to co-optimize the entire model lifecycle—from data quality through alignment—allowing builders to achieve frontier capabilities with greater efficiency and accessibility.

Key takeaways

  1. The Narrow Path of AI Research 2:36

    Historically, contributing to AI breakthroughs required following a narrow path (right PhD, right lab), which was compounded by the need for enormous compute resources. This has created significant barriers to entry globally.

  2. AutoScientist Automates Model Training 10:45

    The system automates model training by co-optimizing the entire loop (data $ ightarrow$ alignment). It is designed to self-evolve based on domain and data type, outperforming research staff because it searches across a broader space of architectures (dense vs. Mixture of Experts) than human researchers typically consider.

  3. Shifting Compute Paradigms 17:12

    Pre-training size is no longer the most rewarding axis for scale; instead, distributed inference compute and post-training customization are becoming more lucrative. This shift means that algorithms and recipes matter more than simply hoarding GPUs.

Watch on YouTube Full article

Intelligence + Continual Learning = Expertise — Yu Su, NeoCognition thumbnail

· 19:43

Intelligence + Continual Learning = Expertise — Yu Su, NeoCognition

The talk distinguishes between 'Intelligence' (the capacity to reason through unfamiliar problems from available context) and 'Expertise' (accumulated, situated competence). While modern LLM agents excel at symbolic tasks like coding because code is a structured language-native world, they struggle in heterogeneous real-world digital environments. The speaker posits that this difficulty represents a modern Moravec's paradox. To scale AI beyond basic capability, systems must implement continual learning to acquire specialized expertise for each 'microworld,' leading toward 'unbounded expertise from bounded intelligence.'

Key takeaways

  1. Intelligence vs. Expertise Distinction 3:50

    Intelligence is the ability to reason through novel problems given context, while expertise is accumulated competence that allows for efficient action and judgment in a specific domain (e.g., recognizing constraints beyond just finding a shared calendar slot).

  2. The Coding Agent Advantage 5:26

    Coding is an ideal first market for LLM agents because code is already symbolic and structured, providing clear tests and rewards. Leaving this 'privileged world of code' introduces significant brittleness.

  3. The Role of Continual Learning 10:44

    Continual learning is defined as the adaptive compression of experience into reusable structures for future behavior. It is presented as the critical bridge needed to transition from raw intelligence (brute-forcing solutions) to specialized expertise (compressing the search space).

Watch on YouTube Full article

Scaling Compute on Context — Jack Morris, Engram thumbnail

· 19:42

Scaling Compute on Context — Jack Morris, Engram

This talk introduces the concept of 'Scaling Compute on Context,' addressing the fundamental limitation that current Large Language Models (LLMs) are trained exclusively on public data. While traditional deep learning progress relies on scaling three axes—more data, more compute, and bigger models—the inability to scale with private corporate or personal data limits model depth. The speaker reviews several advanced techniques (e.g., KV compaction, on-policy distillation, continued pretraining) aimed at transferring domain expertise from a fixed, unstructured corpus ($D$) into the model's weights, ultimately seeking a self-improving training mechanism analogous to AlphaGo.

Key takeaways

  1. The Knowledge Gap: Public vs. Private Data 5:59

    Current LLMs are superb on public data (Wikipedia, GitHub) but lack deep knowledge of private corporate or personal contexts (emails, internal meetings). This is the core problem that limits model depth and expertise acquisition.

  2. Scaling Compute on Context 8:40

    Since scaling with new public data is limited, the focus shifts to maximizing compute power given a fixed, private dataset ($D$). This approach aims to imbue the pre-trained model ($ heta$) with deep domain knowledge from $D$.

  3. The Goal: Self-Improvement and Depth Scaling 11:45

    Most current methods eventually saturate (hitting a 'data wall'). The desired property is self-improvement, where getting better makes the training questions harder, allowing compute to continuously buy depth rather than flattening out.

Watch on YouTube Full article

Memory Harnesses for Long-Running Research Agents — Stefania Druga, Sakana.ai thumbnail

· 13:04

Memory Harnesses for Long-Running Research Agents — Stefania Druga, Sakana.ai

The presentation details the design and efficacy of 'memory harnesses' for managing state in long-running research agents. The core finding is that while memory harnesses offer no benefit when task context fits within the model's window (adding only cost), they are critical for solving long-horizon tasks where relevant information sits far outside the current context. The speaker emphasizes treating memory as a write-manage-read control loop, not merely an attached database.

Key takeaways

  1. Memory is a Control Loop, Not a Database 5:44

    The memory harness must be viewed as a 'write-manage-read' control loop wrapped around the model, rather than simply a retrieval database. This architectural focus allows for precise state management.

  2. Local Models Enable Sovereignty and Cost Control 2:36

    Running evaluations on local hardware (e.g., M3 Ultra) enables better control over the entire pipeline, which is crucial for maintaining 'sovereign AI' capabilities and reducing operational costs.

  3. Ranked Recall Outperforms Other Policies 7:16

    Across the X-Bench benchmark (over 68 questions), the 'ranked recall' policy consistently achieved the best performance, outperforming even approaches that simply gate memory usage or use an ideal 'oracle' ground truth.

Watch on YouTube Full article

Three OpenAI Engineers Shipped A Million Lines. Your Ten-Hour Agent Run Starts Here. thumbnail

· 23:57

Three OpenAI Engineers Shipped A Million Lines. Your Ten-Hour Agent Run Starts Here.

The video details 'Progressive Context Shaping,' a methodology for managing extremely long-running AI agent sessions (6+ hours) by moving beyond reliance on large context windows. Instead of feeding an agent one massive instruction file, successful agents externalize and manage the current state, active plans, and decisions in structured files (e.g., `current.markdown`). This approach allows the agent to change direction or correct errors without losing critical progress, making human judgment—not just context size—the primary driver of complex AI work.

Key takeaways

  1. Progressive Context Shaping

    The core principle is that as work progresses, the small set of current instructions and decisions must receive priority over all historical data to guide the agent's next action. This allows for changing direction without restarting the project.

  2. OpenAI's Approach 4:03

    OpenAI replaced a 'giant manual' with a short map pointing agents toward active execution plans, decision logs, and design documents, ensuring the agent finds current information rather than relying on old instructions.

  3. Anthropic's Progress File 5:21

    Anthropic uses a 'progress file' as portable memory between sessions in Claude Code. This file records the current state, completed work, known limitations, and failed approaches to allow fresh sessions to pick up tasks.

  4. The Four Context Types 21:47

    Effective agent management requires separating four types of context: Stable Instruction (rules), Current Project State (active goals/decisions), The Map (resource location), and History (what happened).

Watch on YouTube Full article

The OWASP LLM Top 10 has a few surprises for you thumbnail

· 29:05

The OWASP LLM Top 10 has a few surprises for you

The discussion analyzes emerging risks in AI security, highlighting a shift from focusing solely on prompt manipulation to addressing 'Excessive Agency'—the actions an autonomous system can perform. Key takeaways include the need for robust identity controls (least privilege, segmentation) when dealing with agentic systems and the necessity of operationalizing supply chain data via CISA's updated SBOM guidance. Experts emphasize that security must be built around AI models to ensure resilience when they inevitably fail.

Key takeaways

  1. Shift in AI Risk Focus: Agency over Injection 20:55

    The primary concern is shifting from manipulating what the AI says (prompt injection) to controlling what it actually does (excessive agency). Agents are viewed as privileged accounts that require strict identity and access controls.

  2. OWASP List for Tabletop Exercises 21:05

    Instead of treating the OWASP LLM Top 10 list as a compliance checklist, panelists recommend using it as a framework for tabletop exercises to test detection, containment, and reconstruction capabilities during an attack.

  3. Operationalizing SBOM Data 21:45

    CISA's updated SBOM guidance (2026 minimum elements) must move beyond being a compliance artifact. Organizations must integrate SBOM data with vulnerability/exposure management to determine *where* and *how* critical components are exposed in real-time, rather than just cataloging them.

  4. AI Agents as the New Attack Surface

    The risk is no longer limited to software vulnerabilities; AI agents themselves constitute a new attack surface. Threat actors can exploit an agent's granted authority (e.g., via malicious calendar invites) through techniques like 'Intent Collusion.'

Watch on YouTube Full article

Locknote: Reasons to be Cheerful: 0, 1, 2 - Emmz Rendle - NDC Copenhagen 2026 thumbnail

· 57:04

Locknote: Reasons to be Cheerful: 0, 1, 2 - Emmz Rendle - NDC Copenhagen 2026

The talk presents a highly optimistic overview of technological progress across multiple domains, arguing that advancements in AI, quantum computing, and biotechnology are solving complex global problems. While addressing concerns about job displacement and climate change, the speaker emphasizes that these technologies—such as specialized LLMs (Gemma 4, Qwen 3.6) for code generation or CRISPR for personalized medicine—are tools that enhance human capability rather than replace it entirely. The presentation also touches on hardware advancements like shared memory architectures and post-quantum cryptography standards.

Key takeaways

  1. AI in Diagnostics and Genomics 5:20

    AI models are revolutionizing medicine by analyzing complex data sets, such as MRI scans (sub-millimeter slice images) to flag issues for radiologists. Furthermore, DNA/RNA analysis can detect hereditary disease risks and enable custom per-patient cancer treatments.

  2. Quantum Computing Threat and Solution 12:30

    The advent of powerful quantum computers (e.g., those capable of running Shor's algorithm) will render current classical cryptography (RSA, Diffie-Hellman, EDCSA) obsolete. The industry is responding by adopting post-quantum cryptography standards approved by NIST, specifically mentioning Dilithium and Kyber.

  3. AI for Software Productivity 17:30

    LLMs are not replacing programmers but acting as a new programming paradigm. They can generate functional code that is safe to put into production, allowing developers to focus on engineering the system's logic rather than manual typing.

  4. Advancements in Robotics and Automation 23:20

    Robotics are advancing through LLM-driven operating systems (like Gemini Robotics 1.5) that allow robots to reason through steps necessary for tasks, enabling scalable deployment across multiple units.

  5. Sustainable Energy and Climate Solutions 31:40

    New technologies include solar windows (generating electricity while visible) and 'solar canals,' which use floating panels over irrigation channels to prevent water evaporation and generate power.

Watch on YouTube Full article

The fundamentals of Agentic Coding (AKA Vibe Coding) - Theodor René Carlsen - NDC Copenhagen 2026 thumbnail

· 15:42

The fundamentals of Agentic Coding (AKA Vibe Coding) - Theodor René Carlsen - NDC Copenhagen 2026

The talk demystifies 'agentic coding' by establishing a fundamental baseline for understanding AI-assisted development tools. The core concept is that these systems rely on three components: the models (the brain), the harnesses (the ability to act), and the tools (specific functions). Speakers emphasize that while the ecosystem moves rapidly, understanding this architecture—especially the feedback loop where the harness executes actions based on model intentions—is crucial for practitioners. A key recommendation is maintaining control by favoring open-source, customizable systems over locked-down, proprietary solutions.

Key takeaways

  1. The Three Pillars of AI Coding Tools 4:00

    AI coding tools fundamentally consist of three parts: the models (e.g., GPTs from OpenAI, Claude from Anthropic), the harnesses, and the tools. The model is the 'brain,' but the harness allows it to perform actions beyond text generation.

  2. Understanding Agent Functionality 5:10

    Agents operate using a combination of a configurable system prompt (initial instructions) and defined tools. The model generates an *intention* (text), which the harness executes (e.g., reading files, running terminal commands). The output is then fed back into the model, creating a critical feedback loop.

  3. The Importance of Openness and Control 11:10

    While proprietary tools (like Cloud Code) are powerful, speakers caution against losing control. The ability to customize the harness is vital for a healthy ecosystem; open-source solutions allow introspection and customization.

Watch on YouTube Full article

🔬Biology Is Turning Into Software — Matt McPartland & Neil Patel, Chai Discovery thumbnail

· 1:35:20

🔬Biology Is Turning Into Software — Matt McPartland & Neil Patel, Chai Discovery

The intersection of biology and software is transforming drug discovery from a slow 'waterfall' process into an agile, iterative loop. Chai Discovery leverages advanced AI models (Chai-2, Chai-3) that function as sophisticated design suites—more akin to SolidWorks or Figma than ChatGPT. These platforms enable the co-design of protein sequences and structures, allowing researchers to move beyond simple structure prediction toward generating novel therapeutic candidates with high precision for complex modalities like ADCs and bispecifics.

Key takeaways

  1. Platform Design vs. Chatbot Interface

    The product is designed as a visual, highly functional design suite (like Autodesk or SolidWorks), allowing users to 'paint' epitopes and generate binders, rather than operating through conversational prompts.

  2. AI Model Progression for Drug Design 42:29

    Chai models progressed from Chai-1 (structure prediction) to Chai-2 (all-atom diffusion model capable of design), crossing the threshold into generating candidate molecules that bind to a target structure, which is critical for drug development.

  3. Shifting Drug Discovery Paradigms 20:39

    The process is moving from a costly, multi-year 'waterfall' model (target discovery $ ightarrow$ hit discovery $ ightarrow$ optimization) toward an agile, iterative loop where AI models provide rapid, promising candidates for continuous refinement.

Watch on YouTube Full article

Hugging Face Journal Club: Direct On-Policy Distillation thumbnail

· 33:25

Hugging Face Journal Club: Direct On-Policy Distillation

The discussion details a novel technique called Direct On-Policy Distillation for achieving weak-to-strong generalization in large language models. This method proposes an efficient alternative to expensive full Reinforcement Learning (RL) training by leveraging the policy shift observed when training a small model with RL. Specifically, it uses this policy shift as a dense reward signal to train and update a much larger target model (student), significantly reducing computational costs compared to direct RL on the large model.

Key takeaways

  1. Weak-to-Strong Generalization via Policy Shift

    Instead of directly training a large model with expensive RL, this method measures how an RL run changes a small model's policy (the 'policy shift'). This shift is then used as a dense reward signal to distill knowledge into the larger target model.

  2. Efficiency Gains

    The technique offers substantial cost savings. For example, training a 7B model via RL might take 320 hours, while using distillation from a 1.5B model's policy shift can reduce the estimated time to around 164 hours.

  3. Methodological Blurring

    The process blurs the line between traditional RL and knowledge distillation by combining two types of losses: the policy shift signal (from RL) and a standard KL term, making the overall training setup highly efficient.

Watch on YouTube Full article

Evolution of agentic surfaces — Gagan Bhat & Isabella Kai He, Anthropic thumbnail

· 31:24

Evolution of agentic surfaces — Gagan Bhat & Isabella Kai He, Anthropic

The evolution of agentic surfaces (from the Messages API to Claude Managed Agents) addresses the challenge that static harnesses become limiting factors as underlying LLMs improve. The core architectural shift is decoupling the agent's 'brain' (the reasoning loop) from its 'hands' (the tool execution environment/sandbox). This separation significantly improves reliability, allows for parallel setup, and boosts performance by achieving up to 60% faster time-to-first-token at P50. Managed Agents provide production-grade infrastructure—including session logging, credential vaults, and self-hosted sandboxes—enabling developers to focus on defining the agent's task and context rather than managing complex operational overhead.

Key takeaways

  1. Harnesses Encode Stale Assumptions 11:42

    As models improve (e.g., Opus 4.5 eliminating 'context anxiety'), fixes built into older harnesses become pure overhead, adding latency or discarding cache incorrectly. Managed Agents are designed to be agile and adapt to model evolution.

  2. Decoupling Brain from Hands 20:00

    Separating the agent loop (brain) from the tool execution environment (hands/sandbox) improves reliability, allowing the brain to resume from a durable session log even if the hands fail. It also allows model reasoning to start immediately while container setup runs in parallel.

  3. Self-Improving Agents via Dreaming 27:30

    The system utilizes durable session logs and memory state, which can be fed into a periodic batch process called 'dreaming.' This process extracts new insights to automatically update the agent's memory, making subsequent sessions smarter.

Watch on YouTube Full article

The Background Check You Can't Run on an AI Agent thumbnail

· 47:43

The Background Check You Can't Run on an AI Agent

The increasing autonomy of AI agents introduces a fundamental security challenge: non-determinism. Traditional cloud-era identity systems (relying on shared secrets or basic authentication) are insufficient because they cannot verify the agent's intent or ensure its actions align with human goals. The solution requires shifting focus from simple 'who is acting' to complex 'mission identity,' which defines *what* the agent was assigned to do and provides granular, task-based authorization boundaries (hard boundaries/sandboxing) to prevent catastrophic unintended actions.

Key takeaways

  1. Non-Determinism: The Feature and the Bug 17:03

    The core capability of agents—reasoning and guessing over large data sets, leading to non-deterministic behavior—is simultaneously their greatest feature and their biggest security vulnerability. This necessitates new architectural controls.

  2. Shift from Authentication to Mission Identity 36:56

    The identity problem is evolving beyond verifying a user's existence (authentication) or even their general permissions (authorization). The new requirement is 'Mission Identity,' which defines the agent's purpose, scope, and intended actions over time, enabling accountability for delegated authority.

  3. The Need for Hard Boundaries 22:16

    To manage risk, systems must implement hard boundaries (sandboxing) that prevent catastrophic failures. This is critical because agents lack human judgment and cannot inherently distinguish between 'I know' and 'I don't know.'

  4. The Evolution of Protocols 46:47

    New protocols are emerging to solve this, including Cross App Access (an evolution of OAuth) and a net-new standard called Agent Auth. These aim to move away from long-lived shared secrets.

Watch on YouTube Full article

What Is Context Engineering? Why It Matters for AI Agents thumbnail

· 9:57

What Is Context Engineering? Why It Matters for AI Agents

The industry is shifting focus from prompt engineering—which only addresses instruction phrasing—to Context Engineering. Context Engineering is defined as the deliberate practice of structuring and optimizing all information provided to an LLM or AI agent to ensure accurate and reliable outputs. For complex agents that reason across multiple steps, context management is critical because performance can degrade (context rot) when too much irrelevant or poorly structured data is included.

Key takeaways

  1. Context Engineering vs. Prompt Engineering

    Prompt engineering focuses solely on phrasing instructions for an LLM. Context engineering, however, addresses the entire information environment provided to the model, recognizing that prompt engineering is merely one component of context.

  2. The Danger of Over-Context 3:33

    More context does not guarantee better performance. Providing too much irrelevant or poorly structured data can lead to 'context rot,' resulting in worse reasoning and increased hallucinations.

  3. Core Components of Context 4:10

    Context includes the system prompt, user query, retrieved documents (e.g., from a vector database), interaction history, tool outputs, and API results.

Watch on YouTube Full article

The Sound of Your Secrets: Teaching Your Model to Spy, So You Can Learn to Defend - David vonThenen thumbnail

· 51:32

The Sound of Your Secrets: Teaching Your Model to Spy, So You Can Learn to Defend - David vonThenen

This talk details acoustic keystroke logging—a method of intercepting typed information purely from sound rather than physical interception. The speaker outlines how deep learning models can be trained using spectrographic images derived from recorded key presses to classify specific letters (e.g., 'S'). While demonstrating the high accuracy of single-keyboard attacks (100%), the presentation shows that multi-keyboard logging is challenging but feasible, especially when combined with context prediction and spell-checking algorithms. The session concludes by emphasizing defensive measures, including two-factor authentication using physical keys and implementing strong, unique, offline password policies.

Key takeaways

  1. Acoustic Keystroke Logging Mechanism 16:22

    The attack relies on machine learning audio classification. Audio files (linear 16 format) are converted into spectrographic images (frequency over time, visualized as a heatmap), which serve as the input for training models like Convolutional Neural Networks (CNNs).

  2. Multi-Keyboard Attack Complexity 28:12

    While single-keyboard classification can achieve 100% accuracy, using multiple keyboards significantly lowers confidence scores. The problem is made solvable by decomposing the text based on space delimiters and employing spell-checking/context prediction (e.g., predicting 'hello people' from partial sound inputs).

  3. Defensive Strategies 40:50

    Defense requires layered security: use physical two-factor authentication keys (like YubiKey) instead of SMS; utilize unique, complex passwords that are not known to the user; and be aware of potential signal interference or noise.

Watch on YouTube Full article

How I Tamed Claude - Emmz Rendle - NDC Copenhagen 2026 thumbnail

· 59:38

How I Tamed Claude - Emmz Rendle - NDC Copenhagen 2026

The talk details a structured methodology for leveraging advanced coding agents, particularly Claude, to achieve production-grade code generation and maintainability. The core principle is moving away from 'vibe coding' by implementing a spec-driven workflow that enforces separation of concerns among multiple specialized AI agents (Orchestrator, Worker, Reviewer). This process emphasizes defining clear requirements, maintaining an auditable development history, and managing context to ensure the final solution is robust and reliable.

Key takeaways

  1. Spec First, Code Second 12:04

    The workflow must begin with a detailed specification (the 'spec'), which acts as the source of truth for the entire project. The speaker recommends using OpenSpec's four phases: Explore $ ightarrow$ Propose $ ightarrow$ Apply $ ightarrow$ Archive [~10:35].

  2. Separation of Agent Powers 30:30

    The system must enforce a clear separation of duties among agents. The Worker writes code, the Reviewer validates it against the spec and design, and the Orchestrator manages commits and pushes; crucially, neither the Worker nor the Reviewer can approve or commit work [~18:30].

  3. Definition of Done (DoD) 40:15

    A rigorous Definition of Done is critical for preventing scope creep and ensuring quality. This includes mandatory checks like all tests being green, achieving good coverage, running `net format` twice, and completing the entire task group [~24:15].

  4. Context Management 52:05

    To prevent agents from becoming confused or hallucinating outdated information, context must be actively managed. Techniques include using Graphify (for code mapping), Context Mode (to summarize raw output and reduce token count by 70-80%), and dedicated MCP services like Context 7 for accessing up-to-date documentation [~31:25].

Watch on YouTube Full article

Global Bias in AI: When Western Data Shapes the World - Masuma Shariff - NDC Copenhagen 2026 thumbnail

· 56:20

Global Bias in AI: When Western Data Shapes the World - Masuma Shariff - NDC Copenhagen 2026

This talk explores systemic bias in AI models caused by uneven global data representation, arguing that when training data overwhelmingly originates from Western nations (the Global North), the resulting systems fail to accurately serve or represent developing populations. The speaker details how biases accumulate across the entire AI pipeline—from data collection and annotation to model deployment—using case studies in image recognition, medical diagnostics, finance, and governance to illustrate real-world consequences like misdiagnosis and financial exclusion.

Key takeaways

  1. Bias is not static; it multiplies across the AI pipeline. 21:42

    Bias does not simply drop into a system; it accumulates and scales at every stage (data collection, labeling, training). The problem is multiplicative, meaning each stage passes the bias forward amplified, like a snowball rolling downhill. This requires mindful design before writing any code.

  2. Global data gaps lead to systemic failures in critical domains. 29:42

    Case studies show that Western-centric standards fail globally: Pulse oximeters missed dangerously low oxygen levels in Black patients due to melanin absorption [~1650]; and automated credit scoring models flagged economically active people as uncreditworthy because they rely on communal assets rather than formal bank accounts.

  3. The AI system is only as good as the data it learns from, which itself is a cultural artifact. 17:03

    Data is not neutral; it reflects the history and blind spots of those who gathered it. The speaker highlights that many global standards (e.g., Fitzpatrick scale for skin tone) were built for limited demographics, leading to non-inclusive outcomes when applied universally.

Watch on YouTube Full article

How Anthropic uses Claude Code: Agentic Software Engineering at Scale - Daisy Hollman thumbnail

· 1:00:25

How Anthropic uses Claude Code: Agentic Software Engineering at Scale - Daisy Hollman

This talk details the engineering challenges and advanced primitives required for achieving agentic software engineering at scale, particularly within large monorepos. The core thesis is that scaling agents requires sophisticated context management—moving beyond simply increasing model size to implementing abstractions like Skills, Sub-agents, and Hooks. Key focus areas include managing limited context windows (currently around 1 million tokens) by ensuring tools and knowledge are only injected when relevant, thereby enabling complex, long-horizon tasks across massive codebases.

Key takeaways

  1. Context Engineering is the New Discipline 21:45

    As agents become better at writing software, teaching them how to do it—managing context—is becoming the primary discipline of software engineering. This involves carefully selecting and injecting relevant information into the model's limited context window (the 'box').

  2. Scaling Requires Abstraction Primitives 26:45

    To handle massive codebases, simple tool definitions are insufficient. Advanced primitives like Skills (lazy system prompts), Sub-agents (out-of-context processing), and Hooks (event-driven execution) are necessary to ensure that only relevant information is consumed by the model.

  3. The Importance of Feedback Loops 17:15

    The fastest way to improve an agent's performance on a codebase is not necessarily a smarter model, but implementing tighter feedback loops (e.g., type checking, linting) that provide immediate, granular error detection during the tool-use process.

  4. Scaling Workflows Beyond Single Sessions 46:45

    For enterprise use, scaling requires managing multiple concurrent agent sessions. Techniques like using dedicated worktrees and visual cues (e.g., color coding) are essential to manage cognitive load and maintain persistent agent identities across different tasks.

Watch on YouTube Full article

From "Trust Me" to "Verify Me" - Tom van den Berg - NDC Copenhagen 2026 thumbnail

· 54:29

From "Trust Me" to "Verify Me" - Tom van den Berg - NDC Copenhagen 2026

The talk details the critical shift in software security from trusting producers to verifying artifacts through cryptographic evidence. Using the SLSA framework as a guide, the speaker demonstrates how build provenance and attestation provide verifiable proof of what was built, how it was built, and that it has not been tampered with. Key tools demonstrated include `cosign` for artifact signing and leveraging OCI registries to store signed artifacts and their associated metadata.

Key takeaways

  1. Supply Chain Attacks are the New Frontier 2:25

    Modern attacks no longer start in application code but in the build pipeline. Examples include the SolarWinds attack (2020) and recent compromises targeting CI secrets via supply chain vulnerabilities.

  2. Digest-Based Signing is Mandatory 6:10

    Relying on tags for artifact signing is dangerous because tags are mutable (can be rewritten). Security must rely on the content digest (SHA-256 hash) to ensure reproducibility and integrity.

  3. SLSA Framework Guides Verification 14:30

    The Open Source Security Foundation's SLSA framework provides a vocabulary of guidelines for securing the entire software development lifecycle, defining requirements for producers and consumers.

  4. Verification Requires Provenance and Attestation 20:05

    Build provenance is verifiable information detailing where, when, and how an artifact was produced. An attestation is a signed statement that verifies claims about the artifact (e.g., confirming successful security scans or build level).

  5. Security Must Be Automated and Enforced 39:10

    To make security actionable, verification must be integrated into CI/CD workflows as a mandatory deployment gate. This includes checking the SLSA build level and verifying all attached attestations.

Watch on YouTube Full article