Topic

Workflow Orchestration

All digests tagged Workflow Orchestration

Agents & Arbiters - An Adventurer’s Guide to Multi-Agent Collaboration with LangGraph.js - Guy Royse thumbnail

· 59:56

Agents & Arbiters - An Adventurer’s Guide to Multi-Agent Collaboration with LangGraph.js - Guy Royse

The talk introduces multi-agent collaboration using LangGraph.js as an advanced pattern for building complex, interactive systems that move beyond fragile, scripted logic. Instead of anticipating every user action with nested `if` statements, the system uses autonomous agents (LLMs) to contribute perspectives and make decisions. The architecture is built around a graph structure that orchestrates specialized nodes—including routers, experts, arbiters, and committers—to manage state changes and generate coherent responses.

Key takeaways

  1. Agent Definition 24:28

    An agent is defined as an LLM with a system prompt defining its purpose, coupled with a collection of tools that allow it to interact with the world. These agents are composable within a graph structure.

  2. Graph Workflow Components 34:05

    The system uses an orchestration workflow (router, classifier, agents, arbiter, committer) to manage complex interactions. The router determines which specialized nodes are relevant for a given input, and the arbiter reconciles conflicting suggestions from multiple agents.

  3. Conditional Edges 38:38

    Conditional edges allow the graph's flow to be determined by an LLM's reasoning over the current state, enabling patterns like the Supervisor pattern and the ReAct (Reasoning and Acting) cycle. This is crucial for dynamic decision-making.

  4. State Persistence and Memory 48:50

    To solve context loss, the architecture utilizes a dedicated Agent Memory Server (a library/Docker image) that automatically compacts message history and extracts long-term facts asynchronously, providing continuous memory across sessions.

Watch on YouTube Full article

Stateless, Yet Durable: MCP Tasks v2 thumbnail

· 26:23

Stateless, Yet Durable: MCP Tasks v2

The session details MCP Tasks v2, an architectural evolution designed to enable durable, long-running workflows while maintaining a fundamentally stateless protocol design. Using Purchase Order processing as a concrete example, the talk contrasts the complexity and scalability issues of V1 (which relied on stateful server tracking and polling) with the simplified V2 approach. The key shift involves moving client responsibility for task ID persistence to durable storage and introducing a future notification mechanism to replace inefficient constant polling.

Key takeaways

  1. MCP Tasks v2 Simplification 17:53

    V2 eliminated the complex `task list` functionality (due to scalability concerns) and significantly changed how elicitation flows, simplifying the client-server protocol into basic polling and an explicit `update` API.

  2. Durability vs. Statelessness 4:28

    While the MCP protocol is stateless, the tasks themselves are designed as durable state machines (e.g., invoice processing), requiring robust mechanisms to track their lifecycle states (Working, Input Required, Terminal).

  3. Scaling Beyond Polling 23:50

    For massive scale (millions of tasks), constant polling is inefficient. The future direction involves implementing a notifications mechanism within the MCP Tasks protocol to allow idle tasks to consume zero resources until an event occurs.

Watch on YouTube Full article

Inside Kikimora: We Built a Dark Software Factory thumbnail

· 15:51

Inside Kikimora: We Built a Dark Software Factory

The video details the concept of a 'Dark Factory'—an autonomous software development model where processes run without continuous human supervision. The shift was catalyzed by coding agents (like Claude Code) accelerating development speed, which exposed bottlenecks in traditional workflows. This led to building internal orchestrators (e.g., Kikimora, Night Shift) that automate tasks from issue creation (Linear) through code generation and PR management (GitHub), fundamentally changing the role of the engineer from primary coder to system architect and trust validator.

Key takeaways

  1. The Dark Factory Concept 2:05

    A dark factory is an autonomous software building process where no humans are required for supervision. The core workflow involves creating a Linear issue, which is then picked up by an autonomous agent that solves it and opens/manages a GitHub PR until merge.

  2. The Bottleneck Effect 3:23

    As coding agents increased development speed (starting around November), existing processes designed for slower software began to break down, forcing the company to adopt a fundamentally different, highly autonomous model.

  3. Shift in Engineering Value 11:20

    The value of an engineer shifts from writing code (which agents can do better) to understanding complex system constraints, business logic, and the overall interlocking technical architecture. Trust in the automated results becomes the critical skill.

Watch on YouTube Full article

Grok Bot Is The First AI Agent You Just Install. Is It Worth $200? thumbnail

· 18:56

Grok Bot Is The First AI Agent You Just Install. Is It Worth $200?

Grokbot is presented as a consumer multi-agent product that significantly lowers the barrier to entry for AI automation, making advanced agent capabilities accessible to non-technical users. The system operates on a single, dedicated cloud computer (the security perimeter), which allows agents to seamlessly integrate with services like email and calendars through simple authorization processes. While the subscription cost is high ($200/month), its value proposition lies in its ability to automate complex business functions—such as building a storefront or managing an entire workflow—that would otherwise require significant manual effort.

