April 2026 Summaries

Part 5 of an Agentspan multi-agent strategy series explains round robin orchestration, in which agents follow a fixed repeating order and use the complete prior conversation to refine, challenge, or support one another’s work. Agentspan is presented as a durable workflow platform for building, integrating, and observing agents, with executions that persist across failures and can be inspected through a dashboard. The example builds a code-review debate among an architect, security reviewer, and pragmatist, who complete two sequential discussion rounds before a summarizer delivers an approve, request-changes, or needs-discussion verdict. Unlike parallel reviews, which generate independent opinions simultaneously, round robin promotes convergence by letting each reviewer respond to earlier findings, such as SQL injection, path traversal, sensitive card-data logging, excessive file permissions, and potential over-engineering. The strategy is configured with `Strategy.ROUND_ROBIN` and a turn limit, can resume after interruptions from the next persisted turn, and can be combined with other patterns, such as parallel research followed by a structured debate and final summary.

Claude Code users can now enhance their workflow capabilities by integrating Conductor Skills, which enables the building, deployment, and management of entire workflows directly from the Claude terminal. Conductor, a workflow orchestration engine, allows users to define workflows consisting of tasks such as API calls, custom code, and human approvals. Conductor Skills is a plugin that simplifies workflow creation and management, making it accessible for beginners and efficient for experienced users. Conductor comes in two versions: the open-source Conductor OSS, which is free and self-hosted, and Orkes Conductor, a managed version with additional enterprise features like RBAC and AI support. Users can choose between running a local Conductor server, which requires Java, or using the hosted Orkes Developer Edition to experiment without local installations. The integration with Claude Code facilitates seamless interaction with Conductor servers, allowing users to register, monitor, and modify workflows using simple commands. This tool is particularly valuable for users who want to iterate quickly on workflows and explore various use cases, such as fetching web content or interacting with APIs, without needing extensive setup.

Part 4 of an Agentspan multi-agent strategy series introduces the swarm strategy, in which agents communicate peer-to-peer through automatically generated transfer tools rather than relying on a parent agent, fixed pipeline, or classifier to determine routing. Using a customer-support example with front-line, refund, and technical-support agents, it shows how an agent can redirect a request during execution, such as a refund specialist transferring a defective-product case to technical support for warranty handling. In Agentspan, setting `Strategy.SWARM` gives each participating agent transfer capabilities to its peers, while optional text-based handoff conditions can act as a fallback if no tool transfer occurs. The approach is contrasted with handoff and router strategies, which make an initial top-down routing decision but do not allow specialists to redirect cases themselves. Swarm workflows are described as durable server-side state machines that preserve transfer decisions across failures, and they can be composed with other strategies such as sequential pipelines or higher-level handoffs; the next installment will cover the fixed-turn round-robin strategy.

Agents such as coding assistants require more than an LLM wrapper, relying on tool access, context management, orchestration, durable state, and reliable interaction patterns. The post describes a proof-of-concept durable coding-agent REPL built with Agentspan and Conductor OSS, in which an LLM can read and write files, execute shell commands, receive user messages, and reply continuously through a long-running workflow. Agentspan compiles the agent into a Conductor workflow, isolates concurrent sessions with unique run domains, streams workflow activity through Server-Sent Events, and uses a workflow message queue to durably deliver new prompts when the agent is waiting. It distinguishes queued messages for new tasks from signals, which inject instructions such as course corrections into the agent’s context on its next reasoning turn without interrupting its current work. The client uses separate threads to keep a single SSE connection open while handling terminal input, avoiding replay issues, and an enhanced version provides tools for launching, monitoring, and stopping background processes such as development servers. Session execution IDs can be stored and resumed later, restoring the agent’s conversation history and state while re-registering its workers, illustrating how the framework handles operational concerns so developers can focus on agent behavior and tools.

Agentspan presents a durable execution layer for AI agents intended to address production failures common in process-based frameworks, where crashes can lose in-memory state and force completed tool calls to run again. It argues that agent behavior resembles a dynamic workflow because each next action depends on model reasoning, tool outputs, and changing conditions, making deterministic testing and recovery difficult. Built on Netflix’s open-source Conductor workflow engine, Agentspan compiles agent definitions into server-executed workflows in which tool calls become durable tasks with independent state management, retries, recovery, and detailed observability. The platform is designed to preserve existing agent code and support frameworks including LangGraph, the OpenAI Agents SDK, CrewAI, and Google ADK, while enabling resumable runs, human approvals, guardrails, and inspection of recorded execution graphs. Agentspan is described as open source under the MIT license and can be run locally with its SDK and server.

