TechPrufer
Get started
Temporal
Temporal logoTemporal · Feature trail

Sandbox Orchestration Harness

4 posts · Dec 2024 – Oct 2026

What this trail covers

Temporal provides a robust foundation for Agentic AI workflows, offering durability, scalability, and flexibility. This includes features like scheduled execution, human-in-the-loop support, and multi-language integration. The platform acts as a centralized orchestrator for coordinating API calls, services, and data sources, enabling complex, long-running AI agents that can persist and evolve. The Temporal Agent Harness provides an outer layer of control and durability for AI agents, integrating with existing inner agent SDKs. It offers durable execution for agent interactions, a "turn"-based model for managing complex interactions, strongly typed agent interfaces for composition, and controls around tool execution, including approval policies. It also introduces a "code mode" for executing model-generated Python code in secure, durable sandboxes. This post codifies base templates and demonstrates how to run the Pi coding agent on Temporal, enabling recovery across machines while preserving its session format and allowing for automatic failover of interrupted tasks.

All Temporal trails
  1. The immortal life of Pi: Running the Pi coding agent on Temporal.This post details the integration of the Pi coding agent with Temporal Workflows to provide durable execution and automatic recovery across machine failures. It describes how Temporal Workflows act as the execution engine, with each turn of the agent's interaction (model call + tool calls) mapped to Activities. The session file serves as the conversation state, and Git bundles preserve project snapshots. The post highlights the handling of 'unknown outcomes' for tool calls that may have partially executed before a worker failure, and the mechanism for preventing stale attempts from corrupting the session state using a write guard and lease. The core rules for recovery are: transcript as the sole conversation state, `sealStep` as the sole writer of tool results, pre-invocation claims for tools, a write guard rejecting appends from workers that lost their lease, and configurable token/time budgets.
  2. AI safety does not stop at the modelThis post introduces the concept of controlling agent authority by ensuring company-controlled code determines what actions an agent may take, rather than the agent itself. It highlights the need for enforcement mechanisms that persist through system failures, using an example of a flight rebooking scenario. The post positions Temporal's Durable Execution and Temporal Agent Harness as the execution layer that provides reliability, visibility, and company control for AI agents, specifically by managing approvals, rejections, and results through crashes and retries.
  3. Temporal Agent Harness: An early look at durable agent infrastructureThis post introduces the Temporal Agent Harness, an "outer harness" designed to provide control and durability for AI agents. It emphasizes bringing your own inner harness (e.g., OpenAI Agents SDK, LangGraph), introduces a "turn"-based model for agent interactions, strongly typed agent interfaces for composition, and a "code mode" for executing model-generated Python code in durable, secure sandboxes. Key principles highlighted are durable execution, meeting developers where they are, providing strong control points, and treating agents as application components rather than just chat loops.
  4. Stop failing on the path to production: A better way for agentic platformsThis post emphasizes the importance of a robust harness for agentic platforms, advocating for Temporal's durable execution, memory, and programming model as a foundation. It highlights the need for features like simple memory/context, built-in resilience, a code-based programming model, token efficiency, auditability, visibility, unlimited runtime, strong data typing, durable orchestration, simple customization, and full orchestration control. It introduces a reference sample for a Temporal-based agent harness and links to further resources on AI engineering and agent architecture. The post also stresses the critical role of secured data with user-level authentication and authorization, recommending OAuth and MCP servers, and contrasts deployed agents with desktop agents, advocating for opinionated, deployed agents within an organization's infrastructure.
  5. Temporal Sandbox Orchestration Harness: The missing layer for running agentsThis post introduces the Sandbox Orchestration Harness as a missing layer for agent infrastructure, codifying base templates and best practices for integrating sandbox compute runtimes with Temporal Workflows. It details the orchestration problem of managing sandboxes (provisioning, driving execution, persisting state, recovery, cleanup) and presents community code samples demonstrating how to tie sandbox provisioning to the Workflow lifecycle, achieve durable execution across sandbox operations via Temporal Activities, implement workspace persistence with auto-pause (e.g., Modal's suspend), and enable workspace persistence with fork (snapshotting and restoring). It highlights the flexibility of swapping sandbox providers by changing configuration.
  7. From agent zoo to agent orchestra: The benefits of Temporal as your enterprise agentic control planeThis post details how Temporal can be used as an enterprise agentic control plane to bridge the gap between "agentic AI" and "agentic AI you'd actually trust with your business." It categorizes agents into Conversational, Event Stream Processors, Ambient, and Agent-to-Agent interactions, highlighting the architectural pressures each type places on a system. Temporal Workflows are presented as a solution for providing guardrails (human approval, timeouts), managing conflicting agents (workflow isolation, idempotency), and ensuring data security (namespace/process isolation, encryption, audit trails). The post also discusses Temporal Nexus for coordinating agents across namespace boundaries, enabling versioned and discoverable endpoints for inter-agent communication. Furthermore, it emphasizes Temporal's Workflow Versioning capabilities for managing change in long-running agentic systems and addresses operational realities like LLM cost management through controlled retries and long-running agent execution.
  8. Inside the Google ADK and Temporal integrationThis post details the integration of Google ADK with Temporal, enabling each LLM call and tool call within an ADK agent to run as a separate Temporal Activity. This brings Temporal's durable execution and retry capabilities to every step of the agentic loop, rather than just at the boundary. Key contributions include: - `TemporalModel`: A wrapper that reroutes LLM calls through Temporal Activities, allowing configuration of timeouts and retries. It handles model serialization by moving the model name and recreating it on the activity side. - `activity_tool`: A helper for defining tools as Temporal Activities, automatically handling retries, backoff, and heartbeating. It also supports defining Nexus operations or child Workflows as tools. - Deterministic Time and UUID: A PR to Google ADK introduced `google.adk.platform.time` and `google.adk.platform.uuid` abstractions that can be swapped with Temporal's deterministic `workflow.now()` and `workflow.uuid4()` within Temporal Workflows. - MCP Support: Integration with MCP allows dynamic tool discovery at runtime, with each tool call running as a Temporal Activity, providing visibility and retries. The integration handles tool context serialization by taking a focused snapshot of the context needed by the tool. - Worker Setup: A single-line `GoogleAdkPlugin()` addition to the Temporal client handles sandbox passthrough, Pydantic serialization, and deterministic time/UUID replacements.
  9. Introducing Temporal and agentic sandboxes: The OpenAI agents SDKThis post details the integration of OpenAI's Agents SDK with Temporal to enable durable execution of sandbox agents. It introduces a Temporal extension for the OpenAI Agents SDK, allowing sandbox agents to run as Temporal Workflows. The demo architecture includes AgentWorkflow for durable agent execution, SessionManagerWorkflow for orchestrating agent sessions, and a TUI for client interaction. Key technical contributions include the `temporal_sandbox_client` function that wraps sandbox operations as Temporal activities, making them durable and retryable, and the ability for a single Temporal worker to support multiple sandbox clients. The post also highlights the benefits of durable execution for state loss prevention, resource waste reduction, and operational flexibility.
  10. Building observable AI agents: Temporal now integrates with BraintrustThis post introduces an integration between Temporal and Braintrust to enhance the observability of AI agents. It details how to wrap OpenAI clients with Braintrust's `wrap_openai` and integrate the `BraintrustPlugin` into Temporal Workers and Clients. The post demonstrates how to load prompts from Braintrust using `braintrust.load_prompt` and showcases a deep research agent example. Key contributions include enabling LLM call tracing within Temporal Workflows, prompt versioning managed by Braintrust, and providing visibility into cost and latency metrics for AI agent executions.
  11. Orchestrating ambient agents with TemporalThis post details how Temporal primitives (Workflows, Signals, Queries) can be used as "tools" for AI agents within the Model Context Protocol (MCP) framework. It showcases using Temporal Schedules for proactive agent execution, Signals and Queries for inter-agent communication and dynamic prompt tuning, Temporal's UI for observability and auditability of agent actions, and Temporal Workflows for orchestrating multiple agents (broker, execution, judge) in a crypto trading platform. The post highlights how Temporal primitives provide durable actions for AI agents, enabling continuous, resilient, and auditable operation of complex multi-agent systems.
  12. Multi-agent Workflow patterns and modern use cases | TemporalThis post details practical patterns and use cases for multi-agent workflows, highlighting Temporal's suitability for orchestrating interactions, managing state and context sharing, enabling reliable asynchronous communication, handling parallel processing, supporting long-running processes, and facilitating event-driven triggers and real-time coordination. It emphasizes that Temporal acts as a general-purpose backbone for agentic systems, reducing the need to build framework-specific code. A customer support system example is provided to illustrate these concepts.