Slate, LangChain, and AI SDK add graph control for agent runtimes

• Graph control became the week’s agent-runtime obsession: realmcore_ on Slate called Slate a scriptable runtime for execution graphs, while jerryjliu0 described the pattern as a workflow graph around an agent harness, then an outer agent loop that creates that graph.
• Slate Programs are the sharpest demo: wearerandomlabs' Programs note says Slate drafts a diagram, lets the user inspect it, runs it, and lets the user debug broken subagents in chat.
• Durable task graphs are replacing flat todo lists in agent work: kevinkern's Planr post says Planr gives agents a persistent graph to coordinate loops and reduce mid-task stops or premature done claims.
• The pattern is broader than Slate: LangChain's OSS factory post says LangChain open-sourced pieces of a software-engineering agent factory, and ctatedev's AI SDK post shipped Python primitives for agent loops, tool calling, and streaming.
• The production boundary moved to verification, telemetry, and credentials: zeeg argued agent frameworks need end-to-end tests and traces, while Vercel's GitHub Tools update moved GitHub agent auth to short-lived scoped tokens.

Random Labs' Onyx post defines PROGRAMS (*.program.ts) and a VM for deterministic agent orchestration. The AI SDK for Python docs show an overrideable agent loop built from streaming, tool dispatch, and loop-control primitives. LangChain's dynamic subagents post describes a model writing short orchestration scripts instead of issuing subagent tool calls one turn at a time.

The live mental model moved from “agent loop” to “graph around the loop.” Fabian Stelzer compressed the timeline into five stages:

1. Workflows: scripted API calls to LLMs, then function-calling tools.
2. Agent loops: LLM plus tool calling.
3. Loop around agent loops.
4. Orchestration workflow graphs around those loops.
5. Self-modifying orchestration workflows around graphed loops.

A loop becomes a local primitive inside a larger topology in Vtrivedy10's Claude quote, which describes a loop as a one-node graph with a self-edge and an exit condition.

Zach Tratar gave the deflationary version: loops are automations, execution graphs are workflows, context graphs are mostly relational databases, and queues still allocate throughput in zachtratar's taxonomy. Correct, and mildly rude to the hype cycle.

Slate is being pitched as a runtime rather than a harness. Random Labs' Slate docs describe it as a swarm-orchestration agent that can plan with one model, search with another, execute with another, and parallelize tasks across long sessions.

The concrete unit is a Program. The flow in wearerandomlabs' Programs note is:

• Describe the program.
• Slate drafts it.
• Slate presents a diagram.
• The user asks questions about the diagram.
• Slate runs it.
• If a subagent blocks, the user debugs the program through chat.
• Workflows can carry budgets and model choices.

/deepresearch is the cleanest example surfaced in the replies: realmcore_'s deepresearch reply described it as a running program with a fan-out, explore, evaluate path, shown as execution rather than a task breakdown.

Planr attacks a different failure mode: agents stopping mid-task or claiming completion without verification. The Planr GitHub README describes a local-first coordination layer with Markdown plans, a dependency-aware work map, atomic picks, logs, reviews, evidence, and close states.

The useful mechanics are database-shaped, not chat-shaped:

• Readiness is computed from blockers.
• Picks are atomic claims, owned by one worker.
• State persists across handoffs and restarts.
• Closure requires evidence: logs, files, tests, browser proof, or reviews.
• Humans, Codex, Claude Code, Cursor, and MCP clients share the same map.

There is a UI trap here. kevinkern warned that agent apps can drift into “a second Jira,” especially when a single task spans runs, branches, or threads.

LangChain framed the same shift as a software-engineering agent factory. hwchase17's inventory listed Dcode, Open SWE, Open SWE Review, and OpenWiki as pieces of a fully open-source factory.

The underlying abstraction is graph-native. The Open SWE framework post says Open SWE is built on Deep Agents and LangGraph, with planning, file-based context, native subagent spawning, and middleware hooks for deterministic orchestration.

LangChain’s June writeup on dynamic subagents makes the mechanism explicit: the agent writes a short script, runs it in a lightweight interpreter, and uses code patterns like loops, branching, and concurrency to drive subagents.

Multi-agent defaults are still conservative. pvncher's reply says the default architecture is collaboration, not delegation, and large parallel fan-outs are restricted by concurrency settings, with four per thread as the default.

AI SDK for Python shipped the smaller building block: readable loops. The official docs call it alpha and show primitives for streaming, tool dispatch, human-in-the-loop hooks, and loop execution control in mostly plain Python.

VS Code moved in the same direction from the IDE side. The 1.129 release notes say agent sessions now run in a dedicated agent host process, terminal commands can run from chat with !, and the same session can connect to multiple VS Code windows.

The product-level phrasing in VS Code's follow-up is simpler: agents can create sessions and delegate work across conversations, and users can bring their own models to Copilot agents in the Agents window.

The graph pattern does not remove the old production checklist. Zeeg’s bar for agent frameworks was two items:

• End-to-end testing that tolerates LLM-judge assertions.
• Local and production telemetry, including traces and unhandled errors.

Zeeg later narrowed the tracing detail: tool calls need continuation headers, serverless can create new traces, and gen_ai.conversation.id does not cleanly cover multi-agent conversations in zeeg's tracing clarification.

Vercel pushed one credential seam into the tooling layer. GitHub Tools now mints short-lived, scoped tokens through Vercel Connect, and presets such as code review map to Connect scopes.

The Temporal LangGraph plugin post names the durability seam: LangGraph defines what an agent does, while recovery, human review, and long-running execution belong to an orchestration layer.