Agentspan can be used to build a durable dependency-review workflow that compares CycloneDX SBOMs for a baseline and candidate release, identifies added, removed, and changed packages, applies internal policy rules, and produces an engineering summary. The walkthrough uses custom Python functions decorated with `@tool` to load and normalize SBOM data, store intermediate results in `ToolContext.state`, calculate dependency differences, evaluate newly added packages against a local policy database, and generate the final review output. An `Agent` defines the model, instructions, and fixed tool sequence, while `AgentRuntime` executes the workflow as a server-tracked run with an execution ID, recorded tool history, persistent state, and UI or API visibility after completion. The approach keeps parsing and policy logic in locally controlled Python code while allowing the model to coordinate tool use, and it can be extended with approval-gated remediation actions or externally hosted tools.

Agentspan is presented as an execution layer for Python-defined AI agents that stores workflow state, tool history, execution IDs, and step-by-step traces on a server. Its `api_tool()` capability converts published OpenAPI, Swagger, or Postman API specifications into agent-callable tools, avoiding the need to manually maintain endpoint wrappers. The walkthrough demonstrates a service catalog API that lets an on-call assistant identify a service owner, review the latest production deployment, and find a relevant runbook. It emphasizes restricting the agent’s available operations with `tool_names` and `max_tools` to reduce model choice complexity and improve trace readability, while distinguishing `api_tool()` from tools for custom Python functions, individual HTTP endpoints, and MCP servers. Agentspan’s UI then lets users inspect the shared execution record, including API discovery, filtering, HTTP calls, LLM activity, and the final response under a single execution ID.

The passage argues that conventional agent implementations, which keep execution state inside an application loop, are inadequate for reliable long-running business processes because checkpoints preserve data but cannot prevent duplicated side effects after failures. It proposes a “Late-Bound Saga” architecture in which an LLM acts only as a planner that emits intents, while a durable runtime records each intent before execution, performs actions, persists results, and resumes work safely after crashes or extended waits. This model is presented as necessary for effectively-once side-effect handling, process-independent suspension and resumption, external signal delivery, and detailed auditability, especially as multi-step agent reliability declines sharply with accumulating operations. Using a recruiting workflow as an example, the author describes how an agent can dynamically construct its execution graph, fan out work, wait for human responses, and react to cancellation signals without maintaining a live process. The post positions Agentspan, built atop Netflix’s Conductor runtime, as an implementation of this approach, allowing developers to define agents and tools while the runtime manages planning, execution, persistence, and orchestration.

Part 2 of an eight-part Agentspan series explains the parallel multi-agent strategy, in which independent agents receive the same input simultaneously and return separate results, contrasting with sequential workflows where each step depends on the prior output. Using a Python code-review example, it defines specialized bug, security, and style reviewers, groups them under a parent agent configured with `Strategy.PARALLEL`, and retrieves their findings through `result.sub_results`, reducing execution time to roughly that of the slowest reviewer rather than the sum of all reviewers. Agentspan is presented as a durable orchestration and observability layer that can build native agent workflows or integrate agents from other frameworks, persist completed work after failures, and expose execution details in a dashboard. The discussion recommends parallel execution for independent tasks and sequential execution for dependent ones, while showing that both can be composed into a workflow that runs reviews in parallel before a summarizer produces a final verdict. It also outlines a production extension using GitHub tools to retrieve pull-request diffs, perform parallel reviews, summarize the results, and post comments back to the pull request, with the next installment set to cover handoff-based delegation.

Agentspan is presented as a server-side agent workflow platform that provides durable executions, worker-based tools, execution visibility, retries, waits, and guardrails, illustrated through a customer-update workflow that removes internal incident information before returning an agent’s response. In the example, an agent drafts an update using internal context containing an incident ID, war-room channel, and on-call email, while an output guardrail detects these identifiers and replaces them with redacted placeholders using the deterministic `OnFail.FIX` option. The walkthrough, tested with agentspan version 0.1.3, explains that this approach is suited to mechanical policies such as redaction, truncation, and schema cleanup, whereas RETRY, RAISE, and HUMAN options support model retries, run termination, and human review. Agentspan’s UI allows users to inspect both the original draft that reached the guardrail and the rewritten result returned to the caller, making it possible to distinguish model-generated output from policy-approved output.

Agentspan is presented as an execution layer for Python-defined AI agents that compiles agent definitions into server-side workflows with durable state, tool histories, and UI-based execution status. The walkthrough demonstrates a production-change agent that retrieves rollout context and requires human approval before invoking an `execute_rollout` tool, using the `approval_required=True` setting to pause the existing workflow rather than create a separate approval process. Tested with Agentspan 0.1.3 and a local server, the example deploys and starts an agent execution, displays the waiting run in the UI, and allows a reviewer to approve the pending tool call so the same execution resumes and completes under its original ID. This approval-gated pattern is intended for higher-risk actions such as production deployments, publishing, refunds, and financial operations, where human review is needed without losing workflow state.

