Introduction to the Opal updates

Name: Google's Agent Upgrade
Uploaded: 2026-02-27T22:19:38.356134+00:00
Channel: Sam Witteveen
Description: to the Opal updates Opal began as a drag-and-drop agent builder and is now evolving to illustrate where agent design is heading.

Sam Witteveen

Feb 27, 2026

•

5 min read

YouTube video ID: TmqI-pX9aho

Source: YouTube video by Sam Witteveen — Watch original video

PDF

Opal began as a drag-and-drop agent builder and is now evolving to illustrate where agent design is heading. The recent release is positioned as a shift from strictly planned workflows toward agents that can make more decisions themselves. Google Labs, the team behind Opal, is actively releasing new tools and updates that leverage Gemini and other generative AI models.

Google Labs' activity includes releases and updates across multiple projects such as Flow, Pomelli, Stitch, Notebook LM, and now Opal. The stated aim of these releases is to enable average users to create high-quality outputs with generative models. According to the brief, Opal is described as "what Google calls their no-code visual builder."

New agent step and the shift in agent design

The latest Opal release introduces a new agent step that transforms static, step-by-step workflows into interactive experiences. This new step lets agents proactively determine paths based on goals, rather than following a single pre-planned track. The update is framed as a visible sign that "as the models are getting better, the way that you actually build agents with frameworks and harnesses is dramatically changing as well."

The brief contrasts "agents on rails" with agents allowed to be "off the rails" more often. As models like Gemini 3 and Claude 4.5/4.6 improve, the claim is that models can make more decisions themselves about the best path to reach a particular outcome. The speaker frames this as a fundamental change in agent construction.

Comparison with other agent frameworks

Opal's new step is compared to other frameworks and approaches in the agent space. OpenClaw is noted for the ability to build mini agent workflows, while Opal is presented with an expectation of more security and safety features. Crew AI is described as having been initially "off the rails," and Langraph is characterized as heavily "on the rails."

A concise comparison drawn from the brief:

Framework	Characteristic from brief
Opal	Evolving from drag-and-drop to agent-driven, no-code visual builder
OpenClaw	Builds mini agent workflows; comparison point for Opal
Crew AI	Initially "off the rails" approach
Langraph	Deep agents; acknowledgement of more modern harnesses; more "on the rails" historically

Memory and personalization

Opal now includes memory capabilities so Opals can remember information across sessions. The brief states that this makes Opals "grow smarter and feel more personalized over time." The update of persistent memory is presented as a crucial feature in modern agent frameworks and a key enabler of personalization.

The mechanism by which Google implements this memory is not disclosed in detail in the brief, but the presence of cross-session memory is emphasized as a meaningful change. The framing presents this memory as part of the overall progression toward more autonomous and context-aware agents.

Dynamic routing and model-driven traversal

The release emphasizes dynamic routing, relying more on the model to decide how to traverse a graph of nodes. This approach is likened to aspects of Langraph but packaged in a more consumer-friendly product. The brief underscores that with stronger models, the system can let the model choose the path through nodes rather than rigidly predefining every step.

This trend is presented as part of a broader evolution: frameworks and harnesses are moving toward allowing agents more freedom because the models are increasingly capable of selecting the best path to achieve outcomes.

Interactive chat and human-in-the-loop

Opal’s update includes an interactive chat capability framed as human-in-the-loop interaction. The brief describes the consumer-facing name "interactive chat" while noting that functionally this is "your human in the loop" step. Agents can now ask follow-up questions, get more information from users, and incorporate human feedback when the agent reaches decision points.

The role of better models is highlighted again: the improved performance of models makes these interactive, multistep decision points practical. The brief quotes this as a step where the agent "goes back to the user, you get more information, you have some kind of chat with it."

Practical demonstration: building an event finder Opal

The demonstration described in the brief shows a user creating an Opal that finds events in a city over the next week using search and the web. The constructed agent included nodes for city name input, finding events, and rendering listings. Available tools during the demo included web search, weather, get webpage, and map search.

The demo workflow began from scratch (or by remixing a pre-made Opal), took a city name input, and produced a city guide with various events. The agent was then customized to ask users about event interests and family status, producing a more tailored result when prompted with interests like "art events, music, and food festivals" for a specific city such as Tokyo.

Editor, tooling, compute limits, and publishing

The Opal editor allows manual addition of nodes, user inputs, and LLM calls. Models named in the brief that can be invoked include Gemini 3, Gemini 3 Flash, Nano, Banana, Audio LM, LIA, VO, and Claude variants. The brief indicates that updating or refining agents sometimes took longer, possibly due to high usage and compute limitations.

The creation and refinement process is presented as no-code, driven by text prompts and editor interactions. Opal apps created in this way can be shared and published according to the brief.

