Topic

LLM Orchestration

All digests tagged LLM Orchestration

· 17:11

The Unreasonable Effectiveness of Separating the Task from the Model — Maxime Rivest, DSPy

The talk introduces DSPy, an open-source Python framework designed to bring software engineering principles—reusability, composability, and testability—to AI programs. The core philosophy is the 'unreasonable effectiveness of separating the task from the model' by defining tasks strictly through a programmatic interface called the Signature. This approach allows developers to focus on the business logic (the contract) while keeping the underlying implementation flexible for experimentation with different models, weights, and techniques.

Key takeaways

  1. The Power of the Signature

    By defining a task's inputs and outputs (the Signature) first, developers create an abstraction layer that allows them to swap out underlying implementations (models, prompts, etc.) without changing the core workflow. This provides significant agility for AI engineering.

  2. Three Pillars of Task Specification 8:00

    To fully specify an AI task, DSPy advocates using three components: 1) Instructions (what should happen), 2) Constraints/Code (what must happen, enforced by code like self-recheck or chaining), and 3) Evaluation Metrics (what good looks like).

  3. Future Direction: Automation and Learning 10:35

    DSPy is evolving toward automating implementation details. Future versions, including DSPy 4.0, aim to allow models to write code beneath a signature and enable programs to learn directly from user interactions while respecting the defined inputs/outputs.

Watch on YouTube Full article

· 1:19:54

Sandboxing, Agent Harnesses, and Agent Teamwork

The discussion explores the evolution of AI agents from simple task execution to sophisticated SRE (Site Reliability Engineering) capabilities. The core argument is that true value lies not in faster triage (Mean Time To Resolve - MTTR), but in building an agent that learns and compounds operational memory across an organization's entire stack. Key architectural shifts include moving beyond rigid, deterministic tools toward non-deterministic problem solving, requiring advanced techniques like sandboxing, environment simulation, and establishing governance structures for multi-agent teams.

Key takeaways

  1. The Value Shift: Learning over Triage 20:05

    AI agents' primary value is shifting from simply reducing MTTR to building an agent that learns from every investigation. The goal is creating a compounding operational memory, allowing the system to improve its decision-making process and predict failure modes rather than just reacting to alerts.

  2. Harnesses Define Agent Capability 3:25

    The 'harness' is defined as everything between the user and the LLM—including prompts, skills, file systems, and tools. The challenge is balancing necessary guardrails (to prevent agents from doing wrong things) with enough freedom to allow for complex, non-deterministic problem solving.

  3. The Need for Cross-Environment Testing 23:55

    Because every company's infrastructure (e.g., Gojek vs. Uber) is unique, agents cannot simply be trained on general knowledge. Durable development requires simulating and testing agent performance across diverse, idiosyncratic production environments.

  4. Future State: Agent Teams and Governance 1:03:22

    The next frontier involves multi-agent systems (e.g., a Coding Agent working with an SRE Agent). These teams require defined governance structures, similar to a RACI matrix, ensuring agents know their roles and how to share context without losing isolation.

Watch on YouTube Full article

· 31:32

Peter Wilson & Davide Eynard - cq - Stack Overflow for Agents - AI Native DevCon June 2026

The session introduces CQ (Mozilla.ai's proposal), a system designed as a 'Stack Overflow for agents.' Its core purpose is to standardize and share knowledge units (KUs) across autonomous AI agents—locally, within an organization, or publicly. This prevents agents from repeating mistakes, wasting tokens, and ensures that lessons learned by one agent can benefit all others, thereby improving the reliability of complex automated workflows.

Key takeaways

  1. Knowledge Unit (KU) Standardization 17:09

    A KU is a standardized knowledge artifact (stored in JSON format) capturing solutions to novel problems. It includes domains, insights, actions taken, summaries, and metadata (languages/frameworks).

  2. Agentic Context Management 6:15

    Effective agent performance relies heavily on context injection. The system aims to move beyond simple memory files by allowing agents to query a centralized knowledge base for relevant solutions before starting a task.

  3. Layered Sharing Model 20:40

    CQ supports three levels of knowledge sharing: local (SQLite database, no review), private/team (requires user authentication and human-in-the-loop review), and public commons (CQ Exchange).

Watch on YouTube Full article

· 34:18

FORGET Loop Engineering. Agentic Engineering is about THIS

The video argues that 'Loop Engineering' is an insufficient and inaccurate mental model for modern software development with AI agents. The superior approach is **Agentic Engineering**, which focuses on building complex AI developer workflows (ADWs) within a 'software factory.' These ADWs orchestrate three core actors of value creation—Engineers, Agents, and Code—to automate the entire development lifecycle, from planning to deployment, thereby scaling impact and accelerating development far beyond what simple loops can achieve.

Key takeaways

  1. Shift Focus from Loops to Workflows

    Loop engineering is a poor rebrand of the Software Development Life Cycle (SDLC). The focus must be on building comprehensive AI developer workflows that combine code execution with agents, rather than focusing solely on iterative loops.

  2. The Three Actors of Value Creation 2:00

    Successful agentic engineering requires understanding and strategically placing three actors: the human engineer, specialized AI agents, and deterministic code. Code is highlighted as the most reliable actor because it costs zero tokens and runs consistently.

  3. Scaling Developer Workflows 4:00

    Advanced workflows move beyond simple loops by integrating multiple validation steps (e.g., linting, type checking, formatting) and scaling compute through specialized sandboxes for parallel execution. This process is the core of building a 'software factory.'

  4. Meta-Engineering: Building the System 8:00

    The most valuable engineering effort is not working on the application layer, but performing meta-work on the agentic layer—building the system that orchestrates and manages all other components (the 'system that builds the system').

Watch on YouTube Full article

· 42:38

When millions of AI agents meet

This discussion explores the shift from traditional Large Language Models (LLMs) to autonomous AI agents capable of executing multi-step plans, transacting, and delegating tasks. The concept of an 'agentic economy' suggests a future where intelligence is distributed across specialized agents rather than residing in single systems. Key technical challenges discussed include managing agent failure rates, preventing automation bias, securing the system against malicious 'agentic traps,' and developing robust orchestration protocols for complex, real-world workflows.

Key takeaways

  1. Agent vs. Language Model 0:35

    An LLM merely provides continuation or a reply to a prompt; an AI agent observes a state of the world and performs actions in an environment (e.g., purchasing tickets, sending emails). Agents use LLMs under the hood but are wrapped in a harness that enables multi-step planning and automation [0:35].

  2. Distributed Intelligence 28:40

    The future may not be defined by Artificial General Intelligence (AGI) as a single entity, but rather by 'distributed intelligence'—a 'society of specialists.' This model suggests that specialized, smaller models are cheaper to run and more reliable than one massive generalist model [17:20].

  3. Agentic Security Risks 22:26

    The deployment of agents at scale introduces significant cybersecurity risks. These include 'agentic traps' (malicious code or prompts in the environment) and 'dynamic cloaking,' where web pages display different content for humans versus agents, potentially inducing jailbreaking [1:50].

Watch on YouTube Full article