Agentspan is presented as a durable orchestration layer for creating, integrating, and observing AI-agent workflows, with support for agents built through its SDK or imported from frameworks such as LangGraph, OpenAI Agents SDK, and Google ADK. The post demonstrates its sequential pipeline strategy, expressed with the `>>` operator, through a support-ticket workflow in which specialized agents classify an incoming ticket, draft a customer response, and determine whether engineering escalation is needed. Using an urgent performance issue from an enterprise customer as an example, the pipeline produces structured priority and issue tags, a tailored public reply, and an actionable internal engineering note. Agentspan runs these steps as server-side workflows that persist execution state, allowing a run to resume after client or process failures rather than repeating completed work, while its dashboard provides visibility into inputs, outputs, tool calls, and token use. The workflow can be connected to Zendesk through credential-managed tools to retrieve tickets, post public responses, and create private escalation notes, and it can be extended linearly with additional agents such as Jira ticket creators or translators; the next series installment covers running agents in parallel instead.

Agentspan is presented as an orchestration layer that turns AI agent definitions into durable server-side workflows, separating the lifecycle of deployment, worker serving, and execution to support scalable multi-agent systems. The walkthrough deploys Agentspan’s control plane, PostgreSQL database, credentials, and networking on Kubernetes through Helm, optionally using K3D for local testing, then connects a Python SDK to the port-forwarded service. It builds a company-research team in which a coordinator uses handoff to trigger a deep-analysis agent, which runs market and risk specialists in parallel through separate Python tools. The team is registered once with `runtime.deploy`, its tool workers remain active in a separate process through `runtime.serve`, and later requests invoke the registered workflow by name with `runtime.run`. Completed executions can be examined through the API and UI, where the coordinator and nested agents appear as distinct executions and timelines reveal handoffs and parallel work. The central operating model is that Kubernetes manages the control plane, agent definitions can fit CI/CD workflows, workers can scale independently, and execution history supports debugging and observability.

Agentspan is an MIT-licensed open-source runtime and SDK designed to make AI agents resilient in production by storing execution state server-side through Conductor-based durable workflows, allowing agents to resume after crashes, restarts, or interrupted processes. Its Python interface centers on an Agent class, a @tool decorator, and a run() function, while a local server and dashboard can be started with minimal setup. The platform includes persistent human approval pauses, multiple multi-agent coordination strategies, guardrails with retry and escalation options, server-side OpenAPI and MCP tools, observability through dashboards, OpenTelemetry, and Prometheus, and deterministic CI testing without live LLM calls. Agentspan supports several model providers and can add persistence and monitoring to existing OpenAI Agents SDK, Google ADK, and LangGraph applications without requiring major rewrites. The project provides more than 210 runnable examples and includes open-source CLI, server, Python and TypeScript SDKs, and a React interface.

An AI agent is described as an LLM-based system that repeatedly works toward a user-defined goal through four core components: a language model that makes decisions, tools that access information or perform actions, a loop that enables multi-step reasoning and adjustment, and memory that retains the goal and prior results. Loops allow agents to respond to tool outputs, break complex tasks into sequential actions, and determine when a goal is complete or impossible, while memory—often simply conversation history—prevents repeated work and supports continuity. Tools provide access to live data and real-world actions that an LLM alone cannot perform, such as checking weather, calendars, prices, or sending messages. Simple examples include recommending clothing based on current weather, checking store hours, and scheduling meetings, while more complex agents can book travel, handle customer-support cases, or research competitors by iteratively gathering and evaluating information. Systems such as Claude Code may add guardrails, orchestration, many tools, or communication among multiple agents, but the underlying concept remains a goal-oriented LLM using tools, memory, and a loop.

AI agents can be vulnerable to failures in external tools and distributed worker processes, which may otherwise cause executions to disappear, duplicate, or stall indefinitely. The tutorial demonstrates how Agentspan, an agent orchestration platform, preserves a durable incident-triage agent run when its external Python tool worker is deliberately terminated. It guides users through deploying the Agentspan server with Docker Compose, defining an agent that calls an external incident-context tool, running that tool in a separate worker process, starting an execution while the worker is unavailable, and tracking the same execution ID through the CLI and web UI. Agentspan schedules the tool call as server-side durable work, allowing the execution to remain in a running state until the worker returns; after restart, the queued task is handled and the original execution completes with an incident summary and recommended action. The UI provides an execution history, timeline, timestamps, status, and workflow details, illustrating that the agent run remains a managed and inspectable platform record throughout the outage.