Orchestrating Fleet-Scale AI Coding Agents with Temporal Workflows

macroscope · Tech · 2026 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.6 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Fleet-scale AI coding-agent orchestration and code review automation

Macroscope needed reliable infrastructure for long-running code-understanding, code-review, and coding-agent workflows that could survive failures, coordinate external events, run untrusted code safely, and let engineers manage many autonomous coding tasks without constant manual steering.

Constraints:

• Code-review workflows need high signal and low noise or teams abandon them.
• Large pull requests can contain hundreds of function changes and need partial-result reporting.
• Coding agents need real execution environments to self-verify work instead of drifting in chat interfaces.
• Customer code must run across a trust boundary in isolated VM sandboxes.
• Long-running agent jobs can span hours or days, creating workflow versioning and cost-management concerns.

Architecture

Macroscope uses Temporal as the durable orchestration substrate for its code intelligence product and Murmur coding-agent fleet. Core Macroscope features run as workflows for PR check runs, Slack question-answering, GitHub webhook state updates, scheduled automations, and fan-out code review. Murmur adds isolated cloud VMs per coding agent, event-driven agent turns from GitHub/CI/review comments, MCP-based fleet control, decoupled VM and agent lifecycles, Temporal Proxy trust boundaries, JWT-scoped worker access, and workflow version pinning for long-running jobs.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  GitHub_events["GitHub events"] --> Temporal_workflows["Temporal workflows"]
  Temporal_workflows --> Code_review_child_workflows["Code review child workflows"]
  Code_review_child_workflows --> Macroscope_review_agents["Macroscope review agents"]
  Macroscope_review_agents --> GitHub_events
  Temporal_workflows --> Agent_harness["Agent harness"]
  Agent_harness --> Slack_API_interface["Slack/API interface"]
  Temporal_workflows --> VM_pool_workflow["VM pool workflow"]
  VM_pool_workflow --> Coding_agent_VM["Coding agent VM"]
  Murmur_control_plane["Murmur control plane"] --> VM_pool_workflow
  Murmur_control_plane --> MCP_interface["MCP interface"]
  Murmur_control_plane --> Coding_agent_VM
  Coding_agent_VM --> Temporal_Proxy["Temporal Proxy"]
  Temporal_Proxy --> Temporal_workflows
  CI_review_feedback["CI/review feedback"] --> Coding_agent_VM
  Coding_agent_VM --> Verification_tools["Verification tools"]

Components

Data flow

GitHub, Slack, CI, review comments, and scheduled events trigger Temporal workflows. For code review, child workflows fan out over PR changes and emit partial findings. For Murmur, a task starts or wakes a VM sandbox, runs a coding agent, lets it write code, open PRs, respond to CI and review events, verify with tools such as Playwright, and eventually produce a merge-ready PR.

Why this architecture

Macroscope uses Temporal because AI code workflows are long-running, event-driven, failure-prone, and need inspection. Murmur adds VM isolation and event-driven self-verification because coding agents need real environments, CI, code review, and tool execution to complete tasks without constant user nudging.

Models used: Claude Code · Codex · Large Language Models

Scale

• Customers using approvability see about 40% of PRs automatically approved.
  “40% on average of their PRs are automatically approved by Macroscop. 40%.”transcript, stated
• Large PR review can fan out over roughly one hundred changed functions.
  “some PRs can be absolutely huge. You know, you might be changing a hundred different functions in a pull request”transcript, stated
• Murmur is designed for fleets of dozens or hundreds of remote coding agents.
  “your machine can just talk to your remote fleet of dozens or hundreds of agents”transcript, stated
• A demo task fanned out four parallel remote VMs.
  “You can see here that it's calling Murmur four times. We can actually see what the tool calls look like. It's calling Murmur spawn.”transcript, stated
• The demo environment included about 25 microservices plus web, Go backend, Temporal, and Tilt.
  “We happen to have like 25 microservices, you know, we have our web app, we've got our go back end, we have temporal, we use tilt”transcript, stated
• The team reported an internal 32-work-week output equivalent for one week of Murmur-assisted work.
  “32 work weeks worth of output in one week is what a tool like this orchestrating multiple agents allows you to yield”transcript, stated
• Murmur workflows can run for many hours or days.
  “some of these workflows these that are running for a VM could be out many hours or even days.”transcript, stated

Alternatives considered (roads not taken)

Manage several coding agents manually in local tabs and worktrees

Rejected because: The team found three to five concurrent Claude sessions painful to shepherd and difficult to keep moving.

Rely on chat agents without real self-verification environments

Rejected because: Complex tasks go off the rails when agents cannot run, test, and verify their work.

Keep VM lifecycle tied to agent lifecycle

