The new Step Functions pattern: agents that suggest, code that decides

This week AWS published a new Step Functions pattern that introduces AI agents into the airline rebooking process, but with a key particularity: the agent only suggests; the deterministic logic of the code decides what is finally booked. This hybrid approach marks a before and after in how companies integrate generative AI into critical business flows.

AWS's proposal is not coincidental. Over the past few months, we have seen how autonomous agents have been gaining ground in enterprise environments, but also how determinism failures have caused notorious incidents. AWS's solution involves separating responsibilities: the agent explores options, proposes alternatives, and prioritizes them; the code validates, applies business rules, and executes the final transaction.

Impact for SysAdmins and DevOps teams

For operations teams, this pattern represents both a relief and a new challenge. Relief because it reduces the risk of an agent hallucinating and booking a non-existent or unfeasible flight. Challenge because it forces the design of more complex Step Functions flows, with deterministic checkpoints and complete traceability.

From an infrastructure perspective, this implies:

• Greater use of Step Functions as the central orchestrator, with wait states for the agent's response.
• Need for enhanced observability: every agent suggestion must be logged and auditable.
• Integration with legacy booking systems through deterministic APIs, not through prompts.
• Cost management: agents consume tokens, and in a massive rebooking flow that can scale rapidly.

If you work with virtualization or hybrid infrastructure, we recommend reviewing our Proxmox technical guide for lab environments where you can test these flows before taking them to production.

The impact on business: trust and compliance

For airlines, the combination of agent + deterministic code is a way to maintain innovation without sacrificing regulatory compliance. Regulators require that decisions affecting customers be explainable and reproducible. An agent alone cannot guarantee that; an agent that suggests and code that decides can.

This pattern also resonates with what we have been analyzing in the field of enterprise AI. For example, in trust in agentic RAG we already pointed out that evidence and verifiability are pillars for adopting AI in critical processes. Here AWS goes one step further: not only evidence, but execution controlled by code.

Furthermore, security is not an add-on: it is structural. By keeping the final decision in code, the attack surface for prompt injection is reduced and a compromised agent is prevented from executing unauthorized actions. It is a lesson that also applies to other domains, such as permissions in the assembly context in enterprise RAG.

Conclusion: the future is hybrid

AWS's pattern for airline rebooking is not an isolated case. It is a signal of where agent architecture in the enterprise is heading: AI to suggest, code to decide. Teams that know how to design this separation of responsibilities will have a clear competitive advantage. Those that leave everything in the hands of the agent will, sooner or later, face an incident that could have been avoided with a simple deterministic validation.

If you are exploring how to integrate agents into your flows, start by isolating the creative part from the transactional part. Step Functions is a good starting point, but so are other orchestration tools. The important thing is that the code has the final say.

Source: The New Stack. ForgeNEX analysis.