Topic

Agentic Workflow

All digests tagged Agentic Workflow

How to go from your agent's traces to a fine-tuned model in one workflow thumbnail

· 9:01

How to go from your agent's traces to a fine-tuned model in one workflow

This walkthrough introduces LangSmith Fine-Tuning and the SmithTune CLI, providing a single, end-to-end workflow to convert agent traces (trajectories) into custom, fine-tuned models. The process involves dataset creation and preparation from LangSmith trajectories, training using providers like Fireworks or Baseten, and subsequent evaluation, all managed through the SmithTune CLI. The overall workflow is: Create $\rightarrow$ Prepare $\rightarrow$ Plan $\rightarrow$ Train $\rightarrow$ Evaluate $\rightarrow$ Deploy.

Key takeaways

  1. Supervised Fine-Tuning (SFT) Purpose

    SFT teaches a model desired behavior (e.g., tool selection, workflow adherence) using 'golden examples' derived from agent traces, improving task accuracy and tool reliability.

  2. Trajectory Format Importance 0:01

    The LangSmith trajectory format is critical because it provides a detailed reconstruction of the agent's context, including tools available at each turn, which is necessary for post-training jobs.

  3. SmithTune Workflow Overview 0:02

    The process starts by pulling trajectories from a LangSmith tracing project, defining a task-specific rubric, having a model council judge the traces, and then pushing the approved traces back to LangSmith to form a training dataset.

  4. Training and Evaluation 0:07

    After preparing the dataset (specifying provider, base model, and splits), the user runs `smithtune plan` to review settings, followed by `smithtune train` to execute the job. Evaluation compares the fine-tuned model against the base model on held-out test data.

  5. Deployment 0:08

    If results meet quality targets, `smithtune deploy` is used to serve the tuned model and connect it to the application. Otherwise, the process iterates by refining examples or training settings.

Watch on YouTube Full article

Full Course: Spec-Driven Development with Coding Agents thumbnail

· 1:01:34

Full Course: Spec-Driven Development with Coding Agents

Spec-Driven Development (SDD) is presented as the disciplined, professional workflow for building complex applications using coding agents, moving beyond 'vibe coding.' SDD mandates that the developer focuses on writing a detailed specification (the 'what' and 'why') before the agent implements the code (the 'how'). The process involves establishing a project Constitution, defining feature specs, and following a structured loop: Plan $ ightarrow$ Implement $ ightarrow$ Validate $ ightarrow$ Replanning. This approach minimizes context decay, improves intent fidelity, and keeps the human developer in the role of the senior architect and supervisor.

Key takeaways

  1. Three Main Benefits of SDD

    SDD allows control of large code changes with small spec changes (e.g., changing from SQLite to MongoDB). It eliminates context decay between sessions, preserving non-negotiable context. Finally, it improves intent fidelity by forcing the definition of problem, success criteria, and constraints.

  2. The SDD Workflow Loop 5:20

    The process is iterative: 1) Define the Project Constitution (Mission, Tech Stack, Roadmap); 2) Plan the Feature; 3) Implement the Feature; 4) Validate the Result; 5) Replanning (updating the Constitution/Roadmap). This loop is crucial for managing versioning and reducing cognitive debt.

  3. Agent Standards and Automation 20:00

    The workflow can be automated using 'Skills' (a package of instructions/resources) and benefits from industry standards like the Agent Client Protocol (ACP) and Model Context Protocol (MCP), allowing developers to switch between different coding agents (e.g., Claude Code, Codeex) while maintaining the SDD workflow.

Watch on YouTube Full article

Ship a GitHub PR From a Slack Message with Managed Deep Agents thumbnail

· 3:27

Ship a GitHub PR From a Slack Message with Managed Deep Agents

This walkthrough introduces Patch, an agent built using LangChain's Managed Deep Agents (MDAs). Patch automates the process of converting natural language feature requests from a Slack message into a fully drafted GitHub Pull Request (PR), complete with descriptions and code changes. The agent successfully demonstrated implementing features (e.g., adding a share button, changing the background color) for a Tetris side project, proving that complex integrations—including Slack communication, GitHub interaction, and code sandboxing—can be achieved with minimal code.

