Your Sub-Agents Are a Distributed System. Treat Them Like One.

Girish Konda, Microsoft23:01 · Nov 2026 · 3,266 views
Thumbnail for Your Sub-Agents Are a Distributed System. Treat Them Like One. Watch on YouTube
TL;DR
  1. 1

    Sub-agent handoffs have familiar distributed-system failures, including partial failure, dirty reads, overload, and duplicate side effects.

  2. 2

    SAFE handoffs attach provenance and freshness to facts, limit fanout, make effects at most once, and return named outcomes.

  3. 3

    The model favors consistency for writes, accepts unknown outcomes after lost replies, and adds overhead that is unnecessary for text drafts reviewed by a person.

Summary

Girish Konda argues that an orchestrator delegating work to sub-agents has created a distributed system. Workers run concurrently, share mutable state, call external tools, and return results over unreliable boundaries. That produces familiar failures, but language makes them harder to detect: a half-finished task can look like success, a guess can spread as a fact, and a lost reply can lead to a repeated side effect. Konda proposes SAFE handoffs. Facts carry their source, version, and relevant times. Effects have identities, require approval for the exact action, and are read back rather than replayed. Fanout has bounded budgets and visible refusals. Every handoff returns an explicit state such as completed, failed, stale, or unknown. The approach does not make source facts true, provide rollback, or give exactly-once delivery. It is intended for agents that touch real systems, while human-reviewed drafting needs much less machinery.

Key ideas
00:24

Sub-agent orchestration creates the same failure classes as a distributed system

Konda describes an orchestrator splitting work among concurrent workers that share conversations, memory files, repositories, issues, vector stores, and working trees. Those workers also call databases, APIs, CI tools, and deployment pipelines. He maps the resulting failures to familiar distributed-systems problems: a call can fail halfway and return success-looking text, workers can read uncommitted guesses, fanout can hide rate limits and overload, and retries can repeat side effects.

02:48

A fluent response does not prove that the work happened

Konda compares a half-finished sub-agent with a Byzantine component. The agent may not crash or raise an exception. It can return normal-looking text even though it stopped early. In his example, one path collected telemetry, another matched a familiar title, and a third did nothing, yet all three produced the same benign conclusion. The orchestrator can see the conclusion, but not how much work supports it.

04:52

A timeout is an unknown outcome, not proof of failure

When a call receives no reply, the worker may still be running, may have crashed while its reply was lost, or may be slow. Konda cites the FLP result and failure-detector work to explain why the caller cannot know which case occurred. In MCP Pacemaker, a first-run server exceeded the normal timeout while downloading itself, while another server crashed and had its useful exit code hidden by the timeout. He records timeout as unknown and preserves the actual cause when available.

07:12

Shared context needs provenance and freshness checks

Konda shows how one worker can write an unsupported claim into shared context and have other workers repeat it as if three artifacts confirmed it. Those workers are reading one shared guess, not independent replicas. His source-feed rule treats every fact as a record with a claim, revision, source version, scope, current-data time, read time, and use time. The orchestrator checks freshness when the fact is used and rejects an inference that has no source and read time.

09:57

SAFE handoffs make facts, effects, capacity, and outcomes explicit

SAFE stands for source feeds, at-most-once effects, fanout budgets, and explicit outcomes. Source feeds attach provenance and freshness to facts. At-most-once effects give each write an identity, bind approval to that exact action, and read back the result rather than replaying an uncertain call. Fanout budgets put gates and bounded weights on downstream work. Explicit outcomes use named states, including unknown and refusal, instead of relying on free-form text.

13:32

Approval and read-back protect side effects from retries and stale work

A lost reply after a tool creates a pull request leaves the orchestrator unable to tell whether the write happened. Retrying the whole task can create it again. Konda explains the delivery choices: at-most-once may lose work, at-least-once may duplicate it, and deduplication must be built for an exactly-once-like result. He gives every side effect an identity, uses approval once for the exact action, and confirms it by reading back that identity. Submitted is not the same as confirmed.

16:51

Capacity controls must be visible to the orchestrator

Konda describes an MCP bridge where many cold starts used NPX and a shared package cache at once, causing lock errors even though each request was individually valid. His bridge gates package-manager cold starts two at a time by default, bounds the wait, caps sessions, and refuses new sessions after a timeout. Capacity is reserved before synchronous startup to avoid a check-then-act race. A refusal is exposed as a failure rather than hidden in text.

19:47

The model trades availability and speed for safer writes

Safe handoffs do not make source facts correct, provide exactly-once delivery, roll back partial work, or create a global order across workers. Konda chooses availability for cold starts, while writes favor consistency and refuse rather than guess. Freshness checks add reads and refusals add waiting. The approach fits agents that change production systems, but it is excessive when an agent only drafts text for a person to review. It also assumes one orchestrator.

"An orchestrator workers shared mutable state and results merge from concurrent executions. This represents a classic distributed system."01:20
Who should watch
  • You are building an orchestrator that delegates tool calls to agents and needs to distinguish completed work from plausible text.
  • Your agents can change repositories, databases, deployments, or other production systems, so retries and lost replies can cause duplicate effects.
  • Your system mainly produces drafts for human review, and you want to judge whether distributed-systems controls would add more cost than value.