Cornelia Davis: I'll introduce myself in just a moment, but I'd like to get to know a little bit about you. So, you know, you can see that there's two brands up on the screen here. There's OpenAI agents SDK in particular, and there's Temporal. I work for Temporal. I'll tell you more about myself in just a second. Um, I'm curious, how many folks are using the OpenAI agents SDK today?

Cornelia Davis: Okay, about a quarter of you. Any other agentic frameworks? Okay, about the same set of you. So, it looks like there's quite a number of you who are not using an agent framework just yet. So, I'll teach you a little bit about that. Okay, next question. How many folks are doing anything with temporal?

Cornelia Davis: Not very many. Awesome. I'm gonna get to teach you some stuff. Okay, cool. So, we're going to talk today about both those technologies. I'm going to talk about them each independently, but I'm going to spend a lot of time on them together. Spoiler, we actually have an integration between the two products that Temporal and OpenAI worked on together. And you'll see it's really quite sweet.

Cornelia Davis: So, let me very briefly introduce myself. My name is Cornelia Davis. I'm a developer advocate here at Temporal. I think the bulk of my career has been spent in this distributed system space. So I was super fortunate to be at Pivotal working on Cloud Foundry from the early 2010s. So I was really there during the kind of movement toward microservice architectures, distributed systems, those types of things.

Cornelia Davis: Any Cloud Foundry folks in the room? Oh, just a few. So for those of you who don't know Cloud Foundry, Cloud Foundry was the early container technology out on the market. It was incubated as a open-source project at VMware and it used container images, Linux containers, container orchestration, eventual consistency, all of that stuff before Docker even existed and well before Kubernetes existed. So I was very fortunate that I was there at the beginning of that movement over toward platforms that supported this more agile distributed systems way of doing things.

Cornelia Davis: What we're going to talk about today is the OpenAI agents SDK. Then I'm going to give you a temporal overview. I'll tell you that for me personally the distinction that I make between GenAI applications and then when they get to agents is when we give the LLMs agency—when the LLMs are the ones that are deciding on the flow of the application. That to me is what an agent is. And these frameworks like the OpenAI agents SDK are designed to make it easier for you to get started with those.

Cornelia Davis: It's available in both Python and Typescript. And here is the most basic application. So what you see here is that we've defined an agent. We've given it a name and we've given it instructions. And anytime you see that runner.run, what that corresponds to is an agentic loop. It also has a lot of other options like handoffs, guardrails, and tools.

Cornelia Davis: And really, this is the picture of what I'm talking about is that every one of those runner.runs basically has a loop that is constantly going back to the LLM. And after the LLM call, it decides to do things. And if the LLM, for example, has said, I want you to invoke some tools, it will go ahead and invoke those tools. And then it'll take the output from the tools and route it back to the LLM and keep going. And the LLM gets to decide when it's done following the system instructions.

Cornelia Davis: Since very few of you know temporal I'm going to slow down a little bit here and tell you more about temporal. So, Temporal is an open-source project. It's been around for about five or six years. So, yes, it well predates the Gen AI boom that we're in. It's designed for distributed systems and what are AI applications if not distributed systems?

Cornelia Davis: Now, it's used in a lot of non-AI use cases. So, for example, every Snapchat goes through Temporal. Every Airbnb booking goes through Temporal. Pizza Hut, Taco Bell orders go through Temporal. OpenAI Codex runs on Temporal. OpenAI's image gen runs on temporal. What it is is distributed systems as a backing service. What it delivers is distributed systems durability.

Cornelia Davis: What that means is that you as the developer get to program the happy path. You get to program your business logic. And you don't have to build the logic in there that says what happens if the LLM is rate limited. What happens if my downstream API is down for a moment? What happens if my application crashes? We do it for you.

Cornelia Davis: For example, if you have used temporal to lend durability to your agents, when you're on the 1,350 second turn to the LLM and your application crashes, no sweat. We have kept track of every single LLM call and return and you will not be reburning those tokens. That's what it means. That's what durability means in this space.

Cornelia Davis: Temporal was a fork of a project that was created out of Uber called Cadence. Cadence pretty much every application running at Uber runs on Cadence and it's because they can program the happy path and all the durability is just taken care of for you.

Cornelia Davis: The two foundational abstractions that you need to know about as a developer is you need to know about an activity. And an activity is just a chunk of work. This is work that either is going to make external calls. What we call those orchestrations is workflows.

Cornelia Davis: What happens when you put activities and workflows together, that's where the magic really happens. You specify in your workflow logic the retry configuration. You don't have to implement the retry logic. It just happens for me. Every single time you call into an activity, all of that is facilitated over cues so that what looks like just a single monolithic application is already turns into a distributed system.

Cornelia Davis: One of the things that we do as well is we keep track of where you are in the execution of your application. We do that by recording the state. It's basically event sourcing. We store all of that state so that if something goes wrong, it will pick up where it left off because we will just run through the event history and pick up where we left off.

Cornelia Davis: Let's look at the code. Here, of course, what we're doing is an agentic loop. So my activities are going to be call the OpenAI API and invoke some tools. So let's look at the first one and you'll see how simple it is. And here is that annotation. This is Python. So you can see here that we just have an activity decorator.

Cornelia Davis: The workflow is also pretty darn straightforward. You can see that I have a while true. We're just looping on the LLM. And if the LLM makes the decision to do so, we're going to call tools. In order to invoke the LLM, I execute that activity. Temporal has something called a dynamic activity. The dynamic activity allows you to call an activity by name, but that activity is dynamically found at runtime.

Cornelia Davis: Now let me show you this in action. Let's say are there any weather alerts in California? And so we're going to start. And you can see here that it said, oh, I made a call to get weather alerts. In the temporal UI, you can see each one of those activities that I called.

Cornelia Davis: I want to show you one other thing. I'm going to run this again. Now I'm going to come up here and I'm going to control C. No workers running. My agent is not running. It's not running at all.

Cornelia Davis: And this is going to give you the clearest picture of what I mean by durability is that I have this agent running and now it's stuck. I'm going to come back over here and I'm going to restart the worker. And what we should see happen is, oh, sure enough, it keeps going. So, it picked up where it left off. It did that through event sourcing.

Cornelia Davis: This is particularly cool when you do things like human in the loop. With temporal, you don't have to figure that out. You just code it as if that process. It'll take it out of active memory, and after days or weeks, when the user comes back and gives you that input, it just reconstitutes memory the way that it was when it was waiting for the user and continues on. It is so freeing to realize that I don't have to think about physical processes anymore.

Cornelia Davis: The OpenAI agents SDK the kind of paradigm that they use there is to build lots of small agents that have their own independent agentic loops and then orchestrate them together. And by the way, I just have to say I love the term microagent. Microservices have proven themselves to be very valuable. I think we're going to see a very similar paradigm when it comes to building AI agents.

Cornelia Davis: There's two ways that you can orchestrate them together. The just code is really simple. You execute an agent, get back a result and pass that result into the next agent. The second way is called handoffs. When you do a handoff what you're effectively doing is just changing the context of the agentic loop. So this works exactly. So temporal is totally handoff.

Cornelia Davis: Summing it up, this idea of bringing durability to these otherwise non-durable agent frameworks is a very popular one. So after we did OpenAI agents SDK, Pydantic themselves integrated temporal into their agent framework. There's more coming.

Cornelia Davis: If you want to get started, you can go to our documentation and find AI cookbook. We have an AI cookbook that implements a bunch of patterns. My team is hiring for folks on these AI applications of temporal. We're looking for developer advocates too. Well, thank you so much.