Demo

Fix CWEs in Your Code Using FlowAgents with Open Weight Models

Learn how to wire Cisco’s Antares, and two other locally hosted models, into Itential FlowAI and build a private, end-to-end agentic pipeline that finds and fixes code vulnerabilities in network automation repos.

Demo Notes

(So you can skip ahead, if you want.)

0:00 Introduction: Agentic Security Automation with Local AI
1:21 The Three-Agent Architecture Explained
3:43 Dev Environment Setup: MacBook, Ollama & Itential Gateway
7:11 Why Private, Air-Gapped AI Matters
8:08 Itential Model Registry: Registering Local Models with RBAC
9:09 Building the CWE Workflow
11:29 CWE Find & Fix Agent
13:06 Human-in-the-Loop Approval in Work Center
14:41 Reviewing Agent Session Logs
15:52 Second Demo: CWE502 Deserialization of Untrusted Data
18:42 Wrap-Up & Next Steps

Three Agents, Three Models, One Governed Workflow

Cisco’s Foundation AI team just released Antares, a family of open weight small language models purpose-built for vulnerability localization: finding exactly where Common Weakness Enumerations (CWEs) live inside a codebase. This demo registers Antares into Itential FlowAI alongside two other locally hosted models to show what an end-to-end, private agentic security workflow looks like in practice.

Three FlowAgents work together in sequence. The finder runs on Cisco Antares, scanning the Git repository and pinpointing the vulnerable file. The fixer runs on Qwen3 Coder, generating the patch. The reporter runs on Gemma 4, producing the audit trail and firing notifications, with human approval in between. Itential’s model registry supports any model. Local, open-source, or commercial. The same workflow structure runs against whichever models a team brings or already has approved.

That flexibility matters most for highly regulated industries such as healthcare, government, financial services, and utilities. These teams are automating their networks with code and cannot send that code to cloud AI providers. A local agentic pipeline that scans for weaknesses, generates fixes, and routes them through approval changes what is operationally feasible for those teams.

What You’ll See

Three Specialized Agents, Each Backed by a Purpose-Built Model

Cisco Antares 1B locates the vulnerable file and pinpoints the exact code pattern associated with the target CWE. One tool call. Under 19 seconds.
Qwen3 Coder 30B takes the finding and generates the fix: a corrected code block with a clear explanation, produced in under 12 seconds.
Gemma 4 writes the summary report, capturing the vulnerability, the fix, the approver, the timestamp, and the link to the patched Git repo.

Itential Model Registry in Action

All three models are registered in the Itential model registry and connected to the local Ollama instance running in Docker on the same machine.
RBAC access groups are applied at the model level before any agent runs, so only authorized users can invoke each model.
The orchestration layer mixes deterministic steps with probabilistic agents that reason toward a goal. The process runs the same way every time. The agents adapt to what they find.

Human-in-the-Loop Approval, Built Into the Workflow

After the finder agent locates the vulnerability and the fixer agent writes the patch, an approval request surfaces automatically in the Itential Work Center.
The reviewer sees the vulnerability, the proposed code change, and the explanation before approving.
Once approved, the reporter agent fires and the pull request lands in the Git repository.

Two CWEs, Two Live Demo Runs

CWE78 (OS Command Injection): found in the pinghost function due to unsafe popen usage, fixed by switching to subprocess with proper command execution handling.
CWE502 (Deserialization of Untrusted Data): identified and patched in a second live run, with the full reasoning trace and session logs visible in the platform.

Why This Matters

Private AI Is Not a Compromise, It’s a Requirement for Some

Highly regulated industries such as healthcare, government, financial services, and utilities are clamoring for AI-driven automation and cannot use cloud providers. This demo shows what a fully isolated agentic pipeline looks like in practice. Three models running locally in Ollama over a private Docker network. No token costs. No data leaving the environment.

Check Your Code for Weaknesses, Autonomously

The teams that scripted their way into network automation with Python are not scanning that code for CWEs. This workflow changes what is operationally feasible: provide a Git repository and a CWE number, and three agents find the problem, write the fix, and route it through human approval.

The Builder Skill Built the Workflow