Key takeaways

  1. Simplified Agent Integration

    Grokbot solves the 'agent signup pain point' by centralizing authorization. Users authorize services (e.g., email, calendar) once within one conversation with one bot; this authorization applies across all other bots and services used on the platform. This process uses remote login screens rather than requiring plain text passwords.

  2. Centralized Security Perimeter 2:00

    The entire system operates within one dedicated cloud computer (located in Silicon Valley), establishing a single security perimeter. Adding more agents does not increase this risk, providing greater confidence than systems relying on multiple scattered machines.

  3. High-Value Automation Bots 8:10

    Recommended bots include the 'Superdoerbot' (which proactively works on real tasks like drafting presentations based on calendar events) and the 'Business In a Box' bot, which helps users build and manage an entire business using AI agents.

  4. Technical Accessibility 0:10

    Grokbot is designed to be non-technical ('No code, just install'), crossing the chasm that previously required users to understand complex agent setups (like those needed for OpenClaw or Codex).

Watch on YouTube Full article

Stanford CS329A Self-Improving AI Agents | Part 1 | Course Overview thumbnail

· 1:09:42

Stanford CS329A Self-Improving AI Agents | Part 1 | Course Overview

This course overview details the evolution of Large Language Models (LLMs) from simple predictive models to complex, self-improving agents. Key advancements include understanding scaling laws based on parameters, compute, and data size; developing advanced reasoning capabilities through Chain-of-Thought (CoT); and moving beyond single-turn chat interactions into sophisticated agentic workflows. The focus shifts to building systems that can plan, interact with external tools, self-correct using verifiers, and achieve end-to-end goals in domains like software engineering and data analysis.

Key takeaways

  1. LLM Scaling Laws 2:20

    Model performance improves significantly by scaling up parameters, compute (compute on the x-axis), or dataset size. This exponential growth has been foundational for models like GPT-3 and PaLM.

  2. Agentic Workflows vs. Chatbots 17:05

    Modern LLM applications are moving from single-turn chat formats to complex agentic workflows (e.g., Deep Research, Cloud Code). These systems can take a goal, plan steps, interact with environments/tools, and correct their actions until the goal is achieved.

  3. The Role of Verifiers 22:00

    In agentic systems, verifiers (like unit tests for code) are crucial feedback mechanisms. They allow models to verify generated outputs and guide self-correction, which is essential in verifiable domains like math and coding.

  4. Self-Improvement Loop 27:30

    The most advanced frontier involves combining test time scaling (e.g., repeated sampling) with fine-tuning to generate synthetic, high-quality data. This creates a self-improving loop where the model trains on its own generated solutions.

Watch on YouTube Full article

Inside the Dark Factory: AI That Ships Code Solo thumbnail

· 58:39

Inside the Dark Factory: AI That Ships Code Solo

The video details Tessl's 'Dark Factory,' an autonomous system that handles a significant portion of their code shipping (65-70% of PRs). This factory uses AI agents and sophisticated verification layers to process tickets from inception (Linear) through to merge. The core architectural shift involves moving engineering focus from writing code to designing robust, automated workflows, emphasizing context management and layered verification to build trust in autonomous systems.

Key takeaways

  1. High Automation Rate 2:24

    Tessl routes 65-70% of its PRs through the Dark Factory. Historically, up to 95% of their codebase has never been reviewed by a human.

  2. Shift in Engineering Focus 17:12

    The role of the engineer shifts from implementing tickets to designing complex workflows, scoping tasks for agents, and encoding organizational 'taste' into verification layers (e.g., whiteboarding conversations).

  3. Trust is Earned, Not Enabled 31:00

    Building trust in the Dark Factory requires continuous effort, including running into failure modes and improving verification layers. Accountability remains with the person who filed the original ticket.

  4. Verification Layers are Key 22:22

    The most critical component is not the coding agent itself, but the layered verification system (Verifiers) that allow engineers to encode fuzzy principles (e.g., 'library should be the single source of truth') into deterministic checks.

Watch on YouTube Full article

Your agent architecture has a half-life of 6 months — Dan Farrelly, CTO, Inngest thumbnail

· 19:20

Your agent architecture has a half-life of 6 months — Dan Farrelly, CTO, Inngest

The talk addresses the rapid obsolescence of AI agent architectures, noting that their 'half-life' can be as short as six months due to evolving models and frameworks. The core thesis is that engineers must build systems by focusing on three decoupled conceptual layers—Execution, Context, and Compute—to ensure stability. The Execution Layer is identified as the most stable component, responsible for managing flow, state durability, retries, and coordinating complex workflows regardless of changes in LLMs or prompts.

Key takeaways

  1. Agent Architecture Volatility

    AI agent architectures are highly volatile; components like prompts may last weeks, models months, and frameworks can quickly become outdated. This rapid change necessitates an architectural approach that decouples core primitives to prevent technical debt.

  2. The Three Conceptual Layers 3:30

    Effective agent design requires considering three discrete layers: the Execution Layer (the 'brain,' handling flow, state, and durability); the Context Layer (the 'knowledge,' including models, prompts, tools, and memory); and the Compute Layer (the 'hands,' involving sandboxes, runtimes, or browsers).

  3. Focus on the Execution Layer 5:20

    The execution layer must be designed to remain stable over years. It is responsible for managing the full life cycle of an agent—including planning, model calls, code running, and sub-agent invocation—independent of the context or compute used.

Watch on YouTube Full article