Cybersecurity

The GitLab Duo Agent Platform Vulnerability, Explained Plainly

A critical GitLab Duo Agent Platform vulnerability let a logged-in user escape a sandbox and run commands. The real lesson is older than AI agents.

Editorial Team / /9 min read
Server room rack with status lights and a terminal screen showing a gateway log

A configuration box turned into a command line. That is, in plain terms, what happened inside the GitLab Duo Agent Platform vulnerability disclosed in early October 2026: a logged-in user with access to GitLab’s AI agent tooling could trick the system into running arbitrary commands on the AI Gateway, the server that handles AI requests. GitLab’s hosted offerings were already protected, so most customers never had to do anything. But the flaw itself is worth a few calm minutes, because it is not really a story about artificial intelligence. It is a much older story wearing a new badge.

What actually broke, in terms a non-engineer can follow

The affected piece is the GitLab AI Gateway, the backend service that connects GitLab to its AI models, and which some organizations run themselves (a self-hosted AI Gateway). Inside that gateway sits the Duo Agent Platform, a feature that lets teams build custom flows: small automated sequences where an AI agent reads a prompt template, fills in some blanks supplied by the user, and acts on the result, such as opening a merge request, running a check, or posting a comment.

To stop a user’s input from accidentally becoming a command the system executes, that kind of feature normally runs inside a sandbox, a restricted environment meant to let configuration data in while keeping it from reaching anything that can actually run code. The sandbox is the wall between a setting and an instruction. In GitLab’s case, that wall had a gap. A user with valid Duo Agent Platform access could craft a specially designed flow configuration that escaped the sandbox, according to GitLab’s own security advisory published on docs.gitlab.com. Once escaped, the attacker could execute arbitrary commands on the AI Gateway itself, the server doing the AI processing, not just the chat window in front of the user.

Why this is textbook, not exotic

Here is the part that matters more than any version number. The mechanism behind this bug has a name, and it predates AI agents: server-side template injection, often shortened to SSTI. A template engine is software that takes a block of text with placeholders, similar to a form letter with blanks for a name and address, and fills those placeholders in with real data before showing or using the result. Web frameworks have used template engines for years to build pages and messages. The recurring failure mode of template engines is the same one GitLab just reproduced: if the engine does not strictly separate the data a user supplies from the code the engine is able to execute, a cleverly written piece of input stops being a harmless value and starts being an instruction the system obeys.

Internet security trackers document CVE and CVSS ratings precisely because this class of bug is well understood and consistently dangerous. A CVE is simply the public reference number assigned to a specific, confirmed vulnerability, and CVSS is the 0-to-10 severity scale used to describe how bad it could be if exploited. This particular flaw was logged as CVE-2026-90970, with a CVSS score of 9.9, close to the top of the scale, reflecting that a successful exploit hands an attacker command execution on a backend server rather than, say, a cosmetic glitch. The cause, per the CVE record GitLab published, was classified under CWE-1336, the standard category for improper handling of template-engine input, the exact family SSTI belongs to.

None of that requires GitLab’s AI Gateway or the Duo Agent Platform to be exotic or poorly built in general. It requires one boundary, between what a user configures and what the system executes, to be drawn with less precision than it needed. That boundary problem is as old as template engines themselves. Dressing a feature in agent language does not retire the old rule: isolate what executes from what a user is allowed to configure, or the isolation was never real.

Who was actually at risk, and who was not

It is worth being precise here, because headlines about AI vulnerabilities tend to blur into a vague sense of danger that does not match the facts.

First, this was never a pre-authentication flaw. An attacker needed a valid, logged-in GitLab account with access to the Duo Agent Platform before any of this applied. That rules out the scenario people instinctively picture, an anonymous stranger on the internet reaching in from nowhere. It does not rule out risk inside an organization: a compromised employee account, a disgruntled contractor, or an attacker who already obtained low-level credentials through phishing could use this flaw to escalate from a basic logged-in session to running commands on the AI backend.

Second, the exposure was narrow by hosting model. GitLab.com and GitLab Dedicated, GitLab’s own hosted and managed offerings, were already running a patched version of the AI Gateway and needed no customer action. The people who had to act were operators running a self-hosted AI Gateway on their own infrastructure. Self-managed GitLab instances that use a GitLab-hosted AI Gateway were protected and needed no action. GitLab shipped fixes in AI Gateway versions 19.2.4, 19.3.2, and 19.4.1, published around October 2, 2026, and operators of a self-hosted AI Gateway needed to apply one of those updates manually.