Three agents passing context between them, with deterministic steps in between – assembled using the Itential Builder Skill in Claude Code across two days. The session logs, token counts, and approval records are all visible in the platform. Nothing about the orchestration layer had to be built by hand.

–+

John Capobianco • 00:03

Hi everyone, my name is John Capobianco and I’m the head of AI and DevRel here at Itential. Now, I’m going to be taking you on a journey today and showing you how I’m using our model registry in our platform to bring my own model, models, and how I’m using on this MacBook that I’m recording on right now are my local Itential Gateway and my local instance of Olama where I have multiple models available. Now, a few days ago now, maybe weeks since this gets recorded, Cisco released Antares 1 billion parameters. And I think it should have made more noise, and I think a lot more people should be paying attention to this, that a vendor like Cisco has released a fine-tuned small language model. Specifically for common weaknesses, enumerations, CWEs, not CVEs, not vulnerabilities on like a router or a switch, weaknesses in code. So, most of us, or some of us, or a lot of us, or maybe one or two of us, have moved into network automation with Python. And we’re writing Python.

John Capobianco • 01:21

Even if we’re comfortable doing that, do we know that there’s not common weaknesses in that code? Probably not. Well, now, through an API call, and in my case, through Flow AI agents and through a deterministic workflow that I’m going to peel apart for everyone, I can provide a Git repository ID and a CWE number and description, provide that to my workflow, and scan the repository to identify the weaknesses in the code. Part one. Now that only gets us halfway, and that’s where the model will stop. I thought, what if I added a coding? Language model, a model that’s really good at coding, to take the findings from the Antares model and fix the code, write the fix.

John Capobianco • 02:17

Ideally, send a Git repository pull request and patch it right in through a human-in-the-loop approval. Finally, and before I move on, that agent is not using Antares. That agent is using Quen3 Coder, 30 billion parameter, about 18 gigabytes in size, but it will run on my Mac through OLAMA at a decent enough performance. That’s all I need. No token costs, no tokenomics to worry about, no privacy concerns. I will show you a diagram of all this. Lastly, because the Quinn is a coder-specific agent, so I’m using a 3rd agent to do the write-up, the summary, the email, the Slack, the communications, all of that stuff.

John Capobianco • 03:11

Now, I hope that wasn’t too much. I’ve got three agents, each with a custom-specific purpose, backed by a custom-specific model. They can do tool calling. So, there’s some tools that have been developed through the builder skill. And I’ll talk about what the builder skill is for itential in cloud code. And I want to mention that I didn’t make, I’ll show you what I made, and I’m going to be very clear of what my Claude Code builder session made and what I made. All right.

John Capobianco • 03:43

Now, before we get started. Let me share the screen and we’re going to take a look at the Antares information. All right. So I made a post about this, and I really would recommend that you take a look at my post here on LinkedIn because I cover the 1st half of this. And here’s my proof that it scanned a repository with a specific CWE exposed and it found it. That was part one. The articles I suggest you look at are the Cisco blog under their artificial intelligence category, introducing Antares, highly efficient open-way AI models for vulnerability localization.

John Capobianco • 04:28

And all the great stuff you need to know about it is in here. We can see that there is a 1 billion and a 3 billion and a 350 million parameter model. And you can talk about locating files related to a CWE category in a snapshot, supporting CI CD triage. Lots of amazing opportunities here. I suggest you watch this. And the next one is a more personal blog from the lead developer and Cisco’s chief AI scientist. He’s a vice president at Cisco.

John Capobianco • 05:07

So take a look at these two articles. That should bring you up to speed. Now, in terms of my setup, and I do want to add maybe one more thing here. Another little small box in here. That should say MCP. All right, so if you just bear with me. All right, so this is my MacBook.

John Capobianco • 05:31

This is what’s on my MacBook as a developer for Itential solutions. I have my OLAMA instance, and I have the Antares model, the Quinn3Coder model, and the Gemma 4 model. I have my Docker desktop on my Mac, where my Itential Gateway lives, as well as MCP servers if they require Docker runtime environment, and those are stitched together. The MCP and the Gateway are stitched together, as is the gateway and the OLAMA. Now, you need to make sure that you punch a hole or put them on the same Docker network, but they are connected. The other thing that I have connected is the IAG CTL command line. So I recommend that this, all of this environment I’m developing in VS Code with Cloud code in a terminal.

John Capobianco • 06:30

But before I launch Cloud Code, I make sure that I’ve logged into my admin level for IAG CTL. All right. The next thing is. I have included the itential builder skills in Claude Code. So, Claude Code has access to a command line interface into the gateway and platforms. And it has access to all of the builder skill/slash commands and skill files and markdown information on how to interface with the gateway. Okay, now everything exposed in this gateway.

John Capobianco • 07:11

Is also connected to our platform, which is actually in the cloud. In my case, a private cloud. So, if I draw a big square around all of this, right, there is no external communication at all. If you want to do this, if you’re in an industry that says healthcare, pharmaceutical, manufacturing, government, military, there are insurance, finance, on and on and on, there’s industries that are clamoring for artificial intelligence solutions, but cannot use the cloud providers. Everything here is completely isolated in our private environment. And the flow AI agents, these flow AI agents in the platform, are calling the models down here through this chain and this secure path. All right, so let’s get into the Itential platform.

John Capobianco • 08:08

Okay, so the 1st place I want to go is to show you the model registry. So in the model registry, I’ve registered Antares, Gemifor, and Quencoder. All right, and you can see that one agent is using each of them. And we can edit these and see that they are connected to my Capo cluster. And then I’ve enabled not all the models, just the models I want to expose. And I’ve added RBAC access groups to this. So not everybody can use these models.

John Capobianco • 08:39

All right. The next thing I want to show you is the studio. And by the way, in the gateway manager, you can see that there’s my gateway. And by the way, the gateway is right here, gateway 5 in the Itential Dev Stack on my machine. Now, if we hop into the studio, you can see that I filtered down on CWE. I want to be very clear. This simple workflow was all my builder skill and clawed code needed for me to do.

John Capobianco • 09:09

So it instructed me. It said, John, you want to orchestrate agents together, three agents, and they’re going to pass things between them. What I’d like you to do is make a new workflow and add the run agent. Okay. The new variable with just some dummy information and a merge data. It asked me to make that. So for the 1st place I want to go is to show you the model registry.

John Capobianco • 09:38

So in the model registry, I’ve registered Antares, Gemifor, and Quincoder. All right, and you can see that one agent is using each of them. And we can edit these and see that they are connected to my Capo cluster. And that I’ve enabled not all the models, just the models I want to expose. And I’ve added RBAC access groups to this. So not everybody can use these models. All right.

John Capobianco • 10:06

The next thing I want to show you is the studio. And by the way, in the gateway manager, you can see that there’s my gateway. And by the way, the gateway is right here, gateway 5 in the Itential Dev Stack on my machine. Now, if we hop into the studio, you can see that I filtered down on CWE. I want to be very clear. This simple workflow was all my builder skill and clawed code needed for me to do. So it instructed me.

John Capobianco • 10:35

It said, John, you want to orchestrate agents together, three agents, and they’re going to pass things between them. What I’d like you to do is make a new workflow and add the run agent, okay? The new variable with just some dummy information and a merge data. It asked me to make that. Okay, so again, just a recap: this workflow was made with my hands at the guidance of the builder skill so that it could make this workflow. Now, don’t be overwhelmed, but this is a mix of determinism and agents, which are probabilistic. So if we zoom in here, the very 1st thing that’s going to run is the CWE finder agent.

John Capobianco • 11:29

Somewhere along the path, we have the fixer agent, which is going to prompt us for human in the loop. And then all the way at the end, we have our reporter agent, right? Three different models. Speaking of the models, before we get started to prove it’s all local here. We’re going to do OLAMA serve and OLAMA list, and you can see that we have the Gemma for the reporter, Quen3 for the coder, and Antares quantized 1 billion to find the CWE. So let’s run it. We’re going to hit run, and we’re going to take CWE78 an operating system command injection, CWE 78 OS command injection find and fix run.

John Capobianco • 12:32

We’re now in the operations manager. We can see that the finder agent is looking through the repository that we provided it and trying to find CWE78. Right? We can even zoom in a little bit more here to watch this go. Now, the rest of this is so the agent’s done. And now we are doing deterministic steps, item potent steps that would do the same thing a million times if you asked it to. The next is the fixer agent.

John Capobianco • 13:06

So we’re running the fixer agent right now, which is generating the code to fix the problem found. Now we should get an approve request. So we’re going to hop into the work center and check out what was found and what the proposed fix is. So the vulnerability is in the pinghost function, which used this popen. And so it switched it to subprocess. Maintaining the same behavior while properly handling the command execution without shell interpretation. Approve.

John Capobianco • 13:47

Hop back over here. By the way, let’s watch the next model run. We’re going to see that the workflow has moved on. There we go, right? We can actually see that this model here agent. Run agent is running in my Olama on my Mac through the gateway, which is also on my Mac. We hit the 200.

John Capobianco • 14:20

Look, it’s done in the background as soon as we get the 200. Now I have all the logs and everything here. Yes, perfect. You can see some previous runs that I’ve done. But I like to go into the studio, excuse me, the agent sessions, and we’re going to find the finder. Right? And we can just take a step here.

John Capobianco • 14:41

It was triggered by a job. One tool was called 18, let’s call it 19 seconds, 246 tokens. We have the reasoning. We have the tool call. We can expand the tool call and we can see that it’s looking right using the tool from that agent. And it did find the vulnerability and exactly where we are vulnerable. Right?

John Capobianco • 15:07

Then we’d have the fixer. Now, the fixer doesn’t call any tools. And it takes very minimal tokens, 290, and it only takes 12 seconds for Quen3 Coder to come up with the fix and the explanation, which then we send over to our reporter, which could call tools like email or Slack or WebEx or Teams or whatever. But we have the vulnerability, the fix, the approval, and the approver and timestamp, as well as a link to the get repo where this was fixed. So we can follow the link here and find the fixed right there. And we can see, right? Perfect.

John Capobianco • 15:52

Amazing, right? So let’s do it one more time to prove that it wasn’t a one-off. All right. All right, just to prove that that wasn’t a one-off, let’s do an even more complicated one, a more challenging CWE. So this one is going to be CWE 502, the deserialization of untrusted data find and fix. All right, we’re going to run that. And right away, it’s going to kick off the 1st agent passing the build parameters.

John Capobianco • 16:37

And in here, we have the run agent. And I can show you that it’s going to hit a 200. There was the 200. And now it’s going to move along to the next step in the workflow. That could have been, there’s our 200. All right, so now the deterministic steps are all going to run. Again, I didn’t build any of this.

John Capobianco • 16:59

My builder skill in Claude Code did it. And here’s our next agent running. And we can see it churning away here in Olama locally on my Mac, privately, for free, securely. There’s the 200. Now it’s going to do some things and wait for an approval. So approve the fix. I’m going to go to our human in the loop work center and take a look.

John Capobianco • 17:26

Yeah, it did find some things here. And we’re going to approve that. And pop back in here where we’re going to get a little pause while GEMA4 runs locally here. And actually, I can show you in another spot if I’m quick enough. In the agent sessions, we can see that the GEMA4 agent is running. All right, so there’s a couple places to watch this, but here it’s churning away. And I bet you as soon as we get the 200, we should just in a few milliseconds later.

John Capobianco • 18:06

There’s the 200, there’s the pop-up answer. So we have the vulnerability, the fix, the approval, what was shipped. The deserialization and how it fixed it. All right, so two CWEs found in seconds for free, privately, locally. We went through the architecture. Again, many of our customers are in the business of network automation, and I’m trying to help those customers make those even more secure and better. Right?

John Capobianco • 18:42

So now we have an agent that can be run locally and for free to scan their Git repos or internal repos and look for specific CWEs. This has only taken me very, very little time, as you know. Yesterday I had the Antares finding problems. Today I had Quinn3 Coder fixing problems and Gemma 4 reporting about everything else that happened. Thanks again. Reach out for demos. Reach out for questions.

John Capobianco • 19:13

More than happy to connect with you. Thanks again. Stay safe out there.

Keep Learning