Maze AI-SAST: The AI Security Engineer for Your Code

SAST tools promise to find your vulnerabilities and then bury you in false positives. This happens because they run on fixed rules and flag anything that matches a risky pattern, and most of it isn’t real, so your team burns hours triaging the pile to find the few that matter. Worse, the novel vulnerabilities in your business logic never make the pile at all.

The reason for this is simple. A scanner matches your code against known patterns, so it can’t tell a real risk from safe code that happens to look risky. And it only knows the issues someone already wrote a rule for, so anything new is invisible to it, no matter how dangerous.

AI was supposed to fix this, and plenty of teams have tried, some pointing models straight at their code. The promise is real. So far it just hasn’t landed. The results haven’t been accurate enough to trust, and running models across a whole codebase gets expensive fast. AI SAST has stayed a good idea that’s hard to rely on in practice.

There’s a lot of hype about AI-driven attacks right now, and some of it’s real, some of it’s overblown. What’s clear is that frontier models are getting good at finding and exploiting real vulnerabilities in code. M-Trends 2026 lists the time to exploit as negative seven days, which means flaws are being used before they’re even disclosed.

For a security team, that changes the job from patching known issues on your own schedule to catching the unknown ones before an attacker does. Reasoning like that is what defense has been missing, and a rule-based scanner was never built for it.

That’s why we built Maze Code. Its AI-SAST reads your code the way an expert security engineer would, catches the vulnerabilities a scanner can’t, and clears the false positives that bury your team. It delivers on AI’s original promise of expert judgment at machine speed, doing the work of your best people, on everything, all the time.

Together with Maze Cloud, this is the first security platform to investigate every vulnerability in your code and cloud, giving you one clear picture of true risk across your whole environment.

The rest of this blog covers how our AI-SAST finds what scanners miss, separates real risk from noise, and delivers fixes your team can use.

Investigate everything

We’ve spent two years building the infrastructure for our agents to gather information, and focusing on making reliable agents in Maze Cloud. Our agents are trained on millions of real investigations and evaluated against verified truth every day.

Maze Code builds on the same foundation, and it’s why you can trust them.

Deeper, more accurate investigations.

You can trust every verdict. Most tools stop at reachability. Maze agents treat it as the first signal, then weigh your configuration and surrounding controls to prove what’s exploitable. Multiple layers of validation catch errors before they compound, bringing hallucinations down to nearly zero.

Expert agents, affordable at scale.

Investigate every vulnerability, not just criticals and highs. Maze trains its agents to investigate like expert security engineers, then to do it efficiently. They learn when an expensive model is worth it and when a more cost-efficient one will do.

Unified code and cloud context.

One picture of risk. When run together, Maze Code and Maze Cloud draw on one model of the environment, so a finding in one informs the other. If a vulnerable function sits in code, Maze agents use cloud context to judge the real risk it carries, not just its severity on paper. You get one unified ticket with the fix.

Maze uses AI agents with full context, which is why it delivers some of the most meaningful findings and fixes I’ve seen.
James Berthoty, Founder & Analyst at Latio

How it works

Maze’s AI-SAST looks at your code from two angles. Both are built to catch the subtle flaws that rules miss, the kind attackers now look for with AI. Finding them means reasoning about your code the way an experienced engineer would.

The first is a full review, with agents looking at your entire codebase at once. Think of it like a manual code review from your best security engineer. They’d learn how your code works, then look for where mistakes slipped in and ways an attacker could exploit them. Our agents do the same. They read your entire codebase, its services, functions, data flow, and cloud, following how one part connects to another. That’s how they see how the whole system fits together and weigh every finding against the rest of your code.

That’s how the agents catch the hard-to-spot flaws, and at times they go deeper than you’d expect from a pentest. A piece of one service can look perfectly safe until you see how another one is configured. Nothing in that code looks wrong on its own, so a scanner has no rule to flag it. It only reads as a flaw once you know what the app is supposed to do. The bigger your codebase, the better this works, since every file is more context to reason over, not more noise.

This SAST finding is exactly the kind of finding that we were hoping to get from a pentest. So very much kudos to you. This is awesome.
Nathan Cooke, Engineering Manager, Product Security at Alloy

The second way reacts to a single code change as it happens, like a new pull request. It checks what changed before it merges, working with the scanner you already run or ours. Instead of handing your team another pile of alerts, the agents investigate every finding and use the context of your environment to separate the real risk from noise. They clear out the false positives, then re-rank what’s left.

A finding the scanner called medium can turn out to be critical once the agents see where it runs and what it touches, and a scary-looking high can drop down the list. It’s the triage your team has been doing by hand, now done for you.

Between the two, Maze surfaces the flaws hiding in your code and filters the obvious ones down to real risk.

The investigation

Before surfacing any alerts to your team, Maze agents confirm that each flaw can be exploited in your environment, using context from your code, cloud, and runtime.

Once we know it’s exploitable, the next question is how urgent the problem is. Maze agents then assess the impact and the likelihood of the attack happening when determining urgency. Impact is how large the blast radius is if an attacker exploits it. Likelihood is how realistic that exploitation is, given how and where the code runs. This is how Maze agents surface vulnerabilities that reflect real danger, not theoretical severity.

The agents’ work doesn’t end after surfacing an issue. They also help you fix it, running remediation analysis tailored to what the investigation found and delivering the fix wherever your engineers work.

One fix often resolves multiple vulnerabilities. When several trace back to the same root cause, Maze agents close them all with a single change instead of opening a ticket for each. That means fewer tickets, less busywork, and real risk cleared faster.

Vulnerabilities we’ve found

Maze Code has already found flaws in open-source projects and surfaced vulnerabilities like MFA bypass and cross-tenant data access in customers’ environments.

Here are two live bugs our full-codebase review turned up.

Account takeover

In one environment, we found an account takeover bug. What makes this one unusual is where the damage lands. Most account takeovers are about seizing the account itself. Here the app’s convenience feature, automatically claiming a new user’s past guest orders and gift cards, becomes the payoff. The moment the victim verifies, their entire purchase history and any spendable gift cards silently rebind to the attacker. The attacker walks away with the victim’s order history and their money, and the victim never sees it coming.

This is a unique flaw, and no rule could be written for it. To find it, the agents traced how attacker-controlled data moved through the code down to the root cause. They followed the newly registered user into the functions that merge guest orders and gift cards onto an account. The root cause identified was that the confirmation step never checks that the person clicking the link owns the email. It just hands them everything tagged with it anyway. It trusts one emailed click as proof of ownership.

Likelihood was high. Any anonymous attacker could hit an internet-facing endpoint with no skill required. Impact was critical. A successful takeover hands over a real account with the victim’s order history and spendable gift cards.

Authentication bypass

Maze Code also found an authentication bypass in Langfuse, the popular open-source LLM platform. Langfuse can be set so everyone at a company has to sign in one official way, through the company’s single sign-on. But during a scan, Maze agents found that the password-reset flow let someone in without ever going through a single sign-on.

The code was written correctly, each line did what it should. But it made the bug invisible to scanners. Something the code is missing, a check that guards two of the three login paths but was never added to the third, caused this bug. To catch it, the agents reasoned about what the setting was meant to guarantee, then compared all three login paths and found the email one never checked the enforced-domain list.

They also found dead code. The check that looked like it covered that path didn’t because it depended on a cloud-only setting (the bug was self-hosted). Reading across several files and holding the intent of the control in mind, the way a human engineer would, helped Maze find it.

Likelihood is moderate. Impact is high. The attacker would have to be someone with a recently cut-off account, like an ex-employee. The attacker gets the victim’s full account and everything it can reach. The org’s traces, prompts, datasets, API keys, and member list, and if the account belongs to an admin, control of the workspace itself.

Find what’s hiding in your code

Maze has already found vulnerabilities in open-source projects that other tools scanned and missed. Early customers say it surfaces things their other tools and pentests never caught. The same kind of flaws might be sitting in your code. See what Maze turns up. Book a demo.