Third, and this matters for scope: GitLab Duo’s mainstream features, code suggestions and the chat assistant most developers actually use day to day, were not the vulnerable component. The flaw lived specifically in the prompt-template sandbox for custom Duo Agent Platform flows, a more advanced, automation-oriented feature that not every team has even configured. If a team only uses Duo for autocomplete and chat, this specific hole in the wall was not in a room they were standing in.

A separate, unrelated GitLab flaw had already made headlines a few weeks earlier: a path-traversal bug tracked as CVE-2026-85706, patched in early September 2026, that let an unauthenticated user read arbitrary files, and which security researchers reported was already seeing exploitation attempts within a day of the patch shipping. It is a different bug with a different root cause, reading files rather than escaping a sandbox to run commands, and the two should not be folded into one story just because both involve GitLab in the same general stretch of 2026. The Duo Agent Platform sandbox escape covered in this piece carries no reports, as of mid-October 2026, of real-world exploitation.

The durable point: agent framing does not grant immunity

The reason this case is worth remembering past its patch cycle is not the CVE number. It is what it demonstrates about any product that now calls itself an AI agent, a custom flow, or an autonomous workflow. Those names describe what the feature does for the user. They say nothing about whether the team that built it drew the execution boundary correctly underneath.

An AI agent that reads a configuration and acts on it is, structurally, the same risk shape as a web application that reads a template and renders it: input comes in from somewhere a user controls, and somewhere downstream that input touches something that can execute. If a team building an agent platform, at GitLab or anywhere else, treats the AI framing as a reason the old application-security discipline does not apply, the result is precisely this kind of bug: a long-known vulnerability class reappearing with a new vocabulary.

For a reader managing risk rather than writing the code, the practical takeaway is not to avoid AI agent features outright. It is to ask the same question of any new automation tool before trusting it with elevated access inside an organization: does this feature clearly separate what a user is allowed to configure from what the system is allowed to execute, and has that separation been tested, not just claimed? Reading more about how zero trust architecture treats every request as unverified by default is a useful companion idea here, because the same instinct, never assume a boundary holds just because it is labeled a boundary, applies just as well to a sandbox around an AI agent as it does to a network segment.

Teams evaluating AI-driven developer tools more broadly also benefit from a structured way to reason about where the new risk actually sits, rather than treating artificial intelligence as a single undifferentiated danger. A primer on how OWASP, MITRE, and NIST frameworks each cover a different slice of AI security is a reasonable next stop for anyone responsible for approving these tools internally.

FAQ

What is the GitLab Duo Agent Platform vulnerability, in one sentence?

The GitLab Duo Agent Platform vulnerability, tracked as CVE-2026-90970, let an authenticated user with access to GitLab’s Duo Agent Platform escape a sandbox meant to isolate custom flow configurations and execute arbitrary commands on GitLab’s AI Gateway, the backend server that handles AI requests. Only self-hosted AI Gateways running an unpatched version were actually exposed.

Does this affect GitLab.com or regular GitLab Duo chat and code suggestions?

GitLab.com and GitLab Dedicated were already running a patched AI Gateway when the issue was disclosed, so no customer action was needed there. The flaw also sat specifically in the custom-flow template sandbox of the Duo Agent Platform, not in the mainstream Duo code suggestions or chat assistant most developers use.

Did an attacker need to log in to exploit this GitLab flaw?

Exploiting this GitLab Duo Agent Platform flaw required a valid, authenticated account with Duo Agent Platform access, not an anonymous outside attacker. That makes it a privilege-escalation and insider-risk concern more than a wide-open front door, though a compromised employee or contractor account could still have used it to reach command execution on the AI Gateway.

Is this the same bug as the actively exploited GitLab path-traversal flaw patched weeks earlier?

The Duo Agent Platform sandbox escape is not the same bug as the actively exploited GitLab path-traversal flaw patched a few weeks earlier, in September 2026. CVE-2026-85706 is a separate, unauthenticated path-traversal vulnerability that lets an attacker read arbitrary files and has reportedly seen real-world exploitation attempts since shortly after its patch. CVE-2026-90970, the sandbox escape covered here, has a different root cause and carries no reports of active exploitation as of mid-October 2026.

What should a team running a self-hosted AI Gateway actually do about this?

Teams running a self-hosted AI Gateway should update to version 19.2.4, 19.3.2, or 19.4.1, whichever matches their current release line, since GitLab shipped the fix across those three versions in early October 2026. Anyone unsure which line they run should check their current AI Gateway version against GitLab’s advisory before assuming they are already covered.

#gitlab#gitlab-duo#ai-security#vulnerability#ssti#sandbox-escape