标签 · Orchestration — Glean

Recent picks

14picks · chronological

07-23

From Loop to Graph: The Real Shift in AI Agent Improvement

This essay explores the shift from single-loop optimization to graph-structured improvement in AI agent engineering. It dissects four failure modes of single loops: Goodhart's law, blindness to target correctness, conflict among loops, and measurement decay. Mature systems employ graphs of loops—champion-challenger, drift monitoring, rollback, and audit loops—each watching and constraining others. But graphs alone fail without anchors: measures that touch reality, frozen rules, and human judgment on what 'better' means. The key is groundedness, not topology. For AI engineers, MLOps practitioners, and agent designers.

x.com · 13 min · Agent Architecture · AI Engineering · Loop Engineering

07-23

Graph Engineering with Claude: 14-Step roadmap from 0 to graph architect (Full Course)

Most multi-step agents are built as linear chains, each step waiting for the previous one, wasting parallelism and creating bottlenecks. This article introduces graph engineering for agents using Claude Code's dynamic workflows. It presents 14 steps to transform linear scripts into directed acyclic graphs (DAGs) where nodes are bounded work units with contracts (validated input/output schemas) and edges are data dependencies. Key patterns include parallel fan-out (parallel()), fan-in barriers, runtime routing, adversarial verifiers, and convergent cycles. The author provides JavaScript/TypeScript code examples and topology diagrams, showing how to scale agents from a single-threaded line to a coordinated fleet. Targeted at engineers building complex agent systems who want to improve throughput, reliability, and cost efficiency.

x.com · 21 min · Agent Architecture · Agents · Claude Code

07-10

Lessons from Building Claude Code: How We Use Skills

Anthropic engineers share practical lessons from maintaining hundreds of Claude Code skills internally. The post categorizes skills into nine types—library reference, product verification, data fetching, business process automation, code scaffolding, code quality, CI/CD, runbooks, and infrastructure ops—and offers concrete writing tips: focus on non-obvious hints, build gotchas sections, use the filesystem for progressive disclosure, avoid over-constraint, design setup flows, treat the description field as a trigger for the model, store memory (logs, JSON, SQLite), and bundle scripts/libraries to reduce token waste. It also covers distribution strategies (in-repo vs. marketplace), skill composition, and usage measurement via PreToolUse hooks. A must-read for anyone building agent-centric workflows.

x.com · 15 min · Agent Engineering · Agent Skills · Anthropic

07-04

Superpowers: How to Make an AI Agent Run All Night and Deliver Usable Results

The author shares their journey from a failed attempt at orchestrating long-running AI agent tasks to discovering the Superpowers Skill Set, which solves the core pain points. Superpowers decomposes the development workflow into three phases: brainstorming, writing-plans, and executing-plans (with subagent-driven-development). Key design elements include: using separate prompt templates (implementer, spec-reviewer, code-quality-reviewer) to enforce separation of concerns; spinning up a fresh subagent for each task to avoid cascading context pollution; using hard constraints like "Never/HARD-GATE" to prevent agent deviation; and enforcing software engineering best practices such as TDD, DRY, and YAGNI. The author argues that with frontier models like Opus 4.8 and Codex GPT-5.5 now being sufficiently capable, the real bottleneck is harness design—using clear specifications and structured processes to make even cheaper models reliable for long-duration tasks.

justinyan.me · 4 min · Agent Architecture · Agent Engineering · Context Engineering

07-01

Micro-Agent: Beat Frontier Models with Collaboration inside Model API

The vLLM Semantic Router proposes a different take: a router is not just a request dispatcher but an amplifier of model capability. The core idea is to encapsulate multi-model collaboration inside a single model API call. The user sees one model endpoint (vllm-sr/auto), but behind it the router can automatically select a collaboration pattern — from cost-aware escalation (Confidence), parallel aggregation (Ratings), repeated mixture-of-model reasoning (ReMoM), disagreement-as-signal (Fusion), to budgeted micro-agent workflows (Workflows). These patterns are controlled, configurable, observable runtimes, not application glue. Benchmarks on LiveCodeBench, GPQA-Diamond, and Humanity's Last Exam show the closed-model collaboration scheme (VSR Closed) achieving 92.6%, 96.0%, and 50.0% respectively, matching or beating single frontier models like Fugu Ultra and GPT-5.5. This article is valuable because it sinks multi-model collaboration from the product or application layer down to the serving infrastructure layer, while preserving a single model identity. For engineers building inference routing, multi-model strategies, or cost optimization.

vllm.ai · 14 min · AI Engineering · Cost Optimization · LLM

06-25

How 1 Claude Agent Runs 10 Others · 9 Steps Swarm Loop

This post breaks down a 9-step pattern for running multiple Claude Code subagents in parallel without chaos. The key insight is that launching many agents is easy and usually messy; the skill is in the orchestration loop: verify the task is splittable, have the lead agent decompose it into atomic subtasks with human approval, isolate each agent via Git worktrees to prevent file collisions, then fan out in parallel. A SubagentStop hook gates every result (tests + lint), a grader scores each against a rubric and automatically sends weak ones back for revision, and finally only the lead agent merges passing results in dependency order. The entire loop can be packaged as a reusable skill or slash command.

x.com · 10 min · Agent Architecture · Agent Engineering · Claude Code

06-24

Loop Engineering: How One Loop Ships 259 PRs a Month

This article breaks down the engineering of AI-driven development loops, contrasting a single engineer shipping 259 PRs in a month with a runaway loop that burned $47,000. It dissects six essential components—state file, automation/scheduling commands (e.g., /loop, /schedule, /goal), git worktrees, skills, MCP connectors, and sub-agents (writer vs. checker)—with concrete configuration examples for both Claude Code and OpenAI Codex. The piece provides a brake configuration template (max_turns, max_budget_usd, scope, circuit_breaker), describes four failure modes, and offers low-cost starting strategies. Aimed at engineers building or evaluating AI agent workflows.

