We Trust AI Agents That Break Every Day - Shy Ruparel, Temporal

AI Engineer · 21 min · 318 sentences · from YouTube's caption track

Each timecode opens YouTube at the start of that sentence. Line anchors (#s42) are the cue ids in the WebVTT, and every line carries its start and end seconds. All transcripts has every talk, and the whole corpus as one file.

00:00All
00:01[music]
00:12right.
00:12Hi everyone.
00:13I'm Shai.
00:13I am a developer advocate at Temporal.
00:16Uh I cannot see anyone in the room.
00:18So if you boo me or like want to throw tomatoes or something, I I will have no idea.
00:23Um all right.
00:27Oop.
00:27Clickers are difficult.
00:29There we go.
00:33I guess I'm not using a clicker today.
00:35So, uh, agents, they are everywhere.
00:37I'm guessing if you are in this room, you are probably building an agent or shipping an agent.
00:42Does that sound about right?
00:43Yeah.
00:44Um, so last year, KPMC uh conducted a survey and they figured out that uh we have seen $3 trillion in terms of corporate productivity gains in 2025.
00:55And that's from their uh Agentic AI report.
00:58Uh and from that 3 trillion, it's really fin uh financial services that are leading the way here.
01:04So 94% of fintech are saying that AI is core to how their businesses operate.
01:10And they've decided that AI isn't just a side project, but but it's like it's part of the business now.
01:15Like this is how we operate.
01:17Uh and 62% of those teams lose measurable time uh or revenue to reliability issues.
01:24So they haven't decid, you know, deciding that AI is uh that something we're doing isn't necessarily the same as shipping it.
01:31There's definitely still a gap between those two things there.
01:34Now to break it down, uh part of this is the shape of the work.
01:38Finance runs on longunning workflows, not not on individual models.
01:43Um you know, for some examples of their process, you can think of loan origination, KYC and AML, fraud review, uh paying people.
01:51Each of these processes tan spans multiple days, multiple systems, and usually multiple people.
01:58Uh so there's many many steps.
02:00There's many many systems and there's real money involved.
02:03So they can't mess anything up.
02:05And now imagine that we're going to go ahead and put an agent into the middle of that process.
02:12So uh at Temporal, we wanted to understand how things are actually going.
02:15So we conducted a survey.
02:17This is our second year running this survey, the state of development survey.
02:20uh we surveyed 554 engineers and engineering leaders who are actively using AI agents right now.
02:26Every number on this slide deck is either from that report uh or it'll be qualified in the bottom left from the report that I'm pulling it from.
02:35So to start things off, we can talk take a look at the demographic of that survey.
02:3848.4% have 11 plus years of experience working in industry.
02:43So we're not talking about hobbyists.
02:45And then the rema segment also has 6 to 10 years.
02:49So none of these people are hobbyists.
02:51They're all professionals working um every day.
02:54Um it's a mix of engineers, AI engineers, data engineers, platform teams, IT leaders.
02:59Twothirds of them were from the US, a third of them were from the UK in EMA.
03:04Uh and what we found uh is four gaps.
03:06I promised you all that this talk was about gaps in the title.
03:10Uh and the data shows that there are four major gaps and I wanted to walk through each of them and then close with kind of one big idea.
03:16So, let's go into gap one, and that's the gap between uh usage versus production.
03:21So, daily agent use from our 2025 version of this survey had us at about 47.3% of the folks that we talked to were using agents daily.
03:31Uh today, uh nearly a year later, we've doubled that to 80.8% uh of users are using agents in their day-to-day.
03:40Um, now using agents isn't necessarily the same thing as shipping agents.
03:46Uh, and so if we take a look at those teams again and ask them what they're doing, about half of them are running those agents in production or they say that those agents are core to how they ship.
03:55And then the other half of that is still experimenting or still only really using assistance.
04:02So we've got 49.1% of the folks that we talk to, half of the folks that we talk to are running agents in production are saying that those agents are core to how how things ship.
04:13Um, so that's a huge gap, right?
04:14Like that's a 30% gap between 80% of the people are using agents every day and 50% 49.1% are actually shipping them and using them in production.
04:24So far fewer people in production than actually using them daily.
04:28A and something seems to keep breaking on the way to production.
04:31And let's talk about what that is.
04:33And that brings us to gap number two, which is trust versus reality.
04:37Now, one of the things we asked folks in this survey was how much do you actually trust your agent output?
04:42And trust is really high.
04:44Actually, I'm really impressed by this number.
04:46Uh, a quarter of the folks that we we surveyed trusted the agent output almost completely.
04:51Most people trusted it somewhat and almost no one disrupted distrusted it.
04:55I did not get asked to to participate in this survey because I'm in that complete somewhat distrust category myself.
05:01So, I'm actually really surprised by this number from that survey.
05:05Um, yeah, 85.5% trust agent output at least somewhat.
05:10Uh, and that's going to be an important number.
05:12Let's come back to that 85.5 in a little bit.
05:15So, we also asked, how often do your agents have issues?
05:19Um, the pink bars are daily or worse.
05:22And that's a lot of pink for a number that uh 85% of people trust.
05:27That's a lot more pink than I would expect for an 85% trust rating.
05:31Uh, 41.1% of those folks hit those agent issues daily or more.
05:36So that's four in 10 of the people that we talked to see issues every day.
05:40And then 16.4 hit them every hour.
05:42So one in six of the people that we surveyed were getting an agent issue every hour.
05:47And then that brings us back to that trust, that 85.5% gap versus the 41.1% uh system breaking.
05:55Uh so so we trust the output and the system, but it still breaks every day.
05:59Uh both of those things are true at the same time.
06:02And getting good at agents doesn't seem to to make this go away.
06:06You can't skill your way out of this.
06:10um we were seeing teams that call themselves successful were actually 1.7 more times likely to hit issues continuously.
06:18So be in that hourly or daily category.
06:20Uh and it's not because they run more agents, right?
06:23The report found that agent count and issue frequency aren't actually correlated in any way.
06:28I'm guessing and the team at Temporal are guessing that maybe those folks are just looking harder for issues and so they're finding those issues some more.
06:35That's definitely something we need to dig into a little more when we do next year's version of this survey.
06:40But the important, I guess, takeaway is that even with how much you trust your agents, failure isn't going away.
06:46Uh you have to account for it.
06:47You have to plan for it.
06:48So the goal isn't zero failures, right?
06:51When we're using agents in production, it's just how do we make it so these failures don't cost us anything.
06:56Now, a really interesting stat is saying that 40% uh of the teams that we talk to says security is truly the thing that is blocking them from autonomous agents.
07:05And that's its own talk.
07:06Mason uh from the temporal team and Kim from the key card team actually gave a talk about this yesterday on the workshop day.
07:12So I'm going to defer to the recording of that talk uh rather than going to it myself um as well.
07:18And let's jump into that third gap the prototype uh that we were probably all seeing and working on last year versus the enterprise deployment.
07:26You know customers are actually touching it that prototype to production ready code system.
07:30And most teams going from an AI prototype want to go to production ready code uh really fast.
07:35We're seeing it in like really low numbers.
07:38Uh 51.3% uh are able to get an AI prototype to production ready in hours or faster.
07:46Uh that's like startup speed, right?
07:48That's traditional startup speed.
07:50Uh this falls apart though if you work somewhere big.
07:52Uh so if you work somewhere uh 5,000 plus employees, it tends to take months.
07:57Uh and the data breaks down at that point.
07:59The biggest companies about one in five says it takes months.
08:02Everywhere else it's about one in 20 saying that it takes months to get an AI agent deployed into production.
08:09So big companies uh are shipping at very different speeds.
08:13We're using the same tools uh and very different speeds.
08:15Half are shipping in hours and then at these large companies were doing it one in five taking five months.
08:21Um big companies, regulated work.
08:23Uh we're talking about banks, we're talking about insurers, we're talking about payment companies.
08:27I'm guessing there's a lot of those in the room right now.
08:30And those companies all need something really need a bunch of things that are really important, right?
08:34They need approvals.
08:35They need audit trails.
08:36They need systems that will not lose a payment.
08:39My read is that's where the five months are going into the auditability and the trust of of all of those things.
08:44And the survey doesn't break that down, right?
08:46But it's not bureaucracy for its own sake, or at least I hope it's not.
08:49I hope it's it's bureaucracy for something productive and like getting to that reliability bar.
08:55Which brings us to that last reli reliability gap uh seeing versus recovering.
09:00And this is one of the ones that was in the title, right?
09:03So we asked what limits your team's productivity.
09:06Number one is tracking state and number two is debugging.
09:09The models aren't in the top two uh at all.
09:13Um 35.7% were saying uh state uh tracking state across service is their top locker and then 30.9% says that it's isolating and debug debugging issues.
09:2422.2 2% or uh of that survey are losing progress and redoing work because of crashes and restarts.
09:30So that's one in five losing work.
09:32And then last year in a different survey um 27% called their state management fragile.
09:38This year it's the number one blocker.
09:40Uh different surveys, different questions.
09:43Um so it's not a trend line, but the story is consistent.
09:46State got more important as agents got more real.
09:50And one of the wildest responses that we got was when when an agent breaks, where do you go for help?
09:55And the number one answer to that being YouTube is kind of wild to me.
09:59I don't really code with YouTube.
10:01And so this is very different from me.
10:03Uh, and the way that I build things.
10:06Um, but that's what debugging looks like when your system can't tell you what happened is you end up going to YouTube and trying to find someone that can.
10:14[gasps]
10:14Observability right now just tells you your agent failed.
10:17Most teams have that, right?
10:18traces, logs, LLM observability tools.
10:22But reliability means that failure doesn't cost you anything.
10:28Uh only 13% of the people that we talked to were very confident that they can observe and debug AI workflows at scale.
10:35And then 22% of the people that we talked to lose progress because of crashes.
10:39And so the gap between seeing uh and recovering is a person reading a trace at 2 a.m. in the morning and then fixing their state by hand.
10:47And that's not realistic, right?
10:48Like that's not a realistic thing to expect, uh, is someone fixing things at 2 a.m. in the morning.
10:53So, I want to show a quick little demo, right, of what this looks like.
10:56And I'm going to move 25,000 $2,500.
11:00This is a synthetic customer, but it's a real temporal workflow.
11:03It's a real LLM running on this laptop.
11:04I have Quen 36B uh 9B running on this laptop right now.
11:09Uh, and I'll show you a demo of what we're about to go through, but basically, we're running a payout workflow.
11:14So, this is going to be a nine-stage workflow.
11:16uh which is going to be much shorter than I think it would be in like in production.
11:21Uh money is going to move.
11:22Uh the money is going to look kind of weird.
11:25Uh and so an agent is going to jump in and is going to do a fraud investigation.
11:28The agent is going to just take a look at the transaction and decide do we need to escalate this to a human being or is this good to just wave it through.
11:36Uh and then we're going to have a human in the loop that actually makes the decision and decides what to uh whether or not to make the final call of this transaction getting approved or not.
11:45We're going to validate the request, reserve the funds, check in with the FX quote, and those funds will be reserved.
11:50So the real state will exist in another system, and then I'm going to go ahead and kill uh sorry, and we're going to have that agent do the real work, do those tool calls, uh and then I'm going to kill the process.
12:01Um so I'm going to just tell the worker to die.
12:03I'm going to stop the worker.
12:05Uh and so our process will die.
12:06Uh and that could be for any reason, right?
12:08Like it could be a timeout, it could be a deploy error, we could run out of memory.
12:12I'm going to just intentionally kill it to simulate a worker crash and we'll see what we lose.
12:16Um, what we would lose traditionally is that the funds would be reserved with no payouts.
12:22Uh, and a brief would get produced that never actually makes its way to the approver.
12:26So, we're going to have to respend our LLM tokens traditionally to regenerate that AI uh, draft or summary for the check.
12:33Um, in that tickle in like a traditional stack, all of that is going to live in process memory.
12:38And when that worker crashes, it's all gone.
12:41And so the reserve funds are still reserved.
12:43It's just not in our system.
12:44It's in the bank system.
12:46So traditionally, we'd have to write recovery code.
12:48We'd have to build state tables.
12:49We'd have to build retry logic.
12:51We'd have to create reconciliation jobs.
12:53And that's all code that's unrelated to the core business logic that I'm building to just do a payment transaction.
12:58And that's something that 30% of our respondents complained about is that they're building all of this code unrelated to B business logic.
13:06Or you could use a platform that remembers you.
13:09And uh that's where durable execution comes in.
13:11So durable execution is a temporal concept that code essentially should run to completion even when the process doesn't.
13:17We know that crashes happen.
13:19But with temporal state survives, progress survives.
13:22Uh and every step is recorded in an event history that looks like this.
13:27And so we've also recorded the AI in this state.
13:30So there's a timeline that'll we'll see in a second live.
13:32That's a run from the payout demo that we're going to run in a second.
13:35uh each of those steps uh each of those AI steps choosing the investigation the tool calls that the agentic loop is going to make uh for the lookup of the customer and then drafting the brief each of those is its own individual activity with a recorded result and the yellow bar is going to be our our essentially
13:52activity waiting for a human approval.
13:54Um the workflow code is deciding what's next and it's deterministic.
13:59Anything non-deterministic or sideffecting like the LLM is going to be run in an activity.
14:03So a tool call or a bank API call is going to be an activity and then the person when they approve or reject the transaction is going to be an event too.
14:11It's a signal is what we call them in temporals which is like recorded in history uh like everything else is recorded in the temporal history even though the worker is not running that signal is still going to get captured
14:20uh and get processed.
14:22So when the worker dies, another worker is able to resume from the last previous success.
14:27Uh yeah, and the history lives in the temporal service.
14:30Uh and we're not running our LLM tool calls multiple times.
14:33So we're not wasting tokens uh on multiple tool calls.
14:36We're going to retain the agents work uh and not redo it.
14:40Uh if the call was mid-flight while the worker died, we would retry that activity, but everything before that is uh is kept.
14:47Um and that matters.
14:48Eight and 10 people say that cost limits how they use their agent.
14:51So being able to hold on to the agents memory uh is really helpful.
14:55Rerunning an agent after every cache is a lot of money that you're burning right there.
14:59Uh so let's go into the quick demo.
15:01And yeah, so this is my uh payment transfer.
15:08So uh I'm going to go ahead and set it to $2,500.
15:10I'm going to say it's a new recipient.
15:12I'm going to say it's an unusual amount for this customer.
15:15And just to make sure that uh our AI flags it as something that needs an investigation, we're going to go ahead and set the customer record to say that there's an unresolved account alert,
15:23I'm going to go ahead and start this job, which is going to trigger this new workflow.
15:26And you can see down here in the timeline, all of those nine steps that we talked about are happening.
15:30Um so we're going to reserve our funds, validate.
15:33Uh the AI is doing an agentic loop and deciding, okay, we're going to look at the customer profile, we're going to look at the payouts, and then we're going to draft a breach, uh a brief for a human being to review.
15:42So, I've got an approve or reject button that I can click right here.
15:46But before I click them, uh like I said, I am going to intentionally kill my workers.
15:50I'm just going to hit stop.
15:52And you can see that there are no workers running at this point.
15:54So, I'm going to go ahead and approve my transaction.
15:58And we can see the approval gets logged as a signal.
16:01Now, traditionally, that would be something that just gets lost.
16:04Um we'll get a timeout in a second, but that's not really a big deal uh because we're going to have a retry policy that'll handle this automatically.
16:11So, as soon as I return on my worker, it's just going to pick up that signal and resume the behavior and continue on from that last successful event.
16:18So, we'll start a worker.
16:19This will take a second.
16:24Of course, it takes a little longer when I'm demoing it live.
16:27Usually, it's instantaneous.
16:29Um, let me just go ahead and give it a refresh.
16:34You know what?
16:35I have a video for just this scenario, so we can go ahead and just skip straight forward in the video and see what it's like.
16:40Uh, if the video plays.
16:48Yeah.
16:48Let me see if I can skip to the middle of this.
16:54Oh, it's in the other tab.
16:56What am I doing?
16:57[sighs]
17:02So, I'm going to approve while the worker is dead.
17:04Uh, and then I'm going to go ahead and resume the worker right below.
17:07Uh, and it should go ahead and just uh pick things up and like resume uh resume.
17:12So, the agent is going to investigate, write the brief, uh, and then I give the approval and then, you know, I can go ahead and crash the worker again while we're waiting for the bank to approve the transaction or mark that it was completed.
17:23Again, the signal logs and then whenever I turn the worker back on, it's going to pick it up and rerun again.
17:28So, so this is what happened according to the event history.
17:32And let me full screen that again for y'all.
17:37There we go.
17:38Um, so reading from top to bottom, each of our AI activities ran once, they attempted once, they worked once, and they didn't run again.
17:46We didn't rerun that workflow.
17:47We didn't respend those tokens.
17:49We just ran it once, and so we got that onetime cost.
17:51Uh, our approval signal came through while there were no s while there were no workers running.
17:55Uh, and then our bank submission also, you know, came through while no workers were running.
18:00And both of those things happened on new workers.
18:02We stopped the workers each time.
18:04Uh and then we got new workers that just picked things up.
18:06So zero workers.
18:07Uh the payout waited.
18:08Uh the approval landed and we didn't have to rerun anything from the beginning.
18:12So what are the full list uh of what those engineering leaders are saying uh slow them down.
18:19Um our demo just handled seven of the top use cases right there that they gave us for problems.
18:25Um so state debugging, cost, retries, approval, longunning work, and crash recovery.
18:30Um and we can take a look at the code for each of them.
18:32So state management in temporal is the number one blocker or sorry was the number one blocker in that survey in a workflow state is just fields.
18:40It's plain variables.
18:41There's no database that I built.
18:42There's no cache.
18:43After a crash the replay just rebuilt them exactly.
18:47Uh our LLM calls uh would cost us normally for multiple runs.
18:52In this run the agent we maintained the state so we only ran it once.
18:56The tool run was held was sustained.
18:58So we didn't need to spend any new tokens.
19:00Retries themselves were a policy, not a loop.
19:03We declared the retry policy uh in our uh configuration once and then it applied to every single call in that transaction.
19:11There's no loop anywhere in that code.
19:13Um the uh this is probably the most important slide for the room.
19:19So the agent itself gave us advice.
19:21The workflow itself owned the money and the state and the AI had a really bounded uh attempt to to jump in.
19:29And if the model had failed, the payout would have continued without the brief.
19:32A model outage wouldn't have degraded anything.
19:34Um, we had our human approval.
19:36Uh, and we could have set that timer for as long as we wanted.
19:39Uh, and it would have been the same code.
19:40Um, we could have waited for a year and resumed that worker and it would have been fine.
19:45And then I didn't write any crash recovery code.
19:47That was all built into temporal.
19:50Um, so debugging uh, in most stacks observability and recovery are two separate records that drift apart and then a human brings them together.
19:58Here we were able to have the history that we debugged in the UI be the same history that our worker replays which closed gap 4. So we had seven blockers and we solved them with one workflow.
20:09And this isn't just a demo.
20:11So there are people using this stuff in production for real right now.
20:14OpenAI's codeex runs on temporal.
20:16Uh the coding agent that you use a lot of the day is running on temporal.
20:20Uh Replet runs their replet agents on temporal.
20:22Their engineering team says it's a bad user experience when the agent gets super far into something and then hits a catastrophic error.
20:28And that's just what we ha watched happen or watch not happen.
20:32Um, and I'm going to skip through this because I know I'm running out of time.
20:37Uh, so from the AI engineer side, you write the prompt, you run it, and the if the output's bad, you throw it away, and then temporal retries it for you.
20:44Um, bad model output is just an activity failure.
20:46So same similar retry policy uh as well.
20:50Um so back to the four gaps, one record uh closed them all.
20:53Um and just to skip through what those four gaps were uh again
20:57[laughter]
20:58uh and resummarize that uh that yeah reliability and observability uh were just one record.
21:03And so every number of this talk that I I um mentioned is in that temporal IO report state of development and I'll leave that up screen if anyone wants to take a photo and come check it out.
21:12Uh and there's a bunch of us that'll be at the temporal booth running this demo live if anyone wants to come see it or say hi.
21:18So, um, yeah, that's that's my talk.
21:21Let's hope
21:24[applause]