Video summary
The Flow Creator Agent, introduced in GitLab 19.3 as a foundational agent, simplifies the creation of custom automation flows by allowing users to describe desired workflows in plain English rather than learning complex configuration schemas. Previously, setting up automated processes required understanding the flow registry schema, but this new agent bridges that gap by generating complete, runnable flow definitions directly from natural language prompts. The demonstration begins with a practical scenario involving Tanuki Bank's fraud detection microservice, where an open merge request contains a conflict that needs resolution. Instead of manually navigating technical settings, the presenter uses the agent to design a triage flow that automatically detects conflicts, adds necessary labels, and notifies the author with suggested next steps, effectively handling the initial identification phase without requiring any code changes.
The agent's capabilities extend beyond simple detection by actively researching available tools within the GitLab environment to ensure the proposed workflow is feasible. During the initial design phase, the Flow Creator Agent identifies that a dedicated label tool is missing from the current set and creatively utilizes an existing quick action in merge request comments to achieve the same result. Once the first version of the flow is created and enabled with a specific trigger for merge conflict events, it runs alongside other automations like Duo Code Review on the same merge request. This highlights how multiple agents can collaborate on a single project, with the Flow Creator Agent successfully checking conflicts, applying labels, and tagging authors to streamline the review process before any manual intervention is required.
Recognizing that identification alone does not fully resolve the issue, the presenter iterates on the workflow by asking the agent to evolve from a triage tool into an active conflict resolver. The agent responds by suggesting significant configuration changes, such as incorporating Git and file tools to perform actual code modifications, splitting the process into distinct agentic steps for fixing conflicts and posting summaries, and adding testing capabilities. This updated version instructs the agent to check out the source branch, run a git merge against the target, resolve the conflict automatically, execute pytest tests, and push the resulting commits back to the original branch. The result is a fully automated solution that not only identifies the problem but also fixes it, runs necessary tests, and reports success, leaving the merge request ready to be merged without any remaining conflicts.
Ultimately, the Flow Creator Agent empowers teams to build robust automation by starting small with simple natural language instructions and progressively enhancing capabilities based on real-world needs. The iterative approach allows users to see what is missing in their current setup and continue refining the workflow until it perfectly aligns with how their team operates. By combining ease of use with powerful agentic reasoning, this tool transforms complex multi-step tasks into seamless automations that adapt over time. As part of the GitLab 19.3 release, the Flow Creator Agent represents a significant step forward in making advanced automation accessible to everyone, enabling developers to focus on solving problems rather than configuring intricate schemas.
Read the full video transcript
Hi, hi. It's Fatima. Today, I'm excited
to show you Flow Creator Agent, one of
our newest foundational agents in GitLab
19.3.
On GitLab, custom flows can already turn
manual multi-step work into automation.
[music]
To write a flow though, you had to
understand the flow registry schema
first. [music] Flow Creator Agent lets
me skip that part. I can describe the
automation I want in plain English and
it gives me a complete runnable flow
definition that I can register into the
AI catalog. So, let's try this on one of
my favorite problems, a merge conflict.
This is Tanuki Bank's fraud detection
microservice. It evaluates transactions
in real time and returns a risk score,
risk level, and recommendation. Now,
there's an open merge request here to
update the calculate route and you
guessed it, it has a merge conflict.
I know exactly how I want us to handle
this, but I really don't want to learn a
whole configuration schema before I can
set up a flow. So, today I'm going to
deal with this using the Flow Creator
Agent. I'm going to ask for a simple
merge conflict triage flow. When a
conflict is detected, I want it to check
that the conflict is still there, add a
needs resolution label, and let the
author know in a useful comment with
next steps. For now, no code changes,
just a flow that does triage. Now, Flow
Creator Agent checks the current flow
registry docs before it designs the flow
and starts to do some research. So,
let's see what it finds. It found the
merge request trigger with the merge
conflict action and it noticed that
there isn't a dedicated label tool in
this tool set. So, it uses the {slash}
label quick action in the merge request
comment instead. It also gives me a
quick checklist to review before I
register it. Now, I'm happy with this
first version, so I'll go ahead and
create a new flow. I'll head to AI and
then flows. I'll call this Tanuki Bank
merge conflict and add a description.
I'll set it to public and copy the
configuration from the sidebar where
Flow Creator Agent made it for us into
the flow editor. Once the definition is
saved, I can enable the flow and will
need to pick an event trigger. There are
a lot of events that I could use here
from mention to assignment, but for this
one I want a merge request event and
specifically the merge conflict action.
That means I don't have to be watching
the merge request and manually kick this
agent off when the conflict appears.
Now, I'll enable the flow and there's
the service account. This is the
composite identity for the flow. So,
when this agent operates, this is the
identity it uses when it's working in
the project. Now, let's go back to the
merge request and see what happened. We
can see two sessions running here. One
is the catalog agent, that's our flow,
and the other is duo code review, which
was triggered because the merge request
became ready. This is a great example of
how you can have multiple automations
working on the same merge request
because teams will usually have more
than one thing they want to happen when
their code is ready for review. And
here's the comment from our flow. It's
checking the conflict, adding the label,
suggesting next steps, and tagging the
author. Now, this is useful, but it's
also pretty simple. It tells me what to
do, but I still have to do the manual
work. So, naturally I'm thinking, what
if the flow could also resolve the
conflict for me? Let's go back to the
flow and open up Flow Creator Agent
again. This time I want to turn merge
conflict triage into merge conflict fix
there. We can keep the merge conflict
trigger, summarize what's wrong, and
then use git merge to resolve it, run
the test, and push the fix to the source
branch, ending with a summary for the
author to review. This is the part that
I really like about Flow Creator Agent.
I'm not trying to design the perfect
automation in one shot, but I can start
with the process that I understand and
then continue to iterate on the
capabilities as I know what my team
needs. So, as the Flow Creator agent is
researching, it gives us some important
configuration changes. Because this
version of the flow will work with files
and push a commit, it now needs Git and
file tools to do the actual work. It
also suggested to split this into two
agentic steps. One component that fixes
the conflict and a second one that posts
a summary back to the merge request. In
this version, it'll check out the source
branch, run Git merge against the
target, resolve the conflict, run the
Pytest test, and then commit and push
those results to the original source
branch. I'll copy over this updated
configuration, save it into the flow,
and head back to the merge request.
And this time, the flow has actually
resolved the conflict and pushed commits
onto the source branch. I can review the
changes, check the results, and make
sure that the merge was done
successfully. And when I flip back, the
merge request is now ready to merge. No
more conflicts. We started with a merge
conflict and a simple flow that
identified the conflict. Then we
iterated on it so that it could make the
change, run the [music] test, push the
fix, and report back. With Flow Creator
agent, you can start small with natural
language, see what's missing, and keep
building until the automation fits
[music] the way that your team works.
Flow Creator agent will be available
with the 19.3 release. Oh, this just
gave me an idea for a flow that I need
for my team. So, I'm going to go work on
that, [music] and I'll see you next
time.
Bye. Thanks for watching.