Rejected because: Decoupling lets idle VMs shut down while agents wait for PR review or CI, reducing cost.

Let untrusted VMs connect directly to Temporal Cloud

Rejected because: The VM executes customer code, so Temporal Proxy and JWT-scoped access enforce the trust boundary.

Patterns

durable-execution (orchestration)

Temporal gives each PR check run, agent harness, webhook update, scheduled automation, and Murmur VM/agent lifecycle a durable workflow state machine.

multi-agent-orchestration (orchestration)

Murmur lets engineers spawn and coordinate fleets of remote coding agents, including fan-out through a local Claude/Codex session using MCP.

safety-policy-enforcement (security)

Each Murmur agent runs in an isolated cloud VM, optionally in the customer's VPC, with Temporal access constrained through proxy and JWT task-queue scoping.

eval-driven-development (evaluation)

Murmur agents verify work by running tools, taking screenshots, reflecting on output, responding to CI failures, and addressing review-bot findings.

human-in-the-loop-gate (safety)

Murmur reacts to human PR comments and returns merge-ready work that can still receive additional manual steering.

observability-tracing (operations)

Temporal exposes workflow state and tool calls for debugging check runs and natural-language agent harnesses.

async-message-orchestration (orchestration)

Murmur turns PR comments, CI failures, and review bot findings into queued events that wake the VM and start another agent turn.

Tradeoffs

Use Temporal as the workflow substrate across the product.

Chose Durable workflow state machines over Ad hoc request handlers or polling-based orchestration.

Rationale: Temporal gives durability, replay, debugging, child workflows, webhook-triggered state, and scheduled automation across code-review and agent workflows.

Run each coding agent in a cloud VM sandbox.

Chose Dedicated VM per agent over Local chat-only agent sessions.

Rationale: The VM gives agents code checkout, tools, environment access, screenshots, CI feedback, and customer-network connectivity while isolating execution.

Expose Murmur through MCP as well as a web UI.

Chose Local Claude/Codex orchestration of remote VMs over Only managing tasks through Murmur's web dashboard.

Rationale: Engineers already work in terminals, and MCP enables conversational fan-out and fan-in over a remote fleet.

Keep backfilled execution untrusted.

Chose Temporal Proxy and JWT-scoped worker/task-queue access over Trusting VM workers as Temporal Cloud peers.

Rationale: Customer-code execution requires treating the VM side as untrusted while still letting workflows progress.

Gotchas (what bit them)

Manual multi-agent coding sessions hit an ergonomic ceiling.

Root cause: Engineers had to shepherd several Claude tabs and worktrees, making three to five sessions the practical maximum.

Resolution: Use Murmur as a remote fleet control plane with VM sandboxes and MCP orchestration.

Coding agents drift without execution-based self-verification.

Root cause: Chat interfaces do not provide the environment needed to run, inspect, and verify complex engineering work.

Resolution: Run each agent in a VM with code checkout, CI/review feedback, and tools such as Playwright screenshots.

Always-on VMs would waste infrastructure while agents wait.

Root cause: Agent workflows can pause for review comments or CI completion even when no compute is needed.

Resolution: Decouple VM lifecycle from agent workflow lifecycle so VMs can idle or shut down independently.

Customer-code execution creates a hard trust-boundary problem.

Root cause: The VM executes arbitrary customer code and cannot be treated as trusted infrastructure.

Resolution: Place Temporal Proxy between Temporal Cloud and VM workers and scope access with minted JWTs.

Long-running workflows complicate backwards compatibility.

Root cause: Murmur VM workflows can run for many hours or days while the product continues changing.

Resolution: Use workflow version pinning and Temporal worker controller support.

Evaluation

Macroscope evaluates code review through bug-detection and F1 benchmarks, customer auto-approval rates, and internal productivity metrics. Murmur demos show self-verification via screenshots, CI failures, review-bot findings, and merge-ready PR completion.

Metrics: 40% average automatic PR approval for customers using approvability · Highest bug-detection rate on Macroscope's benchmark · Highest F1 score in a Martian benchmark among compared tools · 20 turns for a Notion integration task, with 19 turns responding to CI and review findings · Reported 32 work weeks of output in one week for an internal Murmur user

Outcomes

• Macroscope reports 40% average automatic PR approval for customers who enable approvability.
• Murmur can spawn parallel remote coding-agent VMs from a local MCP-connected Claude session.
• A demo task used screenshots and reflection for visual self-verification.
• A Notion integration task reached merge-ready state after CI and review-bot iterations without additional human work after the initial prompt.
• Macroscope reports a 32x internal productivity multiplier for one early Murmur user.

The talk reports strong internal and customer metrics, but the 32x productivity claim is self-measured and should be treated as directional evidence rather than a general sustained productivity guarantee.