Examples, accessibility, and corporate relevance

Pre-made Opal examples mentioned include a Google Calendar Opal and an Opal that extracts YouTube transcripts, analyzes them for educational content, and generates a quiz. Opal and Gemini calls are described as free to try in the brief. The tool is framed as relevant for individuals looking to build agents as well as for corporate settings where agent building matters.

The speaker also encourages user feedback and discussion and notes interest in the potential for open-source versions. The brief includes several quotable lines highlighting the shift in agent design and Google Labs' role in producing these tools.

Takeaways

Opal is evolving from a drag-and-drop builder into a no-code visual tool that demonstrates where agent design is headed.
The latest Opal update introduces an agent step that enables interactive, goal-driven paths rather than fixed step-by-step workflows.
Memory, dynamic routing, and human-in-the-loop interaction are core trends integrated into Opal to make agents more personalized and adaptable.
Practical demos show Opal can build event-finder agents with nodes, web tools, and model calls without writing code, though compute limits can slow updates.
Opal and Gemini calls are presented as free to try, and the tool is highlighted as relevant for both individual creators and corporate agent projects.

Frequently Asked Questions

Who is Sam Witteveen on YouTube?

Sam Witteveen is a YouTube channel that publishes videos on a range of topics. Browse more summaries from this channel below.

Does this page include the full transcript of the video?

Yes, the full transcript for this video is available on this page. Click 'Show transcript' in the sidebar to read it.

Helpful resources related to this video

If you want to practice or explore the concepts discussed in the video, these commonly used tools may help.

Ai Textbooks Recommended

Helps developers and non-technical builders understand agent concepts and model behavior, which supports better Opal design choices.

Amazon →

No-Code Books

Provides strategies and patterns for building without code, useful for users adopting Opal's visual builder approach.

Amazon →

Developer Laptop

A capable laptop improves local testing and editing when refining agents and handling compute-heavy development tasks.

Amazon →

Links may be affiliate links. We only include resources that are genuinely relevant to the topic.

Summarize another video

Full Transcript YouTube

