AWS agents will suggest your new flights. Code decides what gets booked.

AWS published a new Step Functions pattern this week that gives AI agents a role in airline rebooking while keeping reservation changes and payments under code’s control. Amazon Bedrock AgentCore agents suggest new itineraries and draft compensation messages after a flight disruption. Deterministic steps in the workflow then validate those proposals before changing any reservation or issuing payment.

As AWS puts it: “The principle is that agents propose, and deterministic code validates.”

Also yesterday, AWS threw more weight behind its case for supporting model reasoning with code execution in a new Abnormal AI case study, arguing that agents need a compute environment where they can perform calculations, process data, and programmatically verify work before returning results.

A Step Functions pattern to keep agents away from the money

Airline rebooking is a good candidate for agentic workflows because agents can help operations teams offload the tedious process of finding route alternatives, comparing constraints, and coordinating next steps — just think of the manual clicking it takes to rebook hundreds of passengers to new itineraries after a flight cancellation.

Such is the scenario put forth by AWS in its new Step Functions pattern.

“The principle is that agents propose, and deterministic code validates.”

By orchestrating specialized Amazon Bedrock AgentCore agents with AWS Step Functions, AWS claims the pattern enables developers to get “the reasoning power of generative AI with the guardrails of deterministic validation.”

Rather than putting orchestration, fan-out, validation, routing, and retries inside an agent’s reasoning, the pattern implements this work in Step Functions, where deterministic steps wrap each agent’s non-deterministic behavior. This way, no agent can take a direct action, like writing a reservation or issuing a payment. Instead, each agent proposal is only applied after deterministic validation passes, with Step Functions maintaining an execution history for audit and review.

Compared to multi-agent collaboration, where a supervisor agent orchestrates sub-agent runs and tool calls, AWS’s pattern pushes those decisions out of the agent layer and into the Step Functions workflow. Per AWS, this separation could help developers use AI agents more safely — that is, using agent reasoning to generate proposals but restricting any action until deterministic code gives the go-ahead.

“The reasoning power of generative AI with the guardrails of deterministic validation.”

While AWS uses airline rebooking as its example, the same pattern could apply to other high-stakes financial and regulatory workflows where deterministic code should stand between agent proposals and actions.

A compute scratch pad to bring in computation when semantic reasoning isn’t enough

On the same day it published the Step Functions pattern to validate multi-agent decisions, AWS made a related case for supporting agentic reasoning with code execution in a new case study of Abnormal AI, a behavioral AI security platform.

Per AWS, Abnormal AI uses Amazon Bedrock AgentCore Code Interpreter, a capability of Amazon Bedrock AgentCore that provides a fully managed, serverless runtime for agents to execute code dynamically, to support its real-time inline email threat detection. In this study, AWS argues that Code Interpreter “is not merely a coding tool. It’s fundamental infrastructure that agents use to reason computationally.”

Specifically, it describes pairing the managed, secured sandbox with a large language model (LLM) to combine two different strengths: the reasoning and semantic coherence of an LLM with the calculation, data processing, and verification that come from executing code. For real-world operations, like converting data into structured reports or counting, that don’t map cleanly to semantic reasoning, a compute scratchpad lets agents work through tasks computationally and verify answers instead of relying on reasoning alone.

Why semantic reasoning alone isn’t enough

AWS isn’t the only one working to separate model reasoning from downstream actions.

Last month, Perplexity shipped Portable Computer, the local-first version of its Computer agent running on an Nvidia DGX Spark workstation that puts deterministic software in charge of model actions. Rather than stacking reasoning and execution in the same layer, Perplexity separates them, using probabilistic reasoning to propose what should happen next and deterministic software to decide whether or not to execute it.

As agents take on more consequential work, like tasks across accounts payable, procurement, and the monthly close, semantic reasoning alone can’t guarantee that agent proposals are safe enough to act on. But a layer of deterministic validation may at least add a verifiable check between proposal and execution.

The post AWS agents will suggest your new flights. Code decides what gets booked. appeared first on The New Stack.