Key takeaways

  1. Slack-to-GitHub PR Automation

    Patch allows development discussions held in Slack to immediately trigger the creation of a GitHub PR, eliminating the need for manual PR drafting and code sharing via screenshots.

  2. Multi-System Integration Simplicity 2:09

    Managed Deep Agents simplify connecting disparate systems (Slack, GitHub, Sandbox) into a single agent workflow using only a few lines of code.

  3. Agent Configuration Components 2:31

    The agent's functionality is defined by modular files: `agent.py` (defines the agent name and model, e.g., Claude Sonnet 5), `instructions.md` (specifies goals and procedures), and dedicated connectors for Slack, GitHub, and the sandbox.

Watch on YouTube Full article

Self-Compact Pi Agent: ZERO HYPE Agentic Coding Devlog thumbnail

· 30:03

Self-Compact Pi Agent: ZERO HYPE Agentic Coding Devlog

This devlog introduces the concept of a self-compacting Pi Agent, addressing the critical limitation of context window size in long-running autonomous agent systems. The core innovation is giving the agent the ability to autonomously manage its own context by calling a dedicated tool. By implementing three distinct compaction thresholds (Notice, Warning, and Force), engineers can significantly improve agent reliability, reduce operational costs, and enable scalable, out-of-loop agentic coding workflows.

Key takeaways

  1. Self-Aware Context Management 2:00

    Instead of relying on default compaction settings, the agent is given a dedicated tool to monitor its context window and decide the optimal moment to compact its memory, which is crucial for long-running autonomous swarms (e.g., Fable or Astra swarms).

  2. Three-Tiered Compaction Thresholds 4:10

    The system utilizes three distinct thresholds—Notice, Warning, and Force—to provide the agent with a wide gap for natural stopping points, followed by a short gap before the hard cutoff, maximizing the agent's ability to decide when to compact.

  3. Advanced Prompt Engineering for Control 5:50

    Full control is achieved by overriding the default compaction prompts provided by agent decoding tools (like CodeX or Pi Agent). This includes defining a 'note to self' that survives the summary, enhancing the agent's self-correction capabilities.

  4. Out-of-Loop Scalability 7:30

    The self-compacting mechanism is essential for scaling agents from in-loop to out-of-loop operations, enabling reliable, long-horizon work where human intervention is not present.

Watch on YouTube Full article

Agentic approaches to processing long videos with Gemini thumbnail

· 1:31

Agentic approaches to processing long videos with Gemini

Agentic video understanding with Gemini allows developers to process long-form videos without submitting the entire content, which could exceed 100,000 tokens. Instead, the model uses an agentic loop (thinking, acting, observing) and specialized tools—such as `get transcript`, `get frames`, and audio extraction—to iteratively zoom in on relevant information, significantly reducing token usage and improving processing performance.

Key takeaways

  1. Token Efficiency

    By using an agentic approach, the model avoids submitting the entire video content (which can exceed 100,000 tokens), leading to massive token reductions and lower latency.

  2. Agentic Workflow

    The process involves the model first determining necessary tools (e.g., `get transcripts`, `get frames`) before executing a traditional agentic loop of thinking, acting, observing, and iterating until the answer is derived.

  3. Targeted Analysis

    This technique improves performance by allowing the model to 'zoom in' on specific functions or segments within the video that are most relevant to the query, rather than processing all data equally.

Watch on YouTube Full article

Lada Kesseler: I Trust AI Tests Less Than AI Code thumbnail

· 45:51

Lada Kesseler: I Trust AI Tests Less Than AI Code

Lada Kesseler discusses advanced agentic workflows, arguing that achieving quality with AI agents requires structured 'loop engineering' rather than expecting perfect first attempts. She emphasizes giving agents explicit missions to disagree with and recommends techniques like iterative refinement (the 'centrifuge') and using specialized skills (like TDD) via front matter activation. For build engineers, the core message is shifting from monolithic code generation to modular, verifiable processes that manage complexity through deterministic triggers and layered testing.

Key takeaways

  1. The Centrifuge Principle 11:39

    Quality requires iterative refinement; do not expect AI-generated output to be perfect on the first try. The process involves taking one step, committing it to a file, reading it back, identifying flaws, and repeating the loop until satisfactory (00:13:09).

  2. Agent Ground Rules are for Agents, Not Humans 10:22

    The 'ground rules' or system prompts must give the model a mission to disagree with you (e.g., 'Don't try to please me') rather than just listing best practices. The description field in an agent skill is intended for machine activation, not human readability (00:10:02).

  3. Sketch Prototypes with Markdown 20:43

    For early-stage architecture or complex problem spaces, replace code with a markdown file and an agent. This allows the user to experience the workflow's user experience without committing to production code, serving as a fast, low-fidelity prototype (00:20:43).

  4. Deterministic Verification is Key 27:28

    Use 'verifiers' or deterministic triggers that check for specific standards (e.g., long methods, adherence to style guides) across various files, providing far better results than a single general code review prompt (00:35:29).

Watch on YouTube Full article

Intelligence EXPLOSION: Harness Engineering with Pi Agent, Deepseek, and Gemini thumbnail

· 28:05

Intelligence EXPLOSION: Harness Engineering with Pi Agent, Deepseek, and Gemini

The video addresses the current 'Intelligence Explosion' in Large Language Models (LLMs), noting rapid model releases and aggressive pricing wars. The core thesis is that modern agentic engineering requires moving beyond selecting a single best-in-class model; instead, engineers must build flexible systems to combine compute from multiple models (e.g., Gemini 3.7 Flash, Deepseek V4 Pro, Claude Fable 5) to achieve superior performance, speed, and cost efficiency. The speaker demonstrates three advanced multi-agent orchestration patterns—Opinion, Debate, and Collaborate—using a custom Fusion Harness V2.

Key takeaways

  1. The Principle of Flexible Systems 2:00

    In an era of rapid technological change, the most flexible system wins. Engineers should focus on combining compute rather than selecting a single model (Combine compute, don't select compute).

  2. Multi-Agent Orchestration Patterns 7:10

    Three advanced patterns are demonstrated for leveraging multiple LLMs: **Opinion** (fire one prompt to N models for diverse perspectives); **Debate** (agents argue a claim across multiple rounds, sharing refutations and positions); and **Collaborate** (models propose plans which an 'architect agent' merges into a structured task list with dependencies).

  3. Cost-Performance Analysis 10:20

    While state-of-the-art models like Claude Fable 5 are powerful, they can be vastly more expensive than 'A tier' workhorse compute (e.g., Gemini 3.7 Flash or Deepseek V4 Pro), offering better effective agent hour per token cost.

Watch on YouTube Full article

Building Docs for Agents, Not Humans: Inside OpenWiki thumbnail

· 16:52

Building Docs for Agents, Not Humans: Inside OpenWiki

OpenWiki is an open-source Command Line Interface (CLI) designed to automatically generate and maintain repository documentation specifically optimized for consumption by coding agents. Unlike human-centric wikis, OpenWiki structures content into self-contained, highly searchable snippets using the Open Knowledge Format (OKF). It integrates deeply into a codebase via GitHub Actions, ensuring that documentation remains current with every code change while minimizing manual effort.

Key takeaways

  1. Built for Agents, Not Humans 5:04

    OpenWiki's core thesis is that since agents are increasingly writing code, the documentation must be structured for agent retrieval. This means content must consist of self-contained snippets with predictable headings and optimized context window usage, rather than long narrative pages.

  2. Automatic Maintenance via CI/CD

    The CLI facilitates automatic documentation updates by writing a GitHub Actions workflow. This action runs periodically (e.g., daily), checks the Git history, and uses an agent to generate or update the wiki based on code changes, minimizing manual intervention.

  3. Adoption of Open Knowledge Format (OKF) 11:48

    The system adopts OKF (Google's Open Knowledge Format) by adding a deterministic YAML front matter to every markdown file. This includes fields like `type`, `title`, and `description`, which significantly improves retrieval, filtering, and searching capabilities for agents.

  4. Performance Gains in Benchmarks 15:00

    Early evaluations using the DeepSWE benchmark show that OpenWiki usage leads to fewer tool calls, fewer searches, and a significant drop in token consumption for coding agents while maintaining or improving results.

Watch on YouTube Full article

60% Faster Time-to-Interview: Transforming Hiring with AI Agents with LangChain thumbnail

· 18:05

60% Faster Time-to-Interview: Transforming Hiring with AI Agents with LangChain

LinkedIn details the architecture of a hiring agent built with LangChain and LangGraph that successfully cut time-to-interview by 60% for small businesses. The system evolved from static workflows to an advanced agentic control model utilizing a central planner within a plan-execute-replan loop. Key architectural components include specialized memory types (conversational and experiential), middleware hooks for PII detection, and rigorous 'harness engineering' techniques—such as state flag chaining and one-shot tool guards—to ensure the probabilistic nature of LLMs results in a dependable product.

Key takeaways

  1. Hiring is an Agent Problem

    The hiring process is inherently iterative (plan, act, observe, adapt), requiring continuous adaptation rather than being a one-shot task. This necessitates an agentic approach.

  2. Architectural Evolution to LangGraph 0:03

    The system progressed from hard-coded static workflows (if/then) to sequential LangChain chains, culminating in LangGraph for its true agentic control model featuring a central planner and plan-execute-replan loop.

  3. Choosing LangGraph 0:05

    LinkedIn selected LangGraph over 89 evaluated frameworks because it complements existing infrastructure, builds upon core LangChain primitives (runnables, tools), and allowed for zero rewrite adoption.

  4. Achieving Determinism via Harness Engineering 0:10

    To make the agent dependable, LinkedIn implemented advanced 'harness engineering' techniques, including context management (checkpoint trimming), output format determinism (template confirmation/fallbacks), and node-change determinism (state flag chaining and one-shot tool guards).

Watch on YouTube Full article

Patrick Debois Maps the Patterns of AI-Native Dev thumbnail

· 47:39

Patrick Debois Maps the Patterns of AI-Native Dev

Drawing parallels between DevOps and AI evolution, Patrick Debois outlines a new socio-technical map for AI-native development. The shift requires organizations to move beyond simple coding capability by mastering structured patterns (Prompting $ ightarrow$ Context $ ightarrow$ Harness $ ightarrow$ Loop Engineering). Success hinges on building shared platforms, optimizing processes through continuous feedback loops, and shifting organizational focus from measuring token usage to improving contributions to shared components.

Key takeaways

  1. AI Maturity is Continuous Exploration 10:36

    Debois argues there is no single 'maturity' point; the field requires constant adaptation across Prompting, Context, Harness, and Loop Engineering. The goal is continuous learning and adapting processes rather than reaching a fixed state.

  2. The Four Layers of AI Enablement 18:39

    AI adoption must be addressed at four levels: Agent enablement (the technology), Team enablement (shared components/libraries), Platform enablement (centralized tools like registries and evals), and Organization enablement (process change).

  3. Shift Measurement from Usage to Contribution

    Effective measurement for AI adoption should focus on how much people are contributing to shared components and fixing the system, rather than solely measuring token usage or license counts. This metric reflects true organizational improvement.

  4. Hiring System Thinkers Over Coders 43:52

    The most valuable skill in the AI era is being a 'system thinker'—someone who cares about architecture and reliability, not just writing elegant code. Adaptability and open-mindedness are paramount.

Watch on YouTube Full article

The DevOps Godfather on AI's "Dark Factory" Problem thumbnail

· 22:25

The DevOps Godfather on AI's "Dark Factory" Problem

Patrick Debois argues that the industry is approaching a 'dark factory' model of autonomous coding agents, mirroring historical skepticism around Continuous Delivery [0:02:51]. He emphasizes that success hinges not on better prompts or larger models, but on fundamentally restructuring teams and platforms. The developer role shifts from solo coder to agent orchestrator, requiring improvements in system-level engineering practices (e.g., building tooling for the agents) rather than just fixing the code produced by the agent [0:09:49]. Scaling this requires platform teams to centralize reusable components like skill registries and guardrails, moving organizations from a 'solo developer' model to a 'multiplayer system' [0:10:53].

Key takeaways

  1. Shift from Coder to Orchestrator 5:21

    The modern developer role evolves into that of an agent conductor or orchestrator, managing and guiding autonomous agents rather than writing all the code themselves. This requires a focus on system improvement over individual code fixes [0:02:51].

  2. Focus on Systemic Improvement 9:49

    The key mentality shift is to stop fixing the agent's output code and instead improve the underlying system, context, and tooling (harnesses/loops) that guide the agents [0:09:49].

  3. Platform Team Centralization 20:53

    To scale autonomous development, platform teams must own centralized components—such as skill registries, guardrails, and reusable harnesses—to prevent organizational sprawl and ensure consistency across teams [0:10:53].

  4. New Productivity Metrics

    Instead of measuring token spend, focus on two metrics: the number of human touches required for the agent to succeed, and the multiplier effect gained when a single system improvement benefits all users/teams [0:14:50].

Watch on YouTube Full article