Okay, so in this video I want to look at
the new drop from Google Labs of updates
to Opel. So remember Opel started out as
like a drag and drop agent builder where
you could sort of define different rails
how things were going. But the latest
update introduces a number of patterns
that kind of show where agents are
actually going. And it really shows as
the models are getting better, the way
that you actually build agents with
frameworks and harnesses is dramatically
changing as well. So let's have a look
at what's new. I'll compare it to some
of the things from OpenClaw that have
become really popular and then we'll
also have a play with it so you can
actually see what you can actually do
with this. So first up, just as a quick
aside, the Google Labs team is like
shipping like crazy. Google Labs is the
team in Google which basically is tasked
with coming up with new ideas and new
products especially around things that
use the Gemini models that use the
generative AI models. So obviously their
biggest hit to date is notebook LM but
you can see just looking over the past
couple of months they've shipped a whole
new update to flow and how you actually
sort of build movies and stuff like
that. They've shipped updates to things
like Pomelli for basically making use of
the nano banana models and how to get
the best results out of those. And on
top of this, they've also shipped
updates for Stitch and a whole bunch of
different things that are more and more
focused on giving sort of the average
user the ability to create highquality
outputs with the latest generative
models. So, if you're looking to build
any kind of generative AI app yourself,
you definitely should be checking out
what they're actually doing. Now, if we
take a look at the latest Opal release,
for those of you that don't remember,
Opel is basically what Google calls
their no code visual builder. Like I
said before, this started out as sort of
a drag and drop thing. It's now morphing
into an agent's done for you kind of
tool. And just recently, they also made
it so that you could actually use the
opals that you create in the Gemini app.
So this does look to be one of Google's
plays to look at how you can actually
give normal people who are not involved
with the cutting edge of agents access
to be able to make their own agents to
be able to do different things. And it
makes sense. Google is basically trying
to work out what are the key things that
people actually want to use agents for.
And if they can give people access to
make their own and see what kind of
agents become really popular, this is
definitely then something that they can
think about both when they're designing
new products, but also when they're
creating new versions of Gemini and of
the other generative models. All right,
so jumping in here, we can see that
there's a number of sort of key things
in this release. So they talk about that
they're introducing this new agent step
that turns static workflows into
interactive experiences. And for me,
this is a real clear sign that as the
models are getting better, you don't
need to keep them on a sort of single
track path as much as you did before. So
whereas in the past you basically had
workflows that were step by step that
were planned out and what I've often
referred to as being agents on rails,
the latest models with Gemini 3 and with
things like the latest 4.5 and 4.6 six
versions of Claude, the models are
actually getting much better at being
able to make the decisions themselves of
the best path to reach a particular
outcome. Now, a lot of that's got to do
with things like planning and things
like memory. And we've seen this already
in things like clawed code. We've also
seen it in anti-gravity. And we've also
seen it even in things like OpenClaw.
One of the reasons why OpenClaw became
so popular is that people can just go in
there and tell it what they want it to
do and it starts building these sort of
mini agent workflows in the back end
which can be triggered either via sort
of chron job which they often call a
heartbeat or be triggered by the user
actually asking for something to be
done. Now you can kind of look at this
as Opal actually upgrading to be able to
do this kind of thing and you can see
this clearly here in this idea of a
generate step. So it talks about this
agent step proactively determines the
path based on your goal triggering right
tools and models. Now I'm sure that this
is not going to be as wild as open claw
and there'll going to be a lot more sort
of security and safety things in there
that if you do give it access to data
you're probably not going to have some
of the issues we've seen with open claw
where people have had their data wiped
and experienced all those sorts of
things. But don't be fooled. This is a
fundamental change in the way that we're
building agents. And in the past, we've
seen this sort of play off in different
frameworks. We've seen the early
versions of Crew AI be totally off the
rails and actually be really not that
useful at that time with the levels of
models there. And then we've seen the
sort of counteractive movement of things
like Langraph which have been heavily on
the rails where you can strain exactly
what the agent can do. And I think we're
seeing even with things like deep agents
from Langraph and some of the more sort
of modern ways and harnesses that people
are using to build agents that there's a
clear acknowledgement now that the
models are getting good enough that you
can let them be off the rails a lot more
than you could before. So another key
component of this release and of this
sort of progression is the whole idea of
memory. Now unfortunately we don't know
exactly how Google is doing this.
They're not sort of declaring this but
they are telling us that your opals can
now remember information across sessions
and this makes your opals grow smarter
and feel more personalized over time. So
memory is definitely a thing that we're
seeing with the latest sort of harnesses
and different kinds of agent frameworks
as becoming extremely important. The way
that something like openclaw approaches
this is mostly through markdown files
and JSON files and that works really
well because it's basically a single
user agent system and we are definitely
seeing this sort of change between
single user agent systems versus
multi-user agent systems. Another
feature that they've added in here is
the whole sort of idea of dynamic
routing of where where you're relying on
the model more to decide how you're
going to traverse the actual graph of
nodes and stuff like that that you're
actually doing here. Now, this is more
like something from sort of langraph,
but adding it in in sort of a more
consumer-like product like this is
actually giving people the access to
make these agents where they've got a
wide variety of choices. The last thing
that they're putting in here is what
they're calling interactive chat. And
really what this is basically human in
the loop. So we know that sort of like
the best agents ones that realize when
they get to a point where they suddenly
realize that okay going this direction
is not going to work or I need to get
more feedback from the user. So here you
can see this is described as sometimes
an AI agent needs to ask follow-up
questions. And now this agent step can
actually do the human in the loop sort
of thing. So while the sort of consumer
version of this is being called
interactive chat, don't be fooled. This
is your human in the loop step of where
you go back to the user, you get more
information, you have some kind of chat
with it. And it certainly makes the
product much more reliable at the same
time as giving users more options for
this. So, I'll jump in and have a play
with this in a second. But overall, what
I think is really interesting here is
that this is a consumer-based product
that we're seeing from one of the big
companies that is starting to use some
of these key things that we've been
talking about in building agents over
the last year or so. And we're seeing
that they're able to do this because
they've now got better models that
actually work with each of these
particular steps. So, let's jump in and
have a look at actually playing with it.
Okay, so first up, you got a choice
whether you can sort of remix a pre-made
Opal or you can start from scratch. So
here I'm going to start from scratch.
I'm basically just asking it, can you
create me an Opal that uses search and
the web to find events, activities that
are on in a particular city over the
next week? So let's see how this
actually goes. All right, so we can see
that actually this built a lot quicker
than I thought it would. So okay, it's
what do we've got here? We've got our
first node which is going to be the city
name, right, that somebody inputs in.
Then we've got a set of nodes where
we're going to find city events and
activities. And if we look on the side
here, we can see the prompt for that
node is here, right? And my guess is
that this is going to have a set of
tools that we can actually use. And sure
enough, one of those is going to be
search the web, get weather, get a web
page, search maps. Quite a number of
tools that we've got in there. Next up,
we've got generate a comprehensive event
list. So again, we've got the prompt.
We've got our tools in there. And then
finally, we've got this thing of render
the event listings web page. So we've
got a bunch of information in there
about the layout, about the style design
language, about component guidelines,
etc. So let's try it out. All right. So
I can just come over here and I'm going
to type in Tokyo. All right. So I'm
actually headed up to Tokyo next week.
So, let's see how this goes at finding
what's on over the next week in Tokyo.
And we've got some nice animations going
through what this is. Now, obviously, I
could come in here and customize this if
I wanted to make my own nodes and add in
more things and stuff like that. If we
look at the console, we can see that,
okay, I put in the city name, it started
finding different things. We can see
what was sent to the model and stuff
each time. And then we can see also what
the actual steps from the agent coming
back are. So we can see that okay, it
got some structured data out by the
looks of that. It's had some thinking to
itself. It's structuring those events.
And now it's in the process of actually
rendering all this out. Okay. So let's
go back to the preview. And we can see
sure enough, okay, it's given us a city
guide. It's talked about what's on. So,
okay, this is a doll festival. Probably
not my thing, but we can see that
there's a lot of things going on like
that there. And at this point, you can
see that maybe I don't really want
things aimed at kids or farmers. So, I'm
going to ask it to give me some more
information based on the kind of
activities that I want in here. So, I
could come back and edit these steps.
So, I'm going to edit the steps. We can
see it's definitely got some interesting
things like the early cherry blossom
viewing and stuff like that. But we can
see that I've asked it now as well as
getting the city name, ask the user what
kind of events they're interested in and
if they are taking family, etc. Okay.
Now, interestingly, that update took a
lot longer than it did for the first
time. So, it seems that a lot of people
are actually starting to use this and
they do mention up here that they're
working to get increased quotas just for
the models and stuff like that. So this
is it is kind of amazing that Google is
the company with probably the most
amount of compute in the world and yet
still they're struggling to get enough
compute to run all these Gen AI kind of
things going on. Anyway, we can see now
that we've got different nodes for the
start. We've got our city name, we've
got the events interest, we've got a
family status in there, and we've got
the other things actually sort of
updating to this. So, looks like we lost
one of the nodes where it's been joined.
Anyway, what we will do is we can try it
now as an app. So, you've got the editor
here where you basically try things out.
Remember, you can manually come in and
add different things in here as well.
You can add in user inputs like that.
I'm going to use that. You could add in
a sort of LLM call or a generate and
that can be a variety of different
things. that could be calling Gemini 3
flash nano banana audio LM LIA not the
latest LIA and I'm not even sure which
version of VO that they're using in
there but you really have the ability to
make a lot of things in the editor then
if we come to the app and we now try it
and I say right I want to have Tokyo
what kind of things okay this time I've
basically put in art events music and
food festivals and then we can see again
it's going off and doing the thinking
and doing the actual steps. And if we
come back in here, we can actually see
that console again of where the steps
are. Looks like it's gone through that.
It's now generating the HTML. And now,
obviously, this example is not a
complicated agent, right? It's very just
a reasonably simple workflow. But with
the new way of doing it, you can
actually make a lot more complicated
sort of agents where you've got these
decision points where it can actually
kind of decide different directions in
the graph and go through them. All
right, so you can see this time we've
got probably a lot better kind of thing.
Okay, the Tokyo Indie Music Festival. We
can see now we've got a web page with
all of this and it's been made
specifically for us. And while this is a
simple example, you can see that from
this, nobody needed to code. Really, in
many ways, nobody even needed to
understand that whole drag and drop
system. You could just create it with
text. And I'm sure at some point you'll
just be able to talk to it and make it
happen that way. But you can then build
this sort of little Opal app that you
could then basically share it. I could
then publish it. I could then give it to
other people. So, it's definitely worth
coming in here and just checking this
out and getting a sense of like, okay,
what can I actually do with this? Now,
they've got a bunch of ones that are
already made. You can see, for example,
here's a Google calendar opal. You can
now even uh you can now even take ones
like this where okay, it's basically
taking a YouTube, extracting the
transcript, analyzing it for educational
content, and then generating a quiz and
displaying the quiz in there. So, if
you've got kids that are trying to learn
or trying to do anything, this is
definitely something you should be
checking out. And don't forget, this is
free. This is not costing you anything
to try it out. You're not having to pay
for the Gemini calls and stuff like
that. If you've got a Google sort of
Genai account, my guess is that you get
more quot and things like that. But for
trying these things out, you really want
to come in and just have a play and sort
of get a sense of what is possible and
what you could just build as little
Opals and little apps to basically share
with your friends and family. So come in
and check out what's been released with
Opal this week. Get a sense of where
these things are going cuz already we're
seeing other companies make things like
this for their own particular use case.
And if you're someone who's actually
looking to actually build agents in a
corporate setting, this is something
definitely you need to be aware of.
Anyway, as always, let me know in the
comments what you think. Have you tried
this out? What did you like about it?
Tell me what you didn't like about it.
Would you like to see something like an
open-source version of this that could
work with any models or other
connectors, etc. Anyway, and as always,
if you found the video useful, please
click like and subscribe, and I will
talk to you in the next video. Bye for
now.