AWS gives developers the best-in-class tools for building agentic AI — models, an agent framework, and compute to run it all on. As those systems grow more complex with more tools, more agents, and longer-running steps that wait on human-intervention, keeping the whole thing consistent and recoverable becomes its own design challenge. This is the layer Temporal adds.
This blog post covers why developers trust AWS’s agentic building blocks, how Temporal adds a durability layer on top of them, and what that looks like end-to-end in a real Loan Underwriting agent.
Later in this post, we’ll show you LENNY — an AI loan underwriter that survives a Worker crash mid-review without losing an applicant’s data. First, here’s why AWS is the stack developers reach for to build something like LENNY in the first place.
Why developers build agentic AI on AWS#
Amazon Bedrock gives developers managed access to a whole catalog of foundation models (Anthropic, OpenAI, Meta, Amazon’s own Nova family, Mistral, and more) through one governed API, instead of standing up separate infrastructure and vetting a separate vendor for each one. For a regulated use case like loan underwriting, that matters even more than the model selection — the data stays inside your existing AWS account boundary, governed by the IAM controls and compliance certifications (HIPAA, SOC2) your team has already been through.
Strands Agents SDK is AWS’s open-source, model-driven agent framework, not a third-party tool bolted onto the stack. It takes a lightweight approach to the agent loop, letting developers go from a new agent in just a few lines of code, to a working prototype, to something production-shaped without a lot of ceremony. It’s model-agnostic even though it ships with Bedrock as default, so choosing Strands doesn’t lock a team into one model provider. Since its release in 2025, AWS Strands has grown to 37M monthly downloads and over 12k Github stars.
AWS Lambda is the trusted default for scale-to-zero, pay-per-use compute: the thing most AWS-native teams already reach for when they want to run code without managing servers. It’s the compute layer that most cloud-native teams have already standardized on, with IAM roles, VPC configurations, and CI/CD pipelines already wired up for it.
Running agent workloads on Lambda doesn’t mean adopting new infrastructure. Its pay-per-use pricing and scale-to-zero model provide automatic scaling while charging only for the compute time consumed and eliminating traditional infrastructure overhead. Given how agent workloads behave today, with bursty and unpredictable traffic and frequent idle periods, this approach is a good fit.
For teams already living inside AWS you can keep all of your agentic stack under one boundary. Together, these are genuinely great primitives for the models, the agent loop, and the compute underneath both.
Why Temporal + AWS is better together#
With AWS, your compute already runs inside your own AWS account. Temporal’s Workers do too, wherever you run them — whether that is in AWS serverless compute, AWS containers, or anywhere else. Temporal Self-Hosted is infrastructure-agnostic by design so it lives in the AWS environment you already have rather than asking you to adopt a new one. It adds a durability layer that wraps the entire agent loop so it can survive failures, retries, and long-running human steps without handing over control of your data and leaving AWS.
If you’re on Temporal Cloud, the orchestration layer runs as a separate, managed service outside of your AWS account. Temporal safeguards your data by offering a Codec Server deployed in your AWS environment to encrypt sensitive payloads client-side before they ever leave your environment. Therefore, Temporal Cloud only ever sees data it can’t read. Temporal Cloud and your AWS environment work great together regardless and you stay in control of what data crosses that line.
Strands: a durable agent loop, with no extra effort. Temporal’s integration wraps the Strands agent loop directly, so you’re still writing a 100% Strands-compatible agent, it just comes with automatic Temporal state management built in. Every model invocation, tool call, and MCP call is automatically routed through Temporal Activities without any changes to your agent code. This means that every step your Strands agent takes is now recorded in Workflow history, can survive crashes, restarts, and infrastructure failures. If the process dies mid-conversation, the agent doesn’t start over from scratch; Temporal uses Workflow history to resume from the last step and continue execution, regardless of which model is behind the call. Strands happens to default to Bedrock, so if that’s what you’re running, that’s already covered, no separate integration required.
Lambda: Serverless Workers. Temporal’s new Serverless Workers feature invokes Lambda on demand, only when there’s actual work on a Task Queue to be done. Once the work is done, it scales back down to zero. This means you get Temporal’s durability guarantees without paying for an always-on worker fleet, which is the same value proposition that makes Lambda itself appealing in the first place.
You might be thinking of Lambda’s 15-minute execution limit here, and wondering how that squares with a Workflow that might run for days. The answer is that the limit applies to a single Activity inside one lambda invocation, not to the Workflow itself.
A Workflow’s state lives durably in Temporal, completely decoupled from any individual Lambda instance, so it can span as many invocations as it needs over any timeframe.
Each invocation only has to finish its own current step within that window. The loan underwriting demo’s human-approval step is a good example: the Workflow can wait on that signal for minutes or days without a single Lambda function running (or being billed) the whole time.
AgentCore: the same philosophy, a different piece of compute. Not every team wants to self-orchestrate their agents. Amazon Bedrock AgentCore Runtime offers a managed, serverless execution environment purpose-built for AI workflows, conceptually similar to Lambda, but with containers that can run up to 8 hours instead of a typical Lambda invocation’s much shorter window. Either way, agent reasoning isn’t bound by any fixed window, which is exactly the gap Temporal bridges, whether the ephemeral compute underneath is Lambda or AgentCore Runtime.
We’ve already explored this in practice: one consumer packaged goods company combined AgentCore’s secure runtime with Temporal’s orchestration and cut back costs by 66% while processing millions of events a month with full auditability. A first-class Temporal integration with AgentCore Runtime is on our roadmap. For now, this is the same durability philosophy applied to a different piece of compute.
Seeing it in practice: Loan Underwriting demo#
Here’s what all of this looks like in practice in a real Loan Underwriting demo built with Strands, Bedrock, and Lambda.
Video:
A loan underwriting agent has to gather applicant data, reason over risk, and often pause for a human to approve or deny a borderline case. That’s exactly the kind of long-running, multi-step, occasionally human-blocked process this post has been building toward.
- Strands orchestrates the underwriting agent’s reasoning loop: gathering applicant data, assessing risk, and deciding whether to approve, deny, or escalate
- Bedrock does the actual reasoning at each step, inherited through Strands SDK
- Lambda, via Serverless Workers, provides the compute, scaling to zero between applications, bursty traffic scenarios, and spinning up the moment a new one arrives
The interesting part is what happens when something goes wrong. Instead of losing the application’s progress and starting the review over, Temporal resumes exactly where it left off. The same applies to the human-in-the-loop step. When an application needs a person to approve or deny it, the Workflow can wait for minutes or days without losing any state, consuming any utilization, and picks back up the moment a decision comes in.
Wrapping up#
AWS gives developers best-in-class building blocks for agentic AI, including Bedrock, Strands, Lambda, and AgentCore for teams using AWS’s managed agent platform. Temporal adds a durability and reliability layer on top of all of it, so the agents built on that stack can survive failures, retries, and long-running human steps as one coordinated system.
If you’re interested in learning more about why agents fail in production and how you can use the tools we covered in this blog, register for our upcoming webinar hosted by Rahman Syed, Senior Partner Solution Architect at AWS, and me!
You can also check out the Loan Underwriting demo on GitHub, or read more about how Temporal and Bedrock AgentCore work together.
Want to go deeper on agent orchestration on AWS? Check out Module 6 of AWS Marketplace’s AI Agent Learning Series which features Temporal: Module 6 guide and the Module 6 webinar.