Topic

Agentic Workflow

All digests tagged Agentic Workflow

· 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

· 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

· 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