Over the past year, the enterprise AI community has been embroiled in a debate over how much freedom to give AI agents. Too little, and you get expensive workflow automation that barely justifies. "Representative" label. Too much, and you get the kind of data-wiping disasters that plagued early adopters of tools like OpenClave. This week, Google Labs released an update to its no-code visual agent builder, Opal, that quietly provides an answer — and a lesson that every IT leader planning an agent strategy should study carefully.
The update introduces what Google says "agent step" Which turns Opal’s previously static, drag-and-drop workflows into dynamic, interactive experiences. Instead of manually specifying which models or tools to call and in what order, builders can now set a goal and let the agent determine the best path to reach it – selecting tools, triggering models like Gemini 3 Flash or VO for video creation, and even initiating conversations with users when they need more information.
This seems like a minor product update. It is not. What Google has sent over is a working reference architecture for three capabilities that will define enterprise agents in 2026:
- adaptive routing
-
persistent memory
-
Human-in-the-Loop Orchestration
…and all of this is made possible by the rapidly improving logic capabilities of leading models like the Gemini 3 series.
‘Off the Rails’ inflection point: Why better models change everything about agent design
To understand why the Opal update matters, you need to understand the change that has been building in the agent ecosystem for months.
The first wave of enterprise agent frameworks – tools like the early versions of CrewAI and early releases of Langgraph – were defined by the tension between autonomy and control. Early models were not reliable enough to be relied upon openly for decision making. The result was that physicians started calling "Agent on Rails": Strictly restricted workflows where every decision point, every tool call and every branch path had to be pre-defined by a human developer.
This approach worked, but it was limited. Building an agent on Rails means anticipating every possible situation the system might encounter – a compounding nightmare for anything beyond simple, linear tasks. Worse, it meant agents couldn’t adapt to new situations, the very ability that makes agentic AI valuable in the first place.
The Gemini 3 series, along with recent releases like Anthropic’s Cloud Opus 4.6 and Sonnet 4.6, represent a threshold where models have become so reliable in planning, reasoning, and self-correcting that they can begin to derail. Google’s own Opal update is an acknowledgment of this change. The new agent step does not require builders to pre-define each path through the workflow. Instead, it relies on underlying models to evaluate the user’s goal, assess available tools, and dynamically determine the optimal sequence of actions.
This is the same pattern that has made cloud code’s agentic workflows and tool calling viable: models are good enough to decide the agent’s next step and often even self-correct without the human having to manually re-prompt each error. The difference compared to Cloud Code is that Google is now packing this capability into a consumer-grade, no-code product – a strong sign that the underlying technology has matured past the experimental stage.
For enterprise teams, the implication is direct: If you’re still designing agent architectures that require a pre-determined path for every contingency, you’re probably over-engineering. The new generation of models supports a design pattern where you define goals and constraints, provide tools, and let the model handle routing – a shift away from programming agents to managing them.
Memory across sessions: the feature that differentiates demos from production agents
The second major addition in the Opel update is persistent memory. Google now allows Opal to remember information across sessions – user preferences, prior interactions, accumulated context – creating agents that improve usage rather than starting from scratch each time.
Google has not disclosed the technical implementation behind Opel’s memory system. But this pattern itself is well established in the agent-building community. Tools like OpenClaw handle memory primarily through Markdown and JSON files, a simple approach that works well for single-user systems. Enterprise deployments face a difficult problem: maintaining memory without leaking sensitive context across multiple users, sessions, and security boundaries.
This single-user versus multi-user memory partitioning is one of the least discussed challenges in enterprise agent deployments. A personal coding assistant who remembers your project structure is fundamentally different from a customer-facing agent who must maintain separate memory states for thousands of concurrent users while complying with data retention policies.
The Opal update indicates that Google considers memory to be a core feature of the agent architecture, not an optional add-on. For IT decision makers evaluating agent platforms, this should inform purchasing criteria. An agent framework without an explicit memory strategy is a framework that will produce impressive demos but struggle in production, where the value of an agent increases with repeated interactions with the same users and datasets.
Human-in-the-Loop Is Not a Fallback – It’s a Design Pattern
The third pillar of the Opel update is what Google calls "interactive chat" – Ability for an agent to pause execution, ask the user follow-up questions, collect missing information, or present options before proceeding. In agent architecture terminology, this is human-in-the-loop orchestration, and its inclusion in a consumer product is telling.
The most effective agents in production today are not completely autonomous. They are systems that know when they have reached their confidence limits and can gracefully hand over control to a human. It’s this pattern that separates trusted enterprise agents from the kind of runaway autonomous systems that have generated cautionary tales throughout the industry.
In frameworks such as LangGraph, the human-in-the-loop has traditionally been implemented as an explicit node in the graph – a hard-coded checkpoint where execution pauses for human review. Opal’s approach is more fluid: the agent itself decides whether it needs human input based on the quality and completeness of the information it has. This is a more natural interaction pattern and scales better, as it does not require the builder to predict in advance where human intervention will be required.
For enterprise architects, the lesson is that the human-in-the-loop should not be treated simply as a safety net put in place after the agent has been created. This should be a first-order capability of the agent framework itself – one that the model can dynamically invoke based on its assessment of uncertainty.
Dynamic routing: letting the model decide the path
The last important feature is dynamic routing, where builders can define multiple paths through the workflow and let the agent select the appropriate path based on custom criteria. Google’s example is an executive briefing agent that takes different paths depending on whether the user is meeting with a new or existing client – searching the web for background information in one case, reviewing internal meeting notes in the other.
This is conceptually similar to the conditional branching that Langgraph and similar frameworks have supported for some time. But Opal’s implementation dramatically lowers the barrier by allowing builders to describe routing criteria in natural language rather than code. The model interprets the criteria and makes routing decisions instead of requiring the developer to write explicit conditional logic.
The enterprise implications are important. Dynamic routing driven by natural language criteria means that business analysts and domain experts – not just developers – can define complex agent behavior. This transforms agent development from a purely engineering discipline to one where domain knowledge becomes the primary constraint, a change that can dramatically accelerate adoption in non-technical business units.
What Google Is Really Building: An Agent Intelligence Layer
Stepping back from individual features, the broader pattern in the Opal update is that Google is building an intelligence layer that sits between user intent and the execution of complex, multi-step tasks. Taking a lesson from the internal agent SDK called “Breadboard”, the agent stage isn’t just another node in the workflow – it’s an orchestration layer that can recruit models, invoke tools, manage memory, dynamically route and interact with humans, all driven by the ever-improving reasoning capabilities of the underlying Gemini model.
This is the same architectural pattern that is emerging across the industry. Anthropic’s cloud code, with the ability to manage coding tasks autonomously overnight, relies on the same principles: an efficient model, access to tools, frequent context, and feedback loops that allow self-improvement. The Ralph Wiggum plugin formalized the insight that models could be pressed through their failures to reach the perfect solution – a brute-force version of self-improvement that Opal now packages into a polished consumer experience.
For enterprise teams, the key is having agent architectures converge on a common set of primitives: goal-directed planning, device access, persistent memory, dynamic routing, and human-in-the-loop orchestration. The differentiator will not be which primitives you apply, but rather how well you integrate them – and how effectively you leverage the improvement capabilities of the Frontier model to reduce the amount of manual configuration required.
Practical Playbook for Enterprise Agent Builders
Google sends a clear message by shipping these capabilities in a free, consumer-facing product: The fundamental patterns for building effective AI agents are no longer cutting-edge research. They are produced. Enterprise teams that were waiting for the technology to mature now have a reference implementation they can study, test, and learn from – at zero cost.
The practical steps are straightforward. First, evaluate whether your current agent architecture is overly constrained. If every decision point requires hard-coded logic, you are probably not taking advantage of the planning capabilities of the current frontier model. Second, prioritize memory as a core architectural component, not an afterthought. Third, instead of a fixed checkpoint in the workflow, design human-in-the-loop as a dynamic capability that the agent can implement. And fourth, explore natural language routing as a way to bring domain experts into the agent design process.
Opel itself probably won’t become the platform that enterprises will adopt. But the design patterns it embodies – adaptive, memory-rich, human-aware agents driven by marginal models – are the patterns that will define the next generation of enterprise AI. Google has shown its hand. The question for IT leaders is whether they are paying attention.
<a href