x.com · 12 min · Agent Engineering · Ai Tooling · Claude Code

06-23

From Prompting Agents to Loop Engineering

The AI coding community is shifting from prompting agents manually to designing loops that prompt agents for you. This is the most practical, production-oriented guide available: what an agent loop is, why it matters, and what one looks like in the real world. The author breaks down the six mandatory components (trigger, isolation, written-down context, tool reach, second-agent checker, on-disk state), then illustrates with two concrete examples: a PR babysitter that checks every 15 minutes and auto-fixes CI failures, and Claude Code's /goal command. It also covers where cost actually goes (iterations, not tokens), when not to loop (one-shot edits, unbounded exploration), and predictable failure modes (verification burden stays human, comprehension debt, silent drift).

x.com · 15 min · Agent Engineering · Agent Loop · CI/CD

06-17

How to build a self-improvement loop for your Skills

This article demonstrates a practical approach to building a self-improvement loop for AI Skills using inner and outer agent loops. The inner loop triggers a cloud agent via GitHub Action on each new issue, applying a triage Skill to classify it. The outer loop runs daily, reviews all human corrections (label changes and comments), and generates a diff to update the Skill file, which is then merged back. The author uses Warp's Oz cloud agent platform for issue triage, providing complete code and a sample repo. The pattern is generalizable to code review, bug fixing, and incident response. Suitable for engineers building AI agents who want to improve skill quality over time.

x.com · 4 min · Agent Engineering · Agent Infrastructure · Orchestration

06-15

Decomposing the agent harness into swappable workers: the iii engine architecture

Mike Piccolo argues that monolithic agent frameworks force a tradeoff by bundling the loop, tools, memory, and orchestration into one block, which long-running teams inevitably rewrite. He walks through the iii engine's production worker stack, where all thirteen harness responsibilities—credential resolution, policy checks, turn FSM, session persistence, budget tracking, etc.—are decomposed into 11 independently replaceable workers. Each worker connects to the engine via WebSocket and registers functions and triggers using a single primitive (iii.trigger()), making the harness a composable set of installable workers. The post provides a step-by-step trace of a turn through provisioning, streaming, policy-gated tool dispatch, and reactive approval wake-ups, alongside concrete examples of swapping the model catalog, adding a provider, or integrating a Slack approval surface. The core bet: an agent harness should be a slider of composable workers rather than a framework you fork. This is for backend engineers building or scaling custom agent infrastructure who are hitting the composability limits of existing frameworks.

x.com · 20 min · Agent Architecture · AI Engineering · Observability

06-13

Claude Agents & Skills for Investment Banking, Research, PE, and Wealth Management

Anthropic's official reference implementation of Claude agents for financial services, offering 9 end-to-end workflow agents for investment banking, research, PE, and wealth management, along with 8 vertical skill packs and 12+ MCP data connectors. Everything is file-based (Markdown/YAML), installable as Cowork plugins or deployable via Managed Agents API. Designed for technical teams who need ready-made finance AI workflows while retaining full customization.

github.com · 19 min · Agents · Anthropic · Financial-Services

06-09

Loop Engineering: Designing the System That Prompts Your Coding Agents

Addy Osmani argues that interacting with coding agents is shifting from prompt engineering to 'loop engineering'—designing a system that autonomously discovers tasks, delegates work, and verifies results using five building blocks: scheduled automations, parallel worktrees, project skills, connector plugins, and checker sub-agents. He maps how Claude Code and Codex both implement all five, noting that the leverage point has moved from writing good prompts to architecting persistent loops. The post cautions that loops amplify existing problems: verification, comprehension debt, and cognitive surrender become sharper risks. Intended for senior engineers evaluating how to productize AI coding tools beyond one-shot interactions.

x.com · 14 min · Agent Architecture · AI Agents · AI Engineering

06-08

How to Master Dynamic Workflows in Claude Code: 6 Patterns and 14 Steps

This article provides a systematic guide to Dynamic Workflows in Claude Code, shipped in late May 2026. It moves beyond manual prompt chaining by letting Claude generate a bespoke JavaScript harness for a specific task. The author first explains the mental model: how workflows structurally fix agentic laziness, self-preferential bias, and goal drift inherent in single-context sessions. It then breaks down six core patterns—classify-and-act, fan-out-and-synthesize, adversarial verification, generate-and-filter, tournament, and loop until done—each with code skeletons. Real-world use cases show how to compose patterns for migrations, deep research, triage, and lightweight evals. Practical controls like /goal, /loop, token budgets, and the quarantine pattern for untrusted inputs are covered. It also advises on saving successful workflows and shipping them as Skills. This guide is for engineers aiming to tackle long-running, parallel, or adversarial tasks beyond a single Claude Code session.

x.com · 17 min · Agents · AI Engineering · Anthropic

06-04

A harness for every task: dynamic workflows in Claude Code

Anthropic engineer Thariq Shihipar details dynamic workflows in Claude Code, where Claude auto-generates custom JavaScript harnesses to orchestrate multiple subagents. It explains how this overcomes single-context-window failures like agentic laziness, self-preferential bias, and goal drift. Common patterns such as classify-and-act, fan-out-and-synthesize, adversarial verification, and tournament are illustrated with concrete use cases from migrations and deep research to root-cause analysis. The post candidly advises that workflows are token-heavy and not needed for routine coding, offering practical tips on token budgets, saving workflows as skills, and pairing with /goal and /loop.

x.com · 15 min · Agent Architecture · Agents · Ai Tooling