# Scaling AI Agents Without Breaking Reliability

Preeti Somal, Temporal | AI Engineer World's Fair 2025 | 15:01

Source: https://www.youtube.com/watch?v=1izYWsokr9s
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/scaling-ai-agents-without-breaking-reliability
Published: 2025-07-28
Tags: observability, reliability, workflows

## TL;DR
- AI agents are distributed systems that need durable state, orchestration, failure handling, human interaction, and observability.
- Temporal moves retries, execution state, workflow history, and scaling out of application plumbing so developers can focus on agent logic.
- Agents built with Temporal can run in production while keeping a record of their interactions for debugging and compliance.

## Summary
Preeti Somal argues that AI agents should be treated as complex distributed systems rather than simple model calls. An agent may coordinate language models, tools, databases, parallel work, long-running state, and human approvals, while also dealing with unreliable model and tool calls. Temporal addresses these concerns through a code-based workflow abstraction and language-specific SDKs. Developers define the workflow, wrap tools as activities, and use signals and queries for interaction. Temporal handles retries, execution state, workflow history, and much of the failure plumbing. The worker code stays in the customer's environment, while Temporal Cloud manages execution state and scaling. Somal also describes customer use cases, including customer service agents and payment workloads, and cites a case where feature delivery became more than six times faster after adopting Temporal. The talk is a concise product-focused explanation of how Temporal applies its distributed-systems model to agent applications.

## Key ideas
### AI agents need distributed-systems discipline to earn trust
[01:04](https://www.youtube.com/watch?v=1izYWsokr9s&t=64s)
Somal says agents are software, but they are also complex distributed systems. They interact with large language models, tools, databases, and sometimes people. Their workflows may run for long periods, keep state, pause for human approval, execute work in parallel, and call external tools. A successful prototype is not enough if the system fails in production. Somal points out that LLM calls do not succeed every time, which makes retries, durable execution, debugging, testing, and visibility part of the application design. The agent must keep working despite unreliable pieces, or users will stop trusting it.

### Temporal puts orchestration into a developer-written workflow
[01:30](https://www.youtube.com/watch?v=1izYWsokr9s&t=90s)
Temporal's central abstraction is a workflow written in code with its language-specific SDKs. The developer uses it to coordinate the model, chat history database, tools, and other processes. Somal presents this as a developer-focused programming model rather than a business-user tool. The workflow can contain interactive loops and long-running state, and it can receive input through Temporal signals or expose information through queries. This gives the application an explicit structure while keeping the agent's business logic in ordinary code. The workflow is where the developer describes how the agent should move through its tasks.

### Temporal handles much of the failure plumbing around agent code
[09:37](https://www.youtube.com/watch?v=1izYWsokr9s&t=577s)
In Somal's ticket-booking example, the workflow defines the application flow and tools are wrapped as activities. Developers do not need to fill the workflow with repeated statements such as, "if something fails, keep retrying it." Temporal handles those failure behaviors transparently. It also stores workflow history, giving the team a record of how the agent moved through its interactions. Signals and queries are stored in that history, and the complete record can be exported. Somal says customers want this export for compliance and for debugging in development and test environments.

### The worker stays in the customer's environment while Temporal Cloud runs the service machinery
[12:40](https://www.youtube.com/watch?v=1izYWsokr9s&t=760s)
The agent workflow and worker code run in the customer's own environment and can fit into existing CI/CD practices. Temporal Cloud manages execution state, the call stack, failures, and retries. Somal says the product is designed to meet developers where they are, so teams can keep writing code in their existing environment instead of changing their development process. The separation lets developers concentrate on business logic while Temporal Cloud takes care of the reliability and scaling work around workflow execution. The worker remains part of the application's deployment rather than being moved into a separate authoring system.

### Temporal's value is presented through production examples and delivery speed
[04:39](https://www.youtube.com/watch?v=1izYWsokr9s&t=279s)
Somal says Temporal has been in production for over a decade and is used for mission-critical applications. She names Dust and Gorgeous as examples connected to agent applications, and points to customer service work for brands including Reebok, Timbuk2, and Glossier. She also uses payments to show that Temporal handles workloads where failures matter. On engineering impact, she says customers can put applications into production in weeks and cites case studies with feature delivery velocity improved by more than six times. She also describes a consumer application scaling with events without requiring the customer to write its own scale-handling logic.

### The ticket-booking example combines workflows, activities, signals, and queries
[08:55](https://www.youtube.com/watch?v=1izYWsokr9s&t=535s)
The example follows a ticket-booking agent and shows how Temporal wraps the main parts of the system. The workflow defines the flow and interactive loops. Activities contain the tools the agent calls, while signals provide input to the workflow and queries provide a way to inspect it. The language model provider remains flexible, and Temporal can help validate inputs and move the process toward its goal. The example is meant to show that agent patterns can be expressed as code without separately implementing every retry and state-management path. Somal says the same model supports loops and other patterns needed by agent applications.

## Notable quotes
- "They need to cope with LLMs and they must scale and provide durability and reliability." (01:04)
- "At the end of the day when you think about agents you essentially are just orchestrating a number of pieces around the interaction the large language models the chat history database and the tools." (07:22)
- "Nowhere in there will there be statements like if something fails you know keep retrying it." (10:32)
- "Your agent, your workflow, the code actually runs in your environment." (12:40)

## Tools & references mentioned
- Temporal
- Dust
- Gorgeous
- Reebok
- Timbuk2
- Glossier
- HashiCorp
- Yahoo!
- VMware
- Oracle
- Temporal Cloud
- Temporal Code Exchange

## Who should watch
- You are building an agent that must survive failed LLM or tool calls and need durable execution without writing every retry path yourself.
- Your workflow includes long-running state, human approvals, parallel work, or external tools, and you need a clear record of what happened.
- You want to evaluate a code-first orchestration platform that keeps workers in your environment and provides cloud-managed execution state.

## Related talks

- [Building Durable, Production Ready Agents](https://aietalks.com/talks/building-durable-production-ready-agents) (Cornelia Davis, Temporal, 1:18:30)
- [From Stateless Nightmares to Durable Agents](https://aietalks.com/talks/from-stateless-nightmares-to-durable-agents) (Samuel Colvin, Pydantic, 22:13)
- [AI Agents Are Just Distributed Systems Now](https://aietalks.com/talks/ai-agents-are-just-distributed-systems-now) (Salman Munaf, TikTok, 19:48)
- [Deterministic Infra for Non-Deterministic AI Agents](https://aietalks.com/talks/deterministic-infra-for-non-deterministic-ai-agents) (Nishant Gupta, Meta Superintelligence Labs, 07:14)
- [Events are the Wrong Abstraction for Your AI Agents](https://aietalks.com/talks/events-are-the-wrong-abstraction-for-your-ai-agents) (Mason Egger, Temporal.io, 14:40)