Human-in-the-Loop AI: Building Durable Agents

Google's ADK and Temporal integrate to orchestrate fleet, customer, and dispatch agents, as Melanie Warrick demonstrated with a mascot named Ziggy. The system showcased fleet, customer, and dispatch agents working in coordination.

This system integrates Google's ADK with Temporal, allowing for the orchestration of multiple agents and robust state tracking. Temporal's UI provides a clear visualization of the event history within the parent workflow.

To prevent total system failure, Temporal pauses specific tasks until human approval is received for requests such as order changes.

Temporal allows specific tasks to pause for human input while the rest of the system continues to operate without interruption.

The system processes updates only after receiving human approval, preventing total system failure when dealing with asynchronous user requests.

Agentic loops operate on fundamental behaviors of reasoning, acting, and observing, which are central to autonomous agent design.

The 'harness' is a crucial architectural component that facilitates the transition of agents into production environments. Discussions about the harness often involve debates on the inclusion of models, tools, memory, and security guardrails.

The primary function of the harness is to provide a structured framework for these autonomous agents.

Three distinct agent loops power the platform, with fleet agents accessing Google Maps, customer agents using Google Search, and the dispatch agent handling overall decisions.

The fleet agent researches drivers using Google Maps, while the customer agent researches orders via Google Search. The dispatch agent then processes inputs from both the fleet and customer agents to make delivery decisions.

Temporal standardizes failure handling and state management for distributed systems, offering built-in primitives.

These primitives are compatible with Python, TypeScript, and Rust, and the platform is available as either software or a managed service. Key components include workers, workflows, and activities.

In Temporal's architecture, workers are responsible for executing the code.

Workflows track the steps within the system and manage long-running state, while activities handle interactions with external systems, such as making model or tool calls.

Direct function calls to human input introduce blocking hazards in distributed services, making it essential to use alternative mechanisms.

Two core primitives—wait conditions and signals—allow agents to pause without thread blocking and resume processes post-crash.

These system primitives enhance scalability and include built-in features such as timeouts, crucial for managing asynchronous human interactions.

Temporal utilizes three core primitives: activities, workflows, and workers, which are applied to agent code.

For Google's ADK (Agent Development Kit), the model and tools are wrapped using `temporal_model` and `activity` tools, respectively. Workers are configured by passing in a specific framework plugin, such as the Google ADK plugin, with workflows managing process steps and activities handling model calls and tool executions.

A wait condition, implemented with `asyncio`, allows a specific workflow to pause execution without halting other co-routines.

During this pause, the workflow is removed from memory or 'parked' by the system. External inputs like human approval are injected back into the workflow to resume operation through the workflow.signal function.

By treating node calls as activities and process steps as workflows, Temporal manages state across tools including LangChain regardless of the underlying framework.

In a graph setup, node calls, such as model invocations, are defined as activities, while overall process steps are structured as workflows. Workflows maintain strict determinism, contrasting with activities that are treated as non-deterministic. The interrupt function triggers a wait condition in LangChain, holding the process until a human signal arrives.

The demonstration's architecture features customer and fleet agents running on ADK, while the dispatch agent operates on LangGraph, with Temporal interwoven throughout the entire system.

The system creates child workflows for each order, ensuring independent assessment per framework. High-value orders trigger the signal mechanism, requiring human intervention after autonomous agent activity.

Human responses are typically not instantaneous, which requires systems to adapt to varying delays.

The system enters a wait condition until a human responds, and this human interaction can span minutes, days, or even weeks.

To ensure system resilience, events are stored externally to the service, preventing data loss when a worker goes offline.

Upon a worker's return, the event log is replayed, allowing the system to recover its exact previous state without losing any progress.

The agent can then identify the next necessary step without re-executing any previously completed work, ensuring seamless continuity.

Developers must balance the drive for agent autonomy with the inherent unreliability of probabilistic models. Overuse of alerts can lead to 'alert fatigue,' causing users to ignore critical prompts. Building trust-based systems necessitates careful evaluation within the specific problem domain.

Workflow pauses are managed through the application of wait conditions, which halt execution until specific criteria are met.

Human input advances or resumes workflow execution by leveraging signal mechanisms. These primitives function reliably, regardless of whether the underlying system is currently online or offline, ensuring robust human-in-the-loop capabilities.