OpenAI + @Temporalio : Building Durable, Production Ready Agents - Cornelia Davis, Temporal

Channel: aiDotEngineer

Published at: 2026-01-12

YouTube video id: k8cnVCMYmNc

Source: https://www.youtube.com/watch?v=k8cnVCMYmNc

I'll introduce myself in 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 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?
Okay, about a quarter of you. um
any other um a agentic frameworks?
Okay, about the same set of you. So,
it's it looks like there's a hand 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?
Not very many. Awesome. I'm gonna get to
teach you some stuff. Um, okay, cool.
So, uh, 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. Uh, spoiler, we actually have
an integration between the two products
that Temporal and OpenAI worked on
together. Um, and so, and and you'll see
it's it's really quite sweet. So, let me
very briefly introduce myself. My name
is Cornelia Davis. I'm a developer
advocate here at Temporal. Um I have
spent a lot of time I think the bulk of
my career has been spent in this
distributed system space. So I was super
fortunate to be at Pivotal um working on
Cloud Foundry from the early 2010s. So I
was really there during the kind of
movement toward micros service
architectures, distributed systems,
those types of things. Um any Cloud
Foundry folks in the room? Oh, just a
few. Um, so for those of you who don't
know Cloud Foundry, Cloud Foundry was um
the early the early container technology
out on the market. It was incubated as a
open- source project at VMware and it
used um uh 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
very fortunate that I was there at the
beginning of that movement o over toward
platforms that supported this more agile
distributed systems way of doing things
and because I spent so much time in the
microservices world I also wrote this
book. Okay. So what we're going to talk
about today is we're going to talk about
the open agent a uh open AI agents SDK.
Then I'm going to give you a temporal
overview. I'm going to do lots of demos
and I'm going to show you the repos. If
you want to if you want to follow along,
you can go ahead and grab the repos.
Both of my demos I actually changed this
morning so they're sitting in branches
instead of in the main branches, but I
will make that very clear as well. Going
to do lots of demos there and then I'm
going to do uh move over to the
combination of the OpenAI agents SDK and
temporal together and we'll do more
demos there as well. And then I'm going
to talk a little bit about orchestrating
agents kind of in the general sense.
So this here is a notebook that we're
I'm not going to use today. And so I
decided I just ran this workshop earlier
this week and I decided that for the AIE
crowd it was way too basic. That said,
if you're interested, you can go there.
It will take you through. It's it's set
up with Jupyter notebooks. You can run
it in code spaces on GitHub and you can
run your first OpenAI agents SDK agent.
Then you can run your first 101 temporal
a uh not agent but temporal application.
Then you can move all the way through
the agenda that way. But it's pretty
basic and I decided that for this crowd
I wanted to do something more advanced.
So we're not going to use that today. Um
and I just crafted some of these demos
this morning. Okay. So without further
ado, this is going to be the shortest
part of the presentation is I'm going to
give you an intro to the OpenAI agents
SDK. This was launched in I think around
the May time frame or so. Um and I I'm
not going to read you these slides and
oh just so you know where we're going. I
am going to use some slides because I'm
one of those people where I think the
pictures really help. I've got lots of
diagrams in here, but we are going to
spend a lot of time stepping through the
code as well. I don't think I need to
define what an agent is. I will tell you
that that for me personally the
distinction that I make between Genai
applications and then when they get to
agents is when we give the LLM's agency
when the LLMs are the ones that are
deciding on the flow of the application.
That to me is what 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. And in
fact, we'll see that really we'll see a
contrast on that with the two major
demos that I'm going to show you today.
It's available um 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 it's
taken defaults for the rest of it. Other
things things that are defaulted are
things like the model itself. I don't
know what the default is right now. And
then all you can all you need to do
after that is you basically need to run
it. And anytime you see that runner.run,
what that corresponds to is an agentic
loop. And we'll talk about the agentic
loop several times throughout the
presentation. Every time you see one of
those runner.runs, it's its own agentic
loop. And when we get to the
orchestration stuff later on, you'll see
why I make that distinction.
It also as as I said this is really
simple here but it has a lot of other
options that you can put in place into
the agent configurations that that drive
how the agentic loop works. You can have
handoffs. We will talk about those. So
I'll clarify that later. But you could
put guard rails in place. You can you
can add tools. And we're going to see
both of my examples are heavy duty on
LLM agency and it deciding which tools
to use. So, I'm going to show you tools.
So, there's a lot more that you can do
in here, and I'll show you examples of
that as we go along. 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
and we'll see that. Okay. So that is the
basic um you know agent framework
overview and there's lots of a agent
frameworks out there. Okay. Since very
few of you know 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? So, it turns
out that temporal is beautifully suited
for these this category of AI of use
cases. Now, it's used in a lot of nonAI
use cases. So, for example, every snap
Snapchat goes through Temporal. Every
Airbnb booking goes through Temporal.
Pizza Hut, Taco Bell orders go through
Temporal. Um, there's lots of other ones
that I'm not remembering. OpenAI Codeex
runs on Temporal. So, now we start
moving into the AI use cases. Codeex
runs on Temporal. OpenAI's image gen
runs on temporal. Those are the two I
can tell you about. Those are the two
that are publicly known. Um, so we've
got lots of others out there, lovable
runs on on temporal. So we're definitely
making, you know, inroads, lots lots of
use in the AI space. So I've told you
who's using it, but let me tell you what
it is. What it is is distributed systems
as a backing service. So I think
everybody's familiar with the notion of
Reddus as a backing service or Kafka as
a backing service or a database as a
backing service. So I've got my
applications that are running and I use
these back-end services to serve, you
know, to play a part of my application.
Temporal is a backing service. What it
delivers is distributed systems
durability.
And I'll make that clearer as we go
through the presentation. What that
means is that you as the developer get
to program the happy path. You get to
program your business logic. And the
business logic that we're going to
program today are AI agents. So you get
to say, you know what, what I want to do
is I want to call an LLM. Then I want to
take the output from the LLM and I might
want to invoke some other APIs and then
I want to loop back to the LLM. 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 crash
crashes? You don't have to program any
of that. We do it for you. And I'll show
you a few pictures on how this works in
just a moment.
So there's a a temporal service that is
the backing service. And the way that
you connect to the backing service is
through an SDK. And so the SDK sits
alongside your business logic. So you
get to program your business logic. And
the way that you craft your business
logic, you put wrappers around certain
functions. And that allows the SDK to
say, "Oh, hang on. You're making a a
downstream API call. I'm going to step
in and I'm going to provide you some
service. So I'm going to provide you
retries. If that downstream service uh
succeeds, I'm going to record that for
you. I'm going to record the answer for
you so that in in the event that
something happens and we need to go
through the flow again, I can just get
the the result that you called before.
What that means is, 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. We support um we formally support
seven different programming languages,
but Apple just a couple of weeks ago um
released a Swift SDK as well. So there's
support in just about any language.
There's also experimental stuff out
there in Closure, those types of things.
I said it's an open- source project. The
vast majority of it is MIT licensed. Um
there's a little bit of Apache 2 left
over from in the Java SDK. So very very
permissive licenses and um those of you
who don't know the history uh temporal
was a fork of a project that was created
out of Uber called Cadence. Anybody know
Cadence? Yeah. Okay. So a few people
know Cadence. So 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. So that's kind of the overview of
what temporal is. So there's really kind
of I'm going to talk about two
foundational abstractions. There's a
handful of others as well, but 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. So it's work that might
fail. It's like a lot of work that might
fail. or if you are doing a lot of work
that you don't want to have to redo in
the event that something goes wrong, you
might want to put that in an activity as
well. So, it's things like withdrawing
from an account, depositing into an
account. We'll get to the AI use cases
in just a moment. So, those are
activities you wrap that Oh, and I
didn't mention it, but the SDKs are not
just thin wrappers that are sitting on
top of a REST API. These are SDKs where
as you can imagine be let uh delivering
durability across distributed systems
means that all of those algorithms that
you thought that you had to implement
like worry about concurrency and and and
um uh quorum and all of that stuff
that's all implemented in temporal and
so our SDKs have a lot of that logic is
in the SDK. The service is mostly
persistence for that. So there's a lot
of intelligence in the SDK.
So these activities, if you've said,
look, here's my work. Here's a heavyduty
piece of work or something that's going
external. Let's put an activity
decorator on that. Then the SDK says,
oh, okay, I'm going to give you some
special behavior. Then you orchestrate
those activities together into your
business logic. And what we call those
orchestrations is workflows.
Okay? So, and you'll see that what
happens when you put activities and
workflows together, that's where the
magic really happens. There is some
level of magic in the activities and in
fact, we're just starting to release
what we call standalone activities. So,
you'll be able to use activities without
workflows and get some of those
durability benefits there as well. So,
there's all sorts of evolution that's
happening. But the type of magic that
I'm talking about when you um bring
workflows and activities together is
that I overlaid
um a bunch of icons on here. So I
overlaid these little retry icons. So
what you do is you specify in your
workflow logic you specify the um retry
uh configuration. So you can decide are
you going to do exponential backoffs?
Are you going to do unlimited retries?
Are you going to top out at five
retries? Are you going to have a maximum
window between retries? You get to
configure all of that. And as soon as
you do that and you orchestrate these
things together, now you get retries.
And you'll see the code in just a minute
simply by calling these activities. I
don't have to implement the retry logic.
I don't have to implement any of this
other logic. It just happens for me. So
I get retries. I also get these little
cues. So what looks to you like a single
process application I'm calling this
then I'm calling this and I'm calling
this every single time you call into an
activity every time you come back from
an activity to the main workflow all of
that is facilitated over cues so that
what looks like just a single monolithic
application is already turns into a
distributed system. So you can go and
deploy a whole bunch of instances of
those and you can basically scale by
just deploying more instances of it. You
don't have to manage and I you don't
have to manage Kafka cues any of that
stuff. It's all built in. I spoke with
somebody this week here at AI Engineers
um who's who's a an open source user
actually a customer of ours and I asked
him it's a relatively small startup and
I said you know why did you pick
temporal and he said because we tried to
build all of this with Kafka cues and we
ended up spending all of our time doing
operations on Kafka and spending 25% of
our time on the business logic when we
switched over to temporal we're spending
75% of our time on business logic and
they're using temporal cloud. I didn't
mention our business model is that we
have it that that that service we offer
that as SAS. So they're using temporal
cloud. So they basically shifted from
2575
to 7525 by moving over here. No longer
have to manage Kafka cues or red reddus
or anything like that. And speaking of
Reddus, you see in the upper right hand
corner you see state management. And so
one of the things that we do as well is
we keep track of where you are in the e
execution of your application. We do
that by recording the state. Again,
every time you're making calls to an
activity and coming back, we record
that. It's basically event sourcing.
That's what we're doing. It's not only
event- driven architectures, but we're
doing event sourcing as a service. So
you you get to do that. So, we store all
of that state so that if something goes
wrong, and I'm going to demo that, we're
going to see things going wrong, um, it
will pick up where it left off because
we will just run run through the event
history and pick up where we left off.
So, those little icons that I showed
overlaid on the logical diagram, I'll
get to your question one second.
Actually, all of those services live up
here in the service. So, they're all
durable. So it's not that they're living
in the process, but they're living here
in the service. You have a question?
>> Not sure it's relevant. So a lot of the
agents I have, they handle streaming
data.
So I wanted to see if help with that.
>> Oh, great question. So yeah, so the
question was a lot of the agents that
I'm building are doing streaming. Do you
do streaming? And the answer right now
is a very simple no, we don't. But it is
one of the things. and my colleague at
the back, Johan, um is uh head of AI
engineering. Um so chat with him, chat
with either of us. It is one of the two
top priority things that we're working
on right now. Um the other one is large
payload storage. If I don't have a
chance to to talk about it here during
the workshop, come find one of us. We
can tell you about that. You can imagine
what large payload storage is. is that
you're doing LLMs, you're gonna you're
gonna passing big stuff around. Instead
of passing it around by value, pass it
by reference. That's what large payload
storage is. That's Johan.
>> I'll just mention there are a bunch of
people using workarounds.
>> True.
>> Screening in production today at scale.
So happy to talk about that, but there's
going to be more integrated solution
coming.
>> Yeah. So I ju I'm just going to repeat
what Johan said in case you you couldn't
hear it. So we do have customers that
have built streaming support on top of
temporal, but what we're doing is
building it in natively. So, yep. So,
you can do it today. It's just a little
bit more work. It's not the happy path.
So, okay. Um, so with that, uh, I want
to give you a demo. So, this is going to
be my first demo that I move over here.
Let's see if I can get my screen back.
Okay. So, if you want to follow along,
the first thing I'm going to do is I'm
going to come over here and I am going
to let me increase the font size. Um, so
I'm going to point you to two
repositories. This is actually the
second repository, but what I have up on
the screen right now is that if you want
to get started with temporal, super
simple, you don't have to use temporal
cloud. You can just run a temporal
service. So, the backing service, you
can just run it locally on your machine.
So you can do it by curling this. You
can homebrew install it as well. Um and
then to run that local server, you can
just say temporal server start dev. And
now you've got a temporal service that's
running locally. And all of my um
applications here are just connecting to
my local host. Um and we we'll see the
UI in just a moment. Um I'll come back
to this uh repository in just a moment.
The repo that I'm going to demo for you
is this one. And um sorry I don't know
how to uh increase the font size but you
can see that the org and the repository
here is the org is temporal io. That's
also where you'll find all of the open
source for temporal. Um and then we have
something called the AI cookbook and
that's one of the examples. I I I
actually extended the example just this
morning, but um and you're going to find
that um in the the branch that we're
going to demo here today is called the
agentic loop de branch. So if you want
to, you know, go back and take a look at
this later on um yourself, that's what
we're going to be looking at. Okay. So
with that, let me get to my right
terminal.
And um so this is where I'm going to run
it, but I want to show you the code
first.
Okay. So am I in the right uh
one? OpenAI. Nope. This is the wrong
one. My other cursor. Here we go. So
this is the agentic loop. So I'm doing
two demos throughout today.
And so what you see here on the left
hand side, let me make it just one tick
bigger is that remember that I talked
about activities and I talked about
workflows. So that's the first thing I'm
going to do is I'm going to show you the
activities. Remember we had withdraw and
and and uh and deposit, you know, that
type of thing. Here, of course, what
we're doing is an agentic loop. So my
activities are going to be um call the
OpenAI API, not the agents SDK yet, just
the OpenAI a um API and invoke some
tools. So these are my two activities.
So let's look at the first one and
you'll see how simple it is. I promised
you the happy path. It really is that.
So here is my call to the OpenAI
responses API. Okay, it is exactly what
you would expect. I'm passing in the
model. I'm passing in some instructions.
Um, the user input is going to come in
my tools, which I'll show you in just a
moment. And then I've got some timeouts
that I can configure there. That's for
the OpenAI.
What I've done is I've wrapped that in a
function. It takes in that request. So,
all of those parameters came from a
request that I'm passing in. And you'll
see how I invoke this in just a moment.
And here is that annotation. Now the
different SDKs have different
approaches. TypeScript for example
doesn't require a bunch of annotations.
It just figures it out. It knows where
the activities are. Java has um
annotations. Those types of things. But
this is Python. So you can see here that
we just have an activity decorator. So
by just having that decorator, so you
can see it's not complicated at all. All
you need to do as a developer is say,
"Here's a a bunch of work that I want to
do that I want to kind of encapsulate
into a step." And you just put an you
put it in a function. You put an
activity decorator on that.
So, I'll come back to the tool invoker
in just a minute because there's
something interesting that's going on
here. So, now if we go to the workflow,
the workflow is also pretty darn
straightforward. So what I have here is
I have my workflow definition. You can
see it's a class. The reason it's a
class is because there when you create a
workflow you create the application main
what I call the application main and
that's what has the workflow.run on it.
But this workflow also I'm not going to
cover these abstractions today but we
have a handful of other abstractions
like signals.
So for a running workflow, you can
signal into it and we also have an
abstraction called an update. It's a
special kind of a signal. And we also
have the analog which is queries.
So those things are added to this
workflow class as just functions that
are annotated with signal update or
query. So that's why we've got a class
for the the the workflow. And if we take
a look at what the logic is in here, you
can see that I have a while true. So
this simple application is just that
same picture that I showed you earlier
where I said the LLM is we're just
looping on the LLM. And if the LLM makes
the decision to do so, we're going to
call tools. That's the whole
application. But you're going to see
that I'm doing a couple of interesting
things with temporal here. So in order
to invoke the LLM, I execute that
activity. So you can see that I'm
passing in my model. Um the instructions
here, I I won't show it to you, but you
can see it all in the repository. The
helpful agent system instruction
basically just says you're a helpful
agent. If if you if the user says
something and you think you should be
using a tool, let me know. You know,
choose a tool. Otherwise, respond in
haikus. You'll see that in just a
moment. Like haikus are like the fooar
of the AI world, right? Ever we're all
we're all going to write agents. It's
the hello world of of the agentic space.
So we're going to respond in haikus. Um
and that's it. So we're doing this at a
while true. And I've got a couple of
print statements there. You're you're
going to see how this runs in just a
moment.
Simplifying assumption here. I'm making
the assumption that it's only calling
one tool at a time. So I'm grabbing the
output of that. And then I just take a
look at it and say, is it a function
call? And if it if it is a function
call, then I'm going to handle that
function call. I'll show you that code
in just a second. And then I'm going to
take the output from that function call
and I'm going to add it to the
conversation history. So I'm not doing
any fancy context engineering here. None
of that. I'm just basically tacking onto
the end of the conversation history.
Okay.
Now, handling the function call is
really straightforward as well. So the
first thing that I'm doing is I'm adding
the response from the LLM. So there's
we're going to by the time we're done
with this function call, we're going to
have added two things to the
conversation history. We're going to
have added the response from the LLM
which says please make a function call
and then we're going to do the function
call and then we're going to add the
result. And I just showed you where
we're adding the result of the function
call. So here, this is just me adding
that to the um and this is some of the
squirrel stuff. I'm I have this this
application running against the um
Gemini API as well. And the biggest pain
in the butt in all of this stuff is that
the formats are different. So I have to
rewrite because the JSON formats of
conversation history are different
between the different models. Yes, I
know there's um light LLM out there, but
I don't like least common denominators.
And also I like to understand what those
formats look like. So um but you can see
here that I'm just doing some ugly
parsing and then I'm executing remember
I'm handling the tool call here. I'm
executing the activity with that tool
call. So I've p pulled the tool call out
of the response from the um LLM and then
I'm going to invoke that activity which
is execute activity and the item name is
the tool.
Now one of the things that I was really
intent on here is that I didn't want to
build one aentic loop application that
does one set of tools and then have to
rebuild a whole another one when I have
a different set of tools. the agent
itself and we heard I don't remember who
talked about this but somebody talked
about this on stage this week where they
said look the agentic pattern is the is
is fairly standard and what we're doing
now is we're inserting things into this
standardized agentic loop and that's
exactly what these um AI frameworks are
doing these agent frameworks and I
wanted to do that here in the temporal
code as well the cool thing is that
temporal has something called a dynamic
activity
The dynamic activity allows you to call
an activity by name, but that that
activity is dynamically found at
runtime. So the activity handler here,
and I'm going to show you the code in
just a second, is basically going to
take in that name and say, oh, okay, I
and remember this is event driven. So we
have an activity that's waiting for
things on a queue. And so you can
configure an activity. You can configure
one of our workers to say, "Hey, this is
a worker that will basically pick up
anything off of an activity queue.
Doesn't matter what the name is." So you
don't have to tightly bind to a specific
topic name for example. Yes. Question.
>> I need in advance map which tools would
be available for the agent based on the
activity.
>> Um that is separate and I'm going to
show you that module. There's a module
here that you see that's called tools.
If you see the tools directory, the way
that I'm running it here, it is it loads
that stuff at the time that I load the
application. So, I'm not doing any
dynamic loading, but I can swap in and
out that tools module and the agentic
code does not change at all. So, I'm not
going all the way to the point where
I've implemented a registry and I'm
doing dynamic calling of those things.
You can do that, but this simple example
has basically just put that all into a
separate module. And you'll see how that
module can be switched in and out
because I'm loading it at at at um at
start of runtime. So, um simplifying,
but yes, you could do that. Okay. So,
I'm just going to call an activity. And
so, let's take a look at what that
activity looks like. It's this tool
invoker. And so you can see here that it
has the activity decorator just like I
showed you before, but now it says
dynamic equals true. So that means that
this activity handler will pick up
anything that is showing up on a queue
that isn't being picked up by some other
activity already. So it'll pick up it'll
pick up get weather. It'll pick up get
random number. It'll pick up whatever
shows up in there. You have to register.
Um, you do have to register. No, you
don't have to register all of those.
Those things can be done dynamically.
You don't have to register them into the
worker.
And what you can see here is that we
basically grab that. We get the tool
name. And then what you can see here is
that I'm effectively looking up the
function. You can see here there's no
tool names in here at all. It's
basically looking up the tool name from
a dictionary. it and it it's
metaphorically a dictionary. I'll show
you those those uh um functions in just
a second. So I have one function which
is a get tools function um which by the
way let me go back to that. So in the
open AI responses uh no sorry it's down
in the workflow when I invoke the LLM
right here. Notice that I made this get
tools call. I'll show you that get tools
call in just a second. It's completely
outside of the scope of the workflow and
the activities. It's in its own module.
I'll show you that um function in just a
second.
Okay. So, back to the tool invoker. It's
basically now taking the name and then
it's doing a get handler. So, somewhere
here is a get handler call.
Here's the handler.
>> You just passed it.
>> I just passed it. Sorry.
>> 17.
>> 17. Thank you. I appreciate it. So
here's the get handler and I'll show you
that function in just a second. So great
question on the like how tightly bound
are these things. Let me show you where
that binding is right now. So I have a
tools module here and I have in the init
is where I've got those two functions
defined. So, I've got the get tools
and the get tools are basically just
taking the list of functions and I'll
show you those functions and those
functions what we're passing in here is
we are passing in the JSON blobs that
are passed to the LLM as the tool
descriptions. So, these are the tool
descriptions. So, for example, let me
show you the get weather one. So, if we
go over here to get weather, you can see
that the um the JSON blob is right here.
And it's interesting because OpenAI
um in in the completions API, they had a
public API that allowed you to take any
function that has dock strings on it and
generate the JSON for the completions
API for the tools. The responses API has
no no such public API. So there's a
warning in here that says this API that
I'm using um which is in this tool
helper. I'll show you the tool helper.
Where is my tool helper? Uh helpers.
Here we go. I guess I could put that in
tools. Is that there's a thing in there
that says warning. There is currently no
public API to generate the JSON blob of
tools for the responses API. So I'm
using an internal one. There is an open
issue on this. So there's just a warning
in there that I'm using an internal one.
So if we go back there, I've used an
internal API to just take my get weather
alerts um request which is the uh it's a
pyantic model that has the the functions
in there and has some you know
additional metadata around it and it
generates the JSON blob. So again,
that's what you see when we go into the
agent is we that's what you're getting
with get tools is you're getting the the
the array of JSON blobs for each of the
tools. And then as I said the get
handler basically has it it's it's
basically a dictionary that I've
implemented as as a set of ifns. So it's
a takes the tool name and then it picks
up what the actual function is
completely independent. And so this
particular example has a set of and I'm
going to demo those for you in just a
second. It has a set of tools here. Um
and you can just switch those things
out. You do have to restart your Python
pro process at the moment just because
of the way that I've implemented it.
Okay. Make basic sense. All right. Let
me show you this in action.
Um and so what I've got here is I'm
running uh the worker. I'm not spending
a lot of time here talking about
workers, but you remember that I said
that this is all event driven. Um, and
so there's something that is picking up
work off of event cues and then
executing the right workflows and
activities based on what it's pulled off
of the event cues. The the um the thing
in temporal that does that is what we
call a worker. So a worker is a process
that you run. with that worker, you
register the activities and the
workflows that that worker is going to
be responsible for. So it's going to be
looking for things on the queue to pull
off of those. That worker itself is
multi-threaded. So it is not one worker
one process. Um in general people run it
depends you can do worker tuning but in
general people run several hundred
threads. So you run one worker and it's
already a a a you know concurrent
multi-threaded architecture. Okay. So
this is some solid stuff. Temporal is
just the coolest stuff. It's really
truly is distributed systems designed.
Okay. So I'm running the worker up here,
which is effectively where you're going
to see the outputs coming from the
activities and the workflows. And I'm
going to go ahead and run um run a
workflow. And so
let's say are there any weather alerts
in California? That's where I'm from.
And I think a lot of you are from and
hopefully where I will be headed back to
tonight. And so we're going to start.
And what you can see here is the way
that this application is written is
basically I I um say whether or not I'm
calling a tool. And so you can see here
that it said, oh, I made a call to get
weather alerts. Um and that is what's
happening. So there's a tool call that's
happening. And in just a moment, I
happen to know that as soon as we get a
few drops of rain in California, you
know, there's alerts all over the place.
So, here we go. Here's a whole bunch of
weather alerts in California. You'll see
why I'm I'm pointing that out. It's kind
of fun. Um, okay. Now, let me show you
what this looks like in the temporal UI.
So, over here I have the temporal UI,
and you can see that I've run a bunch of
workflows this morning. And so, let me
refresh refresh this. And this is the
one that I just ran. And what we see
here is, yep, there's all of that dense
fog advisory. That's that's about as as
extreme as we get in California. A
little bit of fog, a little bit of wind,
high surf, beach hazards. But here is
what happened. So you can see in the
temporal UI, you can see each one of
those activities that I called. You can
see that I made a call to an LLM. That's
the create line that you see on the
bottom. So we're working from bottom to
top. Then you can see that I did a
dynamic activity, but the dynamic
activity that I did in particular, it
doesn't say generic dynamic activity. It
says I did a get weather alerts. And
then as we do with agentic loops, we
take the output of the tool and we send
it back into the LLM and we get this.
Now
I want to show you something here. I'm
gonna show you a different example. So,
I'm going to ask the question, are there
any weather alerts where I'm at? So,
does it know where I'm at? And I'm going
to start this. And I'm very going to
quickly going to come over here and
we'll see this one running. And you can
see Oh, I'm going to be too slow it
looks like, but I'll I'll come back and
I'll redo this demo. But you can see how
it just it's, you know, brought those
things in. So, the other So, I have
three tools registered right now. I have
a tool that takes in a state. I have a
tool that takes in um an IP address and
returns a state. And I have a tool that
gives me an IP address for the currently
running computer. And so I didn't I
didn't wire that up that the LLM made
those decisions just based on the tools.
So all I did was I provided those tools.
But you can get that visibility across
this in temporal. So, you can see that
we started with get IP address, then we
got the location info from that IP
address, then we got the weather alerts.
And here's the ironic thing is there are
no weather alerts in New York. So, I
think of New York as a place that has
much more weather, but maybe today is
cal. You have fog, but there's no fog
advisories. So, y'all are a lot more
resilient than than the rest of us
Californians.
Okay. So, I want to show you one other
thing, which is I'm gonna come back over
here. I'm gonna run this again, and I'm
going to try to be I I can be a lot
quicker. So, I'm going to hit okay. And
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.
And so if we come over here and we take
a look at what this looks like in
temporal and this is going to give you
the clearest picture of what I mean by
durability and durable agents is that I
have this agent running and you can see
that it made the first LLM call. Then it
got the made the tool call to the IP
address and now it's it's stuck. It
started to call the LLM but hang on it
something went wrong. the agent itself
is not running. And by the way, I could
have also done a demo. And I don't have
the time to do all of those today, but I
could have done a demo where I cut the
the network. So I could have cut the
network. And what you would have seen
here in this little red bar is you would
have seen it. Create attempt one, create
attempt two, create attempt three. I
could have brought the network back and
then it would have gotten through. But
for brevity here, because I still want
to I still have more stuff to cover. I'm
just showing you one of the failure
scenarios. There's tons of failure
scenarios that are covered. So, 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. Now, when I say it picked
up where it left off, of course, I
killed the process. There was nothing
running in memory anymore. So, when I
brought the worker back, it had to
reconstitute the state of the
application. It did that through event
sourcing.
So that's the way temporal works
fundamentally. Any questions on that?
Yes.
>> Can we delegate one agent to another
agent?
>> Can you delegate one agent to another
agent? Absolutely. Now we do not yet
have native support for A to A if you're
thinking about that protocol in
particular. But one of the things that
you can certainly do is that you can
have an agent act as a tool. And so
there are a number of different ways to
do that. You can either have an activity
invoke another agent or you can use some
other mechanisms. We have child
workflows and those types of things. I'm
not going to cover that more advanced
use case. But yeah, absolutely.
>> A couple of questions. One thing is the
way you are coding it. It seemed the
functions very itemed. There was like
one single line essentially. uh how to
make sure that the developers are you
know creating function so that the
retries are posing a lot so
>> second question is the latency just
added through because of the framework
>> okay I'll so first question is about
around item potence so you have
recognized that um the activity
activities themselves should be item
potent um we don't require it we don't
check on it because We really don't get
into the inner workings of the
activities. We leave that up to the
developers. Um but that is the the
guidance is that if they're not item
potent because remember that when we do
retries on your behalf, we don't know wh
why we never heard back from the first
invocation. So we are going to keep
retrying until we get back a response.
Of course it could be that the request
never made it to the activity. It could
be that it made it and it invoked the
downstream function could have gone
wrong in a number of places. So how do
you make sure that your developers are
doing uh creating your activities to be
item potent education. So we don't have
any silver bullets there. The second
question was around latency because yes
I am going up to the server here um with
every one of those activity calls and so
when we when we think about agents um we
the type of latency and Johan I don't
remember the exact numbers do you
remember what the numbers are I mean
it's tiny the latency to go up to the
server around activities
>> u so it's going to depend a bit where
the server is but it's tens of
milliseconds
>> tens of millc seconds. So it's pretty
small. Um so whether I I I think I have
heard of several customers who are using
this in quite realtime applications. But
in the case of agents, especially agents
where they're long running and they're
running over minutes, hours, days, or
they have user interaction, tens of
milliseconds is is is tolerable. So
there might be use cases where it's not
applicable because of that latency, but
it's pretty small. It's applicable in
most cases.
Okay. All right. So, that is the
temporal overview. Now, I want to switch
back over to the agents SDK now and show
you the differences and the
similarities. So, let's come back over
here. I'm going to go through a few more
pictures.
Okay. So the OpenAI agents SDK the
combination of these two things at a
very high level looks like this. At the
foundation we have the OpenAI models and
the OpenAI API not the SDK but the
OpenAI API. So you might have noticed
that I've already been using the OpenAI
API and we're now going to start using
the agents SDK. And then we also have
temporal as a foundational element. And
now that's what the agents SDK is
layered over the top. So those are two
foundational components. So it isn't
that we're making that temporal sitting
on the side or open AI models are
sitting on the side. We have actually
integrated these things and I'll make
some comments when we get to the code on
how we did that integration and I'll
totally invite Johan to add to that as
well because he led the in led the the
engineering for the integration here. So
now you've got the agents SDK and now
you're going to use the agents SDK to
build your agents to add guard rails.
We're going to I'm going to show you
some tracing. So I showed you the
temporal UI, but the agents SDK has some
really cool tracing features as well.
And you'll see that we've integrated
those things together. You're going to
see those come together. And of course
tools.
So I've been talking about these
temporal activities and we already saw
this. I'll skip that. uh skip that. Um
and so now uh we're I'm going to take
the same exact example that we just went
through. I'm going to have three tools.
One is the weather API and the other two
are those location APIs. And what are we
going to do? Well, we're going to put
activity decorators around them. And
I'll show you what that looks like in
the other codebase in just a moment. We
are going to make sure we have doc
strings in there because I showed you
how the open AAI API had the um the uh
the internal helper function that
allowed us to generate the JSON blobs to
describe the tools. Well, the agents SDK
actually does even more of that for us.
So, you'll see that some of my code went
away. Um and then uh yeah, and then
we'll we'll car continue on from that.
And then and this is going to be our
loop here.
I'm going to show you when we get to the
code that the um the way that we create
that JSON blob is part of the
integration. So you can take an activity
and we have provided for you a function
called activity as tool that will take
in the activity the function itself. So
you don't have to worry about
serializing it yourself. No internal
APIs. This is a public API. It's part of
the in the integration. and you're going
to call activity as tool which is going
to generate the um the JSON blob and
then you can have your timeouts as well.
There's another part which is really
important which is that you have to
configure the integration. So you have
to the agents SDK alone doesn't use
temporal and if you want to use temporal
you need to make sure that you include a
plugin and I'll show you the code for
that in just a second. And then of
course we're going to run it and we're
going to run it the same basic way.
Okay. So let's demo that. So we're going
to spend a lot more time in code and
demo again. Let me come back over to
cursor. Okay. So I've got four four
files that I want to show you here. I'm
going to start with the activities
again. So here's the get weather
activity and you'll see that it actually
got a bit simpler. It's just has the
activity decorator on the get weather
alerts and then here's the function
where it actually makes the the U
National Weather Service API. So there
was another there was a bit of um code
in there that was doing some formatting
where it made that API call to generate
the JSON blob that goes away because we
have a a supported function for that.
The location activities equally simple.
So literally this is the entire file. So
I've got these two functions with the
activity decorators and my dock strings.
So the doc strings are describing the
the arguments and so on. Okay. So now
what about the agent itself? So remember
activities were just the things that
those were the tools that the agent was
using. What I showed you before was an
agentic loop written in Python that was
orchestrating the LLM call and the tool
invocations.
So now if I come over to the workflow,
what does my workflow look like? This is
it.
So I have
sorry this is it. This is the workflow.
Okay. And it's basically let me increase
the font size because I have plenty of
space. is notice that I'm using the
agents SDK. So I'm defining an agent
right here on line 18. I'm giving it a
name, your helpful agent, and I'm giving
it a set of tools. Those tools were
implemented as activities.
And there you can see that I've made the
function call that says activity as tool
that generates the JSON blob.
That's it.
That's all there is to it. That's the
way I've implemented it. Now notice that
I'm still doing it within the workflow
because remember earlier I said we've
got activities, we've got workflows.
When you put them together, that's where
the magic happens. So putting this agent
inside of a workflow, that's what adds
all of these durability capabilities.
Now I am not going to demo the
non-durable version of this because
again we just have constrained time here
today. But if I had implemented this
with just the agents SDK, which is just
a Python library, I would have had a
single process. And if I killed that
process, it everything would have gone
away with it. I there's no way for me to
scale that process. And remember, I've
got an a runner.run right down here,
right? So every one of those runners I
it's just it's just a it's a monolithic
agent, right? It's just one Python
process. By doing it this way, you can
see that if I'm running multiple
workers, I can just keep scaling this
out by just running multiple workers who
are just pulling other things off of the
queue.
>> Yes.
>> Do handoffs to other agents work?
>> Do handoffs to other agents work? Yes.
And I'm going to come back to that in
the final section where we're going to
talk about orchestrations. Um, yes, they
do. Absolutely. Um, okay. So, now let me
go to uh I need to I do need to get one
other thing out of here. I need to get
my worker.
Um where is my worker?
Here's my worker.
because it's in the worker where
where's the plugin? Johan, help me out.
>> I just passed it. Oh, here we go. OpenAI
agents plugin. Okay, so it's in the
worker. Remember the worker is where all
the execution is happening. Think of it
as kind of like a logical metaphorical
container. And oftentimes you are
running the workers in containers. And
here's the configuration that you need
to put in there. It's those and notice
that it's doing things like it it is um
configuring some of the retry behavior
around the LLM. You'll notice, did you
notice that I did not give you an
activity for invoking the LLM
that's done as a part of the agent, but
we still want that to be durable. And
that's what one of the things that our
implementation does here. So you're
doing some retry policies for the LLM
and you're basically saying hey a open
AI agents SDK use these parts of
temporal.
So let me tell you a little bit about
what we did as a part of the
integration. What we did if you go back
and you look at the commit history of
the OpenAI agents SDK you'll find a
commit where it says make the runner
class abstract.
They did that for us because that's how
we imple that's how we got this
durability. That's how we were able to
make the LLM calls durable along with
all of the tools that you just saw. So
we have our own implementation of the
abstract runner class. So that is the
way that this works. Okay. So we've
looked at the activities, we've looked
at the workflow, and then we run the
tools workflow. So, I don't think
there's anything more to look at there.
So, let's go over
to
this. Um, let me find my right window.
It is this window.
Okay. So, what I'm doing in this window,
let me go ahead and increase my font
size a little bit. Is up here in the top
window. And I'm going to exit out of
these because I only need two.
Okay. So, in the top window, I'm running
my worker again. You saw that before.
So, I'm running the worker up there. And
so, it's got a little bit of, you know,
log messages that are going to come out.
And then down here is where I'm starting
the workflow. Here's where I'm
interacting with the agent. So, I'm
going to I just pushed some of this
stuff. Oh, I'll show you the the
repository in just a second. So, are
there any weather alerts in California?
And remember the code. The code is just
that agent, right? We've still
implemented our activities, but the code
is that agent and we are checking and
you can see the things that are
scrolling up there. So, you can see
actually the uh API calls to the LLM.
You can see the API call to the National
Weather Service. And so if we come back
over to the temporal
UI,
it's a different it's called tools
workflow. Here you can see it looks
exactly the same,
right? And that's why I wanted to spend
some time showing it to you with
temporal because temporal, if you're
building these temporal native
applications, you get all this
durability. You get this visibility. It
looks exactly the same, but you were
using the agents SDK to implement your
agents, which I think is just so cool.
So, let's run a second one.
And uh I'll show you the repository in
just a second. We're going to run this
second example which are are there any
weather alerts where I am. And we're
going to come over here. We'll watch it
in progress.
So here it's running.
And it's running exactly the same way.
And I'm going to run it one more time
when it comes back. And it says, "Nope,
you're good in New York." Let me run it
one more time. I'll let it get started.
Get part of the way in. Control C out of
this. And we come back here
and we see the same thing that we saw
before, right? Agents SDK durable,
which is so sweet. I I sorry I get I I
do this all the time, but I still get so
excited about this. Um
and there it goes.
I'm going to share with you like um um a
a way to think about this intuitively
what we're doing here. I've been writing
software for over 30 years. Yes, I have
the gray hair to prove it, right? I have
I have written that software where I
when I'm writing the software, I'm
thinking about the processes that it
runs in. I'm thinking about the fact
that oh I've got a process here and what
happens if something happens to that
process or as I'm scaling things out and
things might not run in the same
processes I'm always thinking about
processes
with temporal what you get to do is you
get to write your program thinking about
a process as a logical entity and just
let temporal map it down to the actual
physical processes that are there. This
is particularly
it it's it's so cool to look at when you
do things like human in the loop. So
earlier this week I did another I've
done another I another one of the talks
that I do is around human in the loop
with agents and one of the big pains of
human in the loop is that when you're
thinking about building these things and
you're thinking about the processes
you're like okay I need to run for a
little while and now I'm going to wait
for the human in the loop and it might
take a second it might take a minute
likely it's going to take hours or days
before this human comes back. What do I
do with that process that's waiting for
that response in the meantime? Like you
as a developer have to figure that out.
With temporal, you don't. You just code
it as if that process. And by the way,
the way that the worker architecture
works is that if it's waiting on
something like human input,
it it'll keep it in memory for a little
while, few seconds, then it'll take it
out of active memory, but it's still
sitting in a cache. And after a little
bit more time, it'll come out of the
cache and it'll be just as if you had
just killed that process. So that when
it does come back 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. So
remember I said it's a crash or it might
be other things, operational things, all
of those types of things. So, it's so
freeing once you start to really get
into this temporal thing. It is so
freeing to realize that I don't have to
think about physical processes anymore.
To me, the processes are just logical.
Temporal takes care of the rest for me.
Super cool stuff. All right, we have
about uh 20 minutes left. I'm going to
go through just a couple more slides to
answer one of the questions around
handoffs.
um and just show you just a little bit
more content and then we're we'll have a
little bit of time in the last I don't
know maybe 10 you know 10 or 15 minutes
I'm happy to take more questions and
Johan would be I'm sure very happy to to
jump in as well. Okay. So, let me
So, um
there are with the OpenAI agents SDK.
This is what I'm talking about here is
somewhat specific to the agents SDK, but
this does kind of generalize to agents
in general, which is with the open AI
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 there's two ways that you
can orchestrate them together in the
agents SDK. And I'm going to show you
both of those in just a moment. So what
we see here on the screen are just a
couple of diagrams of like, okay, I've
got a triage agent. I've got a
clarification agent. Then I've got a
human in the loop. That's not an agent.
Although you might think of the human as
the agent in this application, right?
Then I've got an instructions agent
that's going to craft some stuff. Then
I've got a planning agent. Then you can
see that we're doing things in parallel.
I didn't talk about this, but temporal
has all those abstractions. You can
anything that you can write in a regular
programming language, you want to do
multi-threaded and have a bunch of
different threads and do things in
parallel and then wait for them to come
back together. You can do that. You want
to have some kind of an await that says,
you know what, as they start coming in,
I'll start processing them. No problem.
You can do that. Anything that you can
do in code, you can do with temporal
because you're just coding. So that's
effectively the way that it works here
with the agent SDK as well. Um I'll show
you those things again as well. So you
can do parallel, you can have long
weights. Um and you can have loops. So I
already showed you the fact that I
didn't have to craft my logic in the
Python. The logic the LLM made the
decisions on how the flow was going to
happen in that application. Right? So I
just had a loop that the loop itself is
like fixed, but what happens in the loop
is entirely determined by the LLM. So
that those are all things that you can
do. So there's two ways with the agents
SDK that you can orchestrate these
microaggents. And by the way, I just
have to say I love the term microaggent.
As I mentioned early on, um I uh I spent
a lot of time in the microservices world
and oh my gosh, did we get a lot of
mileage out of that, right? That's the
reason that we can deploy software
multiple times a day. That's the reason
why we can scale the way we can scale.
Microservices have proven themselves to
be very valuable. we I think we're going
to see a very similar paradigm, very
similar success when it comes to
building AI agents, MCP tools, and all
of that kind of stuff. So, I love the
the notion of microaggents that do one
thing and one thing well. I've spent
enough time in the land of Unix as well
that makes my heart sing.
So, just code and handoffs. The just
code is really simple. It's what I
described um before. So, you can see
here that I have a runner.run. I'm
executing an agent. I get back a result
from that agent and I pass that result
into the next agent. I can parallelize,
I can loop, I can do whatever I want.
The second way that Oh yeah, and I
already showed all that. Um, so yeah.
Yeah, I I mentioned all of those
already. Um, the second uh uh way that
Open AAI and were you talking about Open
AI specifically when you were asking
about handoffs? Yeah. So for those of
you who don't know, OpenAI has a second
way of doing orchestrations which are
called handoffs. And so what you see
here is that in my definition of an
agent, I can define handoffs. Those
handoffs are other agents. They've been
defined. I probably should have it on
the slide, but I have a weather agent
that is defined very similarly. It's
using agent has a name, has
instructions, might have tools.
So these two are agents.
Um and all of this works with the the
the e the integration with with um
temporal and but what's interesting here
is that those microaggents when it hands
off to an agent it is not doing a
separate agentic loop. it effectively
and this is my wacky attempt at trying
to describe what's happening here is
that when you do a handoff what you're
effectively doing is just changing the
context of the agentic loop so the a
there's one single agentic loop you have
a triage agent for example it decides
that it's going to go into delivering I
worked at Alexa for a while so did you
ask how late is Costco open or did you
ask what the current temperature is
right. So those are two different
agents, the weather and the local info
agent. And what you're effectively doing
is you are that that agentic loop is
taking on a different persona. You're
just switching the context. And we heard
lots of talks this week about context
engineering because that's the beautiful
thing about the LLMs being forgetful is
that you can just you can completely
control what you want, what the context
is that's going into them. So this works
exactly. So temporal is totally handoff.
I don't have a live demo of that. Um,
and so that's it. Okay. So, with that,
we're going to have a few minutes left
for questions. I want to leave you with
a few resources. So, what you see here
on the um left hand side is you see a QR
code for the uh temporal Python SDK.
You'll find lots of great info on our
Python SDK, but you'll also find a
contrib directory and that's where all
of the integration code to the OpenAI
agents SDK is. And you'll find lots of
samples in there. On the right hand
side, I didn't have a QR code for it
because my marketing folks don't work on
Saturday mornings. Good for them. Um, is
you will see a URL UR URL here. So, if
you go to our documentation, so
docs.temper temporal.io. At in the top
banner, you'll find AI cookbook. We have
an AI cookbook that implements a bunch
of patterns. The one that I showed you
today, the Agentic Loop, is in a um
branch at the moment. It is ready to be
merged. It's been reviewed, but my
reviewer didn't actually give it an
approval review. They just reviewed it
and said, "Looks good, but I need an
approved, so I couldn't merge it this
morning." Um, but that uh recipe will be
up there. And there's a number of
others. There's a recipe in there for
OpenAI agents SDK. So you'll find that
in there as well. Um, so summing it up,
I don't I'm not going to belabor that. I
think we went over that as well. Two
other resources that I want to leave you
with is on the left hand side you'll
find our blog where we describe the
integration of the OpenAI agents SDK and
Temporal. So that's the blog on the left
hand side. The other thing you'll notice
is that that I have a paidantic blog
there. And so this idea of in bringing
durability to these otherwise
non-durable a you know agent frameworks
is a very popular one. So after we did
open AAI agents SDK pyantic themselves
integrated temporal into their agent
framework and Johan do you I I don't
know which ones we can talk about. We
have a whole bunch of other ones in
progress. Is that all we want to say or
do you want to talk about any of those
in specific? That's that's all for
today, but there's more coming.
>> Yeah, I think we have two or three or
four that are in progress right now that
will be popping out either from us or
from some of the other agentic
frameworks. So, this idea of bringing
durability to what is otherwise kind of
just a a proof of concept tool is is
turning out to be quite powerful. And
then finally, if you would be so
inclined, here's a QR code and a URL. If
you want to give us some feedback on
this workshop, we'd really appreciate
it. Um, and include in that feedback.
There's some free form in there. Include
in that feedback what you'd like to see
more of. Like, hey, this was cool, but
it didn't go far enough or you mentioned
this. I'd really I'd really like to see
more about Human in the Loop. By the
way, if you go on our YouTube channel,
you will find a bunch of different
presentations. So, the human in the
loop, I did a webinar on that like three
weeks ago. We've done some MCP module,
MCP things, even advanced. So, we did an
advanced one where where we showed you
how you can use temporal to implement an
MCP server that is durable and supports
sampling and elicitation in a much more
durable way than it otherwise is. Um,
and with that, we still have now about
eight minutes. Um, so, oh, I'll also
mention, especially if you're in the Bay
Area, but if you even if you're not, is
that our conference, our replay
conference, the temporal conference, um,
is in May and it's going to be at
Moscone. And so, we sure would love to
see you there as well. And oh, I you
know this this QR code here was meant
for the workshop that I did on Tuesday,
but heck, might as well use it here. 75%
off. Yes, 75% off the registration um
for uh replay. So, invite you to come
there. You'll find me, you'll find
Johan, you'll find a whole bunch more of
us. And you can see that we've got all
sorts of really cool people like Samuel
Coven is coming and we've got like
people from Replet and Nvidia and lots
more coming. So I'll leave the feedback
up there. So we have a few minutes left
for questions.
>> Yes.
>> Um how state saved temporal
>> how is state saved?
>> You shut down the server it just loses
all memory of all the workers.
>> Yeah. Okay. So you're talking about the
temporal server that I showed you how
you can run it locally. So when you're
running it locally, you can put a switch
on there that says, "Hey, store it in a
like SQL light or something like that."
So you can there is there's state that
backs it. I usually don't run that way
because I want to throw away things
anyway. Um,
so Temporal is open source and we have
lots of users that self-host it. Because
it's open source, we literally at events
like this always run into people. I ran
into somebody yesterday or something who
was like, "Oh yeah, we're using
Temporal." And I'm like, and they're
just using the open source. Um, so it's
it truly is open- source. Um, and so we
do have people who are self-hosting it
and we support relational database and
Cassandra as the backing stores on
temporal cloud. Part of the reason that
um that people come to cloud is that
first of all, we run cloud in 15
different Amazon regions. Uh I don't
know four, five, six Google regions. We
have multi-reion namespaces. All of that
durability. And then we do also have
some special sauce on the persistence
that allows us to do things more
efficiently. Um uh but we have people
who are hosting it quite quite
successfully using the Cassandra or the
database options. So yeah,
any other questions? Yes.
>> Start and stop the agents.
>> When I start and stop the instance the
agent you mean? I mean how do we stop it
if the user wants to stop it
>> the work so
>> the workflow
>> yeah
um so there there are a couple of
different ways that you can start a
workflow you can start a workflow
expecting it to be you know synchronous
and it just ends and you would have to
have some kind of a kill on that but
more commonly you're going to start it
in an async mode and you're going to get
back a handle and then you can do things
against that handle to stop workflows.
Um but generally the the most common
thing is that you are going to define in
your logic what it means to have
completed that agentic experience or
completed that workflow in some way
shape or form. And so you will decide oh
I'm done now and you'll just return. So
it's really as simple as doing a return
from it. It's that's a good question
though since we're talking about these
asynchronous things. I didn't talk about
it in this session, but one of the
really powerful things is that these
workflows can run for hours, minutes,
days, weeks, months, years, and it's
super efficient. And what we what a
pattern that a lot of our users use is
they use it they use a workflow as kind
of a digital twin of something else. We
call it entity workflows as well. So,
for example, you might have a workflow
that corresponds to a loyalty customer
and every time that loyalty customer
scans their QR code at the checkout
register, it'll send a signal into the
workflow and the workflow is otherwise
not consuming any resources and it will
just pop up, take the signal, process
what it needs to and go away again. So
that is a very very common pattern is
this notion of digital workflows as
digital twins of some um other processor
some other entity. Super super powerful.
Lots of people use that.
>> Yes.
>> Another one.
>> Yeah.
>> Um so if work goes down and you've got
it like in that block state where it's
just sitting,
>> how do you guys have any kind of
integration with like incident
management things that would like
trigger an alert so that engineer can
come in the worker? Yeah. So we we as
far as I know we do not have those
integrations but we our customers build
those integrations.
>> Yeah. Yeah. They absolutely build those
on top. Whether we have some of those in
cloud I'm not sure but it isn't
something like we don't have like native
Slack connectors or those types of
things. And some of that of course
wouldn't necessarily be a temporal
thing. Like if you're running your
workers on Kubernetes, you might have um
set up your Kubernetes configuration so
that when the when the um when the
container goes down, you're going to get
alerts or when you see something in the
Kubernetes dashboard where oh gosh, like
my autoscaler and of course you can have
these workers and you you can have them
running in on Kubernetes with
autoscalers. So a lot of that or you
know that like it orchestration stuff
probably would come through your
operational environment. Um you are
that's actually a really good point is
that we host the server but we do not
host the workloads for you. So you're
hosting the work workloads yourself.
Most people love that because they want
complete control over that. We are
toying with the idea in some instances
of maybe hosting workers in the future
but that's nothing on the road map right
now.
So yes,
>> examples of people building like voice
agents with temporal or
>> examples of people building voice agents
with temporal. I don't know of any
offhand.
I
>> I don't know of any that are deployed.
Um people are experimenting with it.
We're experimenting with voice agents.
Um and it's definitely something that
that makes sense. That's one of the
places where we expect agents to go in
the future.
>> Yep. Yes. question in the back.
>> So, I do not have Claude up in keep an
eye on the cookbook. I do not have
examples for Claude just yet. Um, I have
Gemini almost done. Um, and yeah, we
want to we want to add Claude to the the
cookbook as well. We'll also happily
take PRs. So if you want to take this
example and map it over to to Claude,
we'd love to have PRs on that as well.
So yeah, this this is the cookbook is
all open source. It's all in MIT
licensed in our main repository, our
main org.
>> Yes.
>> Any example agents on extracting
information from Excel, PDF?
>> Example agents of extracting from Excel
or PDF? I don't have any personally.
um you know we one of the other things
that I'll mention is that we have a code
exchange so we have um the cookbook is
ours and that's where we're very we're
very careful about making sure that it
demonstrates best practices and we we do
rigorous reviews on those because we
don't want to mislead you at all. We
also have a code exchange which we have
literally I think 20 or 30 or 40
examples in there. There might be
something in there. I'm I'm honestly not
sure. Um, yeah.
>> Is it like a GitHub?
>> Yes, it is. So, you'll find the code
exchange on our website and all and I
believe all of the entries in the code
exchange have GitHub URLs. We don't own
most of them um because they're from the
community, but they're in other people's
repositories. So, yeah, you would find
that.
>> All right. Well, this has been Oh, is
there another question? No, I I just
want to comment that uh we've mentioned
a few times that's coming or that would
be really really cool to do and um you
know uh my team is hiring uh for folks
>> the hiring plug
>> on these AI applications of temporal.
>> Okay. And since he said that I am a I'm
in developer advocacy. We're looking for
developer advocates too. So if you fit
the engineer profile talk to Johan. If
you fit the developer advocate profile
come talk to me.
So, okay. Well, thank you so much.