Building powerful AI agents isn’t the endgame. If you’re reading this, you’ve probably built agents that can reason, take action, and even use tools on their own. Maybe they’re already doing impressive work. But if you want to trust these agents in production, a new set of challenges shows up and are ones that go beyond just making sure the agent “works” in the lab.
What happens when your agents need human approval before making a risky decision? Can your agents survive long runs, outages, or restarts without losing their place? And what does it take to support agents that aren’t just scripts on a desktop, but complex systems running across cloud platforms and distributed environments?
These are the kinds of questions that pushed us at SnapLogic to rethink how agent state is managed. The answer: Agent Continuations, a new mechanism designed to make agent workflows truly resumable, reliable, and collaborative.
Where do humans fit in?
Agent automation has huge upside, but most organizations need guardrails. People want oversight for tasks that carry risk: think transferring money, deleting accounts, or making major changes to critical systems. We call this human-in-the-loop decision-making.
You don’t want an agent blowing past a high-risk step without a human giving the green light. At the same time, you don’t want to stop the agent’s entire workflow just to wait for that approval, especially if you’re coordinating across teams or time zones.
Long-running agents and the problem of failure
The more sophisticated your agents get, the more likely they are to run for hours (or even days), making lots of decisions along the way. But long-running processes are magnets for failure, and network blips, hardware hiccups, API limits, or cloud service disruptions can kill progress if you aren’t careful.
Most frameworks today assume the agent’s main loop will just keep running until it’s done. But in real-world settings, you can’t always guarantee that. If the system goes down, does your agent need to start from scratch? Or can it pick up right where it left off?
The new world: multi-level, distributed agents
Agent architectures are evolving. Instead of one big agent, you often have orchestrators delegating work to sub-agents, each with their own tasks and toolkits. These sub-agents might run on different servers, cloud platforms, or even interact through APIs like Slack or web apps.
This complexity multiplies the risk of interruption and makes it even more important to have a reliable way to pause, persist, and resume agent execution, especially when humans need to step in or when external dependencies are involved.
Enter Agent Continuations
To solve these challenges, we took inspiration from programming language theory – specifically, the concept of continuations. In programming, a continuation captures everything you need to know to pause and later resume a computation from a particular point.
Agent Continuations do the same for AI workflows:
- At any step in an agent’s process, you can “snapshot” its full state, including the tools it was about to call, its pending actions, and even the nested state of sub-agents.
- This snapshot can be stored, moved, or even handed off to another system.
- When you’re ready—say, after a human approves a request—you can send the continuation back, and the agent picks up exactly where it paused, with nothing lost in between.
How does it work in practice?
Every agent interaction, every LLM call, every tool execution gets recorded in a structured “messages array.” This array acts like an event log, providing the full conversation and decision history up to the current moment. When a pause is needed (maybe for human approval, or because an agent hit a resource limit), a continuation object is created.
This continuation object holds:
- The messages array (the agent’s memory of what’s happened)
- Metadata about what needs to be resumed (for example, which tool call is waiting for approval)
- Flags to track which steps have been approved or processed
If agents are nested, continuations support arbitrary levels of recursion, capturing not just the main agent’s state, but any sub-agent states too.
Once the required action is taken (for example, a manager approves a sensitive tool call), the updated continuation is sent back to the agent, which reconstructs the entire workflow and keeps moving forward.
Ready to see it in action? Check out our GitHub demo.
Real-world example: HR onboarding with Agent Continuations
Let’s say you’re automating an HR onboarding workflow. The main HR agent needs to:
- Create a new user account
- Set account privileges
- Send a welcome email
But authorizing account privileges is risky, so it needs explicit human approval.
With Agent Continuations, the workflow pauses right at the authorization step, bundles the full agent state, and sends it back for review. Once approved, the workflow resumes, sends the welcome email, and completes – no lost progress, no manual restarts, and no risk of skipping human oversight.
Why this matters
Agent Continuations bring reliability and flexibility to advanced AI workflows.
- Agents can run as long as they need, with built-in resilience to failures or restarts.
- Human-in-the-loop approvals become first-class citizens, not awkward workarounds.
- Complex, distributed agent systems can pause and resume across environments – whether on your desktop, in the cloud, or across multiple teams.
Other frameworks offer state management, but most either lack seamless human approval or can’t handle deeply nested agent architectures. Our approach, born out of the SnapLogic AgentCreator research team, combines both.
Where we’re headed
We’ve prototyped Agent Continuations on top of the OpenAI Python API (find it here on GitHub) and inside SnapLogic’s own AgentCreator platform. We’re actively working on extending these ideas to broader scenarios:
- Suspending agents for reasons beyond human approval (like waiting on asynchronous events)
- Integrating with other frameworks and standards
If you’re interested in building robust, resumable AI agents, I invite you to try out Agent Continuations, or, if you want to see visual agent design in action, take a look at SnapLogic AgentCreator.
Abschließende Überlegungen
Putting agents into production isn’t just about what they can do, but how they recover, adapt, and collaborate. With Agent Continuations, we’re building a foundation for AI systems that can survive the real world – pausing for people when it matters, and always picking up right where they left off.
- Want to see the full talk? Watch on YouTube
- Code and docs: github.com/SnapLogic/agent-continuations
- Visual agent design: agentcreator.com
