AI-Assisted Features · GitLab Feature Trail

Sep 2026GitLab and Claude Code: Fast, compliant AIThis post details the integration of Claude Code with the GitLab Duo Agent Platform, emphasizing a governed workflow for AI-generated code. It highlights how the platform provides a unified system of record, model-agnosticism, and network-restricted deployment options for government agencies. The post also addresses the workflow challenges of integrating AI-generated code into review and testing processes by providing a governed merge request gate.

Sep 2026How GitLab reduced code-per-agentic-flow ratio by 45%This post introduces the GitLab Duo Agent Platform's Flow Registry framework, which abstracts LangGraph details into Components, Routers, and a shared state structure. Components model AI primitives like agents and human-in-the-loop checkpoints, allowing declarative YAML configuration. Routers orchestrate multiple agents for complex flows, exemplified by the 'Fix pipeline' flow that branches based on an agent's decision. The framework aims to improve developer velocity, reliability, and maintainability by reducing ad-hoc Python implementations and promoting reusability.

Sep 2026Optimize your team's price-performance with hosted open weight modelsThis post introduces three new hosted open weight models (Kimi K3, GLM 5.3, and MiniMax M3) to the GitLab Duo Agent Platform, expanding model choice for optimizing cost and performance. It details the cost-performance advantages of open weight models, providing specific call-per-credit multipliers for each new model and comparing them to existing default models. The post also outlines administrative controls for model selection, deployment options (GitLab-managed, self-hosted, hybrid), and the security and risk management processes for vendor-hosted models, emphasizing a zero data retention policy with Fireworks AI. It highlights how these models can be used for different agentic tasks based on their strengths (large context, long-horizon coding, cost efficiency at scale).

Sep 2026See who spent your AI credits and set fair caps per teamThis post introduces granular controls for managing AI credit consumption within GitLab. It details features for setting per-user and per-team budgets, exporting detailed usage reports down to the billable event level (including LLM call count, token totals, and models used), and implementing budget guardrails at various organizational levels. It also explains how included promotional credits are applied before evaluation credits and how to configure these settings via the Credit caps page and usage exports. The post highlights the importance of these controls for managing AI spend, enabling showback, and forecasting future needs.

Sep 2026Co-Create: Building GitLab with our usersThis post details how users collaborated with GitLab to enhance AI-assisted features. Key contributions include adding Scala language support to GitLab Orbit for better code understanding by GitLab Duo, implementing instance-level enforcement for Secret Push Protection, enabling configurable merge train pipeline limits, adding supported-platform details to container image indexes, and improving API capabilities for user applications and SCIM tokens. Additionally, W3C Trace Context (`CI_TRACEPARENT`, `CI_TRACESTATE`) has been introduced into CI/CD jobs to improve distributed tracing across pipelines. Usability improvements include clearer API documentation for merge request approvals and better accessibility for screen reader users.

Sep 2026Bring your own model to GitLab Duo Self-Hosted with Microsoft FoundryThis post details the technical implementation of connecting GitLab Duo Self-Hosted to models hosted in Microsoft Foundry. It outlines the architecture involving a self-managed GitLab instance, an AI Gateway, and model endpoints deployed in Foundry. Key steps include deploying models in Foundry, recording endpoint URLs and API keys, and installing the AI Gateway. It emphasizes the importance of selecting models based on GitLab's supported-model matrix and Foundry's catalog, and provides guidance on naming conventions for deployments to facilitate upgrades. The post also clarifies data transmission policies, noting that inference data stays within the user's network for self-hosted configurations, while billing metadata is transmitted for online licenses.

Sep 2026GPT-6 Astra on GitLab: Faster runs, fewer tokens usedThis post announces the integration of GPT-6 Astra into the GitLab Duo Agent Platform. It details internal benchmark results showing GPT-6 Astra is 43.4% faster and uses 42.7% fewer tokens per run than GPT-5.6 Sol. It highlights improvements in tail latency (49.2% faster at the 95th percentile) and a 100% task completion rate with a 63.3% resolution rate (compared to 76.7% for Sol). The post emphasizes Astra's suitability for tasks like dependency updates and build fixes where turnaround time and token usage are critical, while Sol might be preferred for changes requiring absolute correctness. It also reiterates that the platform provides consistent governance, context layering, policy checks, and audit trails for all integrated models.

Aug 2026When code is abundantThis post discusses the economic and architectural shifts in software development driven by the abundance of AI-generated code. It highlights how the constraint moves from code production to trusting the code, emphasizing the importance of context, verification, governance, and evidence. The post details how organizations like Stripe, Amplitude, and Spotify are integrating AI agents into their workflows, leading to faster iteration cycles and exposing new bottlenecks in CI/CD, review, and validation. It introduces the concept of 'learning turning into code' where production failures become regression tests and compliance obligations become continuous validation. The post also outlines three coexisting modes of AI adoption: traditional, AI-assisted, and autonomous development, and stresses that optimizing the entire software development lifecycle (environment setup, CI, review, validation) is crucial to leverage the benefits of AI-generated code.

Aug 2026Build custom flows in minutes with the Flow Creator agentIntroduces the Flow Creator agent, a foundational agent within GitLab Duo Agent Platform, that allows users to describe desired automation flows in natural language. The agent translates these descriptions into runnable flow definitions, removing the requirement to learn the Flow Registry schema. It includes guardrails such as scoped service accounts, role-based access control for enabling flows, and pre-output checklists to catch common errors like missing project IDs, broken human-in-the-loop gates, incorrect response targets, and missing stopping instructions. The agent also reads current documentation and applies rules based on observed failure patterns.

Aug 2026From chaos to context: Building an AI dev workflowThis post details the development of agentic AI workflows, persistent memory systems for AI assistants (opencode-memory), and strategies for managing parallel AI sessions. It introduces concepts like Model Context Protocol (MCP) for token efficiency and integrates with broader SDLC knowledge graphs like Orbit. The focus is on building practical, directive-driven AI workflows that amplify engineering productivity, including the use of git worktrees for parallel MR work and the proceduralization of recurring tasks into AI directives.

Aug 2026How I built a demo generator with GitLab Duo Agent PlatformThis post details the creation of a demo generator using the GitLab Duo Agent Platform. It describes how a custom flow and custom tool were built to automate the process of generating click-through demos from screenshots and context. The agent reorders screenshots, writes narration based on a marketing messaging skill, builds an HTML demo template, and opens a merge request for review. It also automates publishing to GitLab Pages and the Demo Hub. The post highlights the benefits of agentic automation within GitLab for tasks like collateral generation.

Aug 2026Confidential AI for GitLab Self-HostedThis post details the integration of GitLab Duo Self-Hosted with Privatemode AI, enabling the use of confidential computing for AI coding agents. It explains how Privatemode's hardware-based trusted execution environments (TEEs) and remote attestation keep prompts and source code encrypted during inference, addressing the needs of regulated organizations. The integration involves running a self-hosted AI Gateway and a Privatemode proxy, which exposes an OpenAI-compatible API. The post outlines the architectural answer of confidential computing, the tradeoffs involved (operating the gateway/proxy, maturing generic models, attestation overhead), and the security properties of the solution.

Jul 2026How to govern agentic AI, MCPs, and AI code assistantsThis post introduces a governance framework for agentic AI in software development, focusing on identity, permissions, and auditability. It details controls for Model Context Protocol (MCPs), agents, model access, and tool permissions, including composite identity, tool approval guardrails, and prompt guardrails. It also discusses data privacy, self-hosted AI options, and the importance of human-in-the-loop decisions for code review, testing, and deployment. Finally, it proposes five metrics for measuring AI rollout: adoption, acceptance and quality, risk, remediation, and ROI.

Jul 2026Claude Opus 5 on GitLab: Reasoning built for the hard tasksThis post details the integration of Claude Opus 5 into the GitLab Duo Agent Platform, highlighting its improved reasoning capabilities for complex tasks like multi-file features and large refactors. It emphasizes the model's higher resolution rate (93.3%) and completion rate (100%) on benchmark tasks, leading to fewer partial patches and more merge-ready code. The post also touches on improved coordination between multiple agents, cost management with GitLab Credits usage caps, and faster execution times at the 95th percentile.

Jul 2026Modernize Java with Cursor and GitLabThis post details the integration of Cursor, an AI coding agent, with GitLab's Duo Agent Platform and Model Context Protocol (MCP) to modernize a Java application. It demonstrates how to use Cursor for focused tasks like fixing failing tests and preparing for larger migrations, while leveraging GitLab's issue hierarchy, CI/CD, and code review workflows to ensure the safety and reviewability of AI-generated changes. The post outlines three use cases: fixing a failing end-to-end test, preparing quality gates for Java 8 to 21 modernization by ensuring CI/CD tests both versions in parallel, and modernizing HTTP connection handling. It highlights the use of the GitLab MCP server to bring project context into Cursor and the importance of GitLab's Duo Agent Platform flows (Code Review, Developer Flow, impact analysis) for certifying AI-generated code.

Jul 2026Automate work item assignment with GitLab DuoIntroduces the 'Work item created' trigger for the GitLab Duo Agent Platform, enabling event-driven flows that fire automatically upon work item creation. Details a two-agent flow that uses GitLab Orbit to determine resource workload and assign new work items to the least loaded individual. Provides a step-by-step tutorial demonstrating the trigger and flow in action. Suggests potential enhancements using Model Context Protocol (MCP) for PTO and calendar integration.

Jul 2026GitLab Transcend Hackathon: What developers built on GitLab OrbitThis post details the results of the GitLab Transcend Hackathon, where developers built on GitLab Orbit. Key themes emerged: understanding code dependencies ('what breaks this change'), test relevance, migration costing, and incident root-cause analysis. Several winning projects demonstrated novel applications of GitLab Orbit's graph-based context for agents and engineers. Sankofa used Orbit for blast radius analysis of changes and vulnerabilities. Stayed Shipped tracked AI-merged changes' production survival. Carver provided migration cost quotes based on dependency graphs. Marshal automated repo-by-repo migrations. CrossCut optimized CI by running only relevant tests. OrbitWeaver performed autonomous refactoring using the dependency graph. Transcend built a reasoning engine on top of Orbit using semantic web technologies for complex queries. Universal Agent OS focused on governance for AI agents. The Contribute Track saw 61 merge requests merged into the Orbit codebase, improving language support, fixing bugs, and enhancing documentation.

Jul 2026Bring GitLab Duo Agent Platform to your terminalThis post announces the general availability of GitLab Duo CLI, which brings GitLab Duo Agentic Chat into the terminal. It highlights how this extends agentic AI beyond code editing to cover operational tasks like pipeline failures, dependency issues, and CI configuration. Key features include staying in the terminal, shared sessions across surfaces, interactive and headless modes, and admin controls for self-managed instances. It also details how the CLI works via `glab duo cli` or standalone `duo` with a PAT, and mentions custom slash commands and agent rules.

Jul 2026Forrester Consulting: GitLab Duo Agent Platform delivers 400% ROIThis post details a Forrester Consulting Total Economic Impact™ study that found organizations using GitLab Duo Agent Platform achieve a 400% ROI and $7.5 million in net present value over three years. The study quantifies benefits such as 80% faster new developer onboarding, a 75% reduction in migration timeline (from 8 months to 2), 40% of time back for security and QA engineers, and 20% more weekly developer time for feature work. It highlights how agentic coding and AI agents accelerate individual output and compound returns through infrastructure built for the full software lifecycle, enabling faster feature releases, security remediation, and migration.

Jul 2026Turn multi-step software delivery into agentic flows you can trustThis post announces the general availability of Custom Flows in GitLab Duo Agent Platform, enabling users to define and trigger multi-step AI-powered workflows from native GitLab events (mentions, assignments, pipelines, MR lifecycle, work item changes). It also introduces the ability to start Foundational Flows from GitLab Duo Agentic Chat, where requests matching specialist work (implementing changes, reviewing merge requests, fixing pipelines) trigger recommended flows that users can approve. New features include exclusion rules for code review automation and custom review instructions to shape review criteria. The post highlights the transition from single-turn chat to agentic software delivery that encodes trusted sequences into predictable automation.

Jun 2026Claude Sonnet 5 on GitLab: More reliable, more efficientThis post announces the availability of Claude Sonnet 5 on the GitLab Duo Agent Platform. It highlights the model's improved reliability (completing all benchmark tasks) and efficiency (resolving 8.8% more issues), which translates to higher-quality code and more usable output for agentic workflows. It also discusses the cost-effectiveness of using different models for various tasks and provides guidance on model selection.

Jun 2026Google Antigravity agents get full context with GitLab OrbitThis post details the integration of GitLab Orbit with Google Antigravity agents. It introduces the concept of a knowledge graph for agents to query software lifecycle data, enhancing capabilities like blast radius analysis, onboarding, and dependency mapping. The integration leverages the Model Context Protocol (MCP) and is available for GitLab Premium and Ultimate tiers, consuming GitLab Credits for queries.

Jun 2026AI Catalog updates for governance and operationsIntroduces event-driven triggers for GitLab Duo Flows, enabling automated execution based on specific GitLab events (merge request conflict, draft to ready, MR approved, work item created). Adds pipeline event filters for specific states (failure, success, cancellation). Implements admin controls to disable custom agents/flows and restrict AI catalog access to group hierarchies. Adds upstream validation for flow configurations before saving. Introduces public beta for AI model allowlisting and default setting for agentic chat. Adds a pattern-based approval tier for local agentic workflow execution.

Jun 2026GitLab: Built for the agentic engineering eraThis post announces and details several new and enhanced AI-related capabilities within GitLab, focusing on agentic engineering. Key announcements include: a next-generation SCM rebuilt for agent-scale concurrency (private beta), GitLab Orbit (public beta) as a context graph for the full SDLC, agents for security and governance for agents (private beta), GitLab Duo Agent Platform (GA) as an orchestration system, and GitLab Flex as a new buying model. The post elaborates on the challenges of agentic coding with current infrastructure, particularly the limitations of traditional Git for machine-scale concurrency and the need for context beyond code. It highlights the performance improvements of the next-gen SCM (up to 2x fewer tokens, 50x faster wall clock time, 1000x less network traffic) and the benefits of Orbit for agent response time (up to 11x faster, 4.5x more cost effective, 45x fewer hallucinations). The introduction of governance for agents emphasizes identity, policy, audit, and approval around agent actions. The GitLab Duo Agent Platform's adoption is noted with a 10x growth in weekly active users. The post also references demos from the Transcend event for each of these components.

Jun 2026Introducing GitLab OrbitThis post introduces GitLab Orbit, a new system that creates a live, queryable graph of software development lifecycle data (code, MRs, pipelines, deployments, vulnerabilities, ownership). It aims to provide context to AI agents, improving their accuracy and speed. Orbit ingests data into ClickHouse and exposes it via MCP, REST, and a Cypher-like DSL. It also includes a Data Explorer for direct engineer querying. The post highlights its use in improving coding agents and enabling new agentic capabilities like pipeline failure triage and vulnerability blast radius mapping.

Jun 2026Mythos-class Claude Fable 5 arrives on GitLab Duo Agent PlatformThis post announces the availability of Anthropic's Claude Fable 5 model on the GitLab Duo Agent Platform. Key technical contributions include: enhanced first-shot correctness for complex problems, improved accuracy on technical images and screenshots, long-horizon autonomy for multi-day agent workflows, self-correction capabilities, reliable dispatch of parallel sub-agents, and improved bug-finding recall for outage triage and code review. The model's ability to sustain instruction adherence across millions of tokens and self-correct through verification loops are significant advancements for AI agent reliability.

May 2026Agentic coding is only as good as its contextThis post details how integrating coding agents with GitLab's platform context (issues, pipelines, security policies) improves code quality, security assessments, and review cycles. It describes three scenarios: agent with repository-only context, agent with repository and issue context (using GitLab MCP server), and agent working within a merge request to address feedback. It highlights how platform context reduces rework and accelerates delivery by enabling agents to adhere to organizational standards and requirements. It also discusses the impact on security by shifting bottlenecks from vulnerability management to AI-generated fix MR review and the importance of `AGENTS.md` for custom agent instructions. The post emphasizes that efficient context delivery from the platform, rather than LLM context window size, is key to AI-assisted development workflows.

May 2026Claude Opus 4.8 on GitLab: Complex agentic work, less disruptionIntroduces Claude Opus 4.8 as a new model option within the GitLab Duo Agent Platform, enhancing agentic workflows with improved long-horizon execution, more precise reasoning, and support for mid-conversation system prompts. This allows agents to handle complex, multi-step tasks with fewer interventions.

May 2026More AI models for GitLab Duo Agent Platform Self-HostedThis post introduces expanded support for self-hosted open-source AI models on the GitLab Duo Agent Platform. It details the deployment of models like Mistral Devstral 2 123B, GLM-5.1, Kimi-K2.6, and MiniMax-M2.7 for customers facing data residency, air-gapped network, or compliance constraints. The recommended serving platform is vLLM, and deployment options include on-premises hardware or GPU-enabled virtual machines in virtual private clouds. It also outlines considerations for choosing between fully air-gapped and hybrid deployments.

May 2026Transform MRs from manual tasks to an automated workflowThis post introduces significant enhancements to GitLab's AI-assisted features, specifically focusing on extending the Developer Flow to cover the entire Merge Request (MR) lifecycle. Key new capabilities include an AI agent that can address reviewer feedback across multiple rounds, resolve merge conflicts on long-running branches, research unfamiliar codebases, split large MRs, and implement features from scratch. The agent is designed to operate with a full developer toolset and leverages project setup configurations like AGENTS.md and agent-config.yml. Additionally, a 'Resolve with Duo' button is introduced for automated merge conflict resolution directly within the MR interface, and a one-click rebase and merge feature is now available. These capabilities are part of the GitLab Duo Agent Platform.

May 2026Beyond BYOK: Why governance matters for AI agentsThis post introduces GitLab Duo CLI and its integration with the GitLab Duo Agent Platform, emphasizing the need for governance in agentic AI workflows beyond individual developer tools. It highlights the platform's capabilities for enterprise-level control, including prompt injection detection, composite identity, auditable actions, and custom instruction files for defining agent permissions. The post contrasts this with GitHub's Copilot CLI's focus on individual workstations and details how Duo CLI enables secure CI/CD pipeline automation with a mix of self-hosted and GitLab-hosted models.

May 2026Fix bugs with Codex and GitLabThis post details the integration of Codex, an AI coding agent, with GitLab's Duo Agent Platform and Model Context Protocol (MCP) to enhance the software development lifecycle. It demonstrates three use cases: fixing a Rust WebSocket bug locally using Codex and project build commands, enriching Codex's context with GitLab issue requirements via MCP for more aligned fixes, and using Codex as an external agent within the Duo Agent Platform to address review feedback in merge requests. The post highlights how agentic workflows can bridge local coding with the broader CI/CD, review, and shipping processes managed by GitLab.

May 2026GitLab Act 2This post announces a significant strategic shift at GitLab towards an 'agentic era' driven by AI. It details operational restructuring, including flattening the organization, creating smaller R&D teams, and rewiring internal processes with AI agents. Architecturally, GitLab is undertaking a generational rebuild of its infrastructure to handle machine-scale work, re-engineering Git for machine scale with API-first services, and building agent-specific APIs. An orchestration service is being reimagined to coordinate agents across the full lifecycle. Context is being invested in as a first-class, API-accessible service. Governance is being built into the core platform. The platform will operate across human-owned, agent-assisted, and agent-autonomous work modes. The business model is evolving to include consumption pricing for agent work. New operating principles are Speed with Quality, Ownership Mindset, and Customer Outcomes.

May 2026Automate deployment processes with GitLab Duo Agent PlatformThis post details the process of building a custom AI agent using the GitLab Duo Agent Platform to automate the onboarding of new microservices into an existing GitOps workflow. It covers generating a system prompt by having the AI study the application's group and subgroups, creating a managed agent project, enabling the agent in relevant projects, and using the agent to generate manifests, update pipelines, and create merge requests for a new microservice. The post highlights the benefits of capturing organizational knowledge and providing auditable, versioned changes.

May 2026Claude Code and GitLab: Three workflows that shipThis post details three workflows integrating Claude Code with GitLab for accelerated software development and shipping. The first workflow demonstrates fixing a C++ bug using Claude Code, followed by GitLab CI/CD, security scanning, and Duo Code Review. The second workflow enhances Claude Code's context by integrating the GitLab Model Context Protocol (MCP) server, allowing it to access GitLab issues, merge requests, and other SDLC data. The third workflow showcases using a Claude-powered external agent within the Duo Agent Platform to address code review feedback directly in a merge request. It also covers prerequisites and setup for these workflows, including configuring Claude Code, the GitLab MCP server, and preparing a GitLab project.

May 20268 Agentic AI patterns reshaping team collaborationThis post introduces eight capability patterns for AI agents designed to enhance team collaboration: providing status updates, routing work between humans, facilitating team communication, role-specific agents in chat, conversational context, RBAC for agents, governed environments for agent deployment, and collaborative agent building. It maps these patterns to outcomes of moving faster, working smarter, and staying in control. The post highlights the competitive landscape's focus on embedding agents in existing communication tools, the non-negotiable nature of governance, and the shift towards collaborative agent building. It positions GitLab Duo Agent Platform as a solution that leverages the existing DevSecOps lifecycle for integrated AI agent orchestration.

Apr 2026GitLab and Anthropic: Governed AI for enterprise developmentThis post announces the deepened integration of Anthropic's Claude models into the GitLab Duo Agent Platform. It highlights how this integration enhances existing agentic capabilities for code generation, review, chat, and vulnerability resolution by leveraging Claude's advanced reasoning and safety features. The post emphasizes that these AI interactions are governed by GitLab's existing SDLC controls, including merge request processes, approval rules, security scanning, and audit trails. It also details enterprise deployment flexibility by routing AI workloads through Google Cloud Vertex AI and Amazon Bedrock, and mentions GitLab's presence in the Claude Marketplace. The core contribution is the enhancement of agentic workflows with more capable AI models while maintaining robust governance and auditability.

Apr 2026Give your AI agent direct GitLab access with glab CLIThis post introduces the use of the GitLab CLI (`glab`) with the Model Context Protocol (MCP) to provide AI agents with direct, structured access to GitLab projects. It details how agents can use `glab` to fetch issues, merge requests (including unresolved discussions), check pipeline status, and programmatically resolve MR notes. It also highlights the benefits of using `glab`'s JSON output for structured data consumption by AI and the ability to leverage `glab api` for full access to GitLab's REST and GraphQL APIs, enabling agents to perform actions beyond built-in commands. Future work includes agent-aware help text and machine-readable errors.

Apr 2026GitLab + Amazon: Platform orchestration on a trusted AI foundationThis post details the integration of GitLab Duo Agent Platform with Amazon Bedrock, offering three deployment patterns: GitLab.com with GitLab-hosted AI Gateway and GitLab-operated Bedrock models; GitLab Self-Managed with GitLab-hosted AI Gateway and GitLab-operated Bedrock models; and GitLab Self-Managed with self-hosted AI Gateway and customer-operated Bedrock models. It emphasizes how this integration addresses operational fragmentation, security and sovereignty concerns, and cloud spend optimization by consolidating DevSecOps orchestration and AI model governance within existing AWS environments. The post highlights how platform teams can standardize model usage for code suggestions, security analysis, and pipeline remediation, and how enterprises can align AI usage with existing cloud agreements.

Apr 2026CI Expert and Data Analyst AI agents target development gapsIntroduces two new foundational AI agents for the Duo Agent Platform: CI Expert Agent (beta) and Data Analyst Agent (GA). CI Expert Agent inspects repositories to automatically generate valid, runnable build and test CI/CD pipeline configurations in YAML, explaining each step. Data Analyst Agent allows users to ask natural language questions about MRs, issues, projects, pipelines, and jobs, providing instant visualizations and generating GitLab Query Language queries. Both agents run within GitLab, leveraging its context.

Apr 2026Claude Opus 4.7 is now available in GitLab Duo Agent PlatformIntroduces Claude Opus 4.7 as a new model option within the GitLab Duo Agent Platform. Highlights improvements in reasoning, instruction following, and output verification, citing internal evaluations showing performance gains over previous models. Emphasizes the impact on agent workflows across CI/CD, code review, and vulnerability remediation, noting more predictable and auditable outcomes due to precise instruction adherence. Mentions the ability for agents to verify their own outputs, reducing back-and-forth and developer interruptions.

Apr 2026GitLab and Vertex AI on Google Cloud: Advancing agentic developmentThis post details the integration of GitLab Duo Agent Platform with Google Cloud's Vertex AI. It highlights how Vertex AI powers the model tier for agent calls, enabling more capable and governed agentic workflows at enterprise scale. The integration leverages Vertex AI's model breadth and managed infrastructure for advanced reasoning, tool use, and long-context understanding. It also emphasizes the BYOM option and how this integration keeps inference usage within existing Google Cloud agreements and controls, streamlining developer productivity and enterprise governance.

Apr 2026GitLab Duo CLI: Agentic AI now in the terminalIntroduces GitLab Duo CLI, a new command-line interface that extends the agentic AI capabilities of the GitLab Duo Agent Platform to the terminal. It supports both interactive (human-in-the-loop) and headless (automated workflows, CI/CD integration) modes. Highlights security features like prompt injection detection and composite identity. Details installation via GLab or as a standalone tool. Emphasizes the CLI's composability and debuggability for automation and scripting.

Mar 2026Agentic code reviews for $0.25 eachIntroduces a flat-rate pricing model of $0.25 per code review for the Code Review Flow capability within the GitLab Duo Agent Platform. This aims to make AI-assisted code reviews more accessible and predictable, enabling them to run in parallel across an entire organization and unblock review queues. The post highlights the cost savings compared to manual reviews and variable pricing models, and emphasizes the ability to define custom merge review instructions per project.

Mar 2026GitLab 18.10: Agentic AI now open to even more teams on GitLabIntroduces the ability for Free GitLab.com teams to purchase GitLab Credits for agentic AI capabilities, including Planner Agent, Developer Flow, Code Review Flow, Fix CI/CD Pipeline Flow, Agentic Chat, Code Suggestions, and custom agents/flows. This expands access to AI-powered features beyond paid subscription tiers. It also details the flat-rate pricing for Code Review Flow at 0.25 credits per review and highlights the promotional credits included with GitLab Premium and Ultimate subscriptions.

Mar 2026Extend GitLab Duo Agent Platform: Connect any tool with MCPThis post introduces support for the Model Context Protocol (MCP) within the GitLab Duo Agent Platform. It details the technical steps required to configure an integration between GitLab Duo Agent Platform (acting as an MCP client) and Jira (acting as an MCP server). This includes setting up Jira OAuth applications, configuring the `mcp.json` file in GitLab projects, and enabling external MCP tools in GitLab settings. It also provides three practical use cases demonstrating how to leverage this integration for planning assistance, issue triage and creation from code, and cross-system incident investigation. The post also outlines troubleshooting steps and security considerations for the integration.

Mar 202610 AI prompts to speed your team’s software deliveryThis post introduces 10 specific AI prompts from the GitLab Duo Agent Platform Prompt Library designed to accelerate software delivery by addressing bottlenecks beyond individual coding. It details prompts for code review (logical errors, breaking changes), security analysis (scan results, code review), documentation (release notes, updating docs), planning (breaking down epics), testing (unit tests, coverage gaps), and debugging (failing pipelines). It emphasizes applying AI across the entire software lifecycle to overcome team-level delays.

Feb 2026GitLab Duo Agent Platform with Claude accelerates developmentIntroduces the concept of external agents within the GitLab Duo Agent Platform, allowing integration with external AI models like Claude and OpenAI's Codex. Demonstrates three use cases: generating a full-stack Java web application from an issue description, performing comprehensive code reviews on generated code, and creating a CI/CD pipeline to build a container image. Highlights the ability of these agents to understand project context, adhere to standards, and autonomously handle complex tasks across the development lifecycle.

Feb 2026Secure and fast deployments to Google Agent Engine with GitLabThis post details the integration of GitLab CI/CD with Google Cloud's Agent Engine for deploying AI agents. It covers configuring Workload Identity Federation for secure, keyless authentication between GitLab and Google Cloud, setting up necessary IAM roles (`roles/aiplatform.user`, `roles/storage.objectAdmin`), and creating a `.gitlab-ci.yml` pipeline that leverages GitLab's built-in security scanning (Dependency-Scanning, SAST, Secret-Detection) and the ADK CLI for deployment. The process streamlines AI agent deployment by automating security checks and cloud permissions.

Feb 2026Agentic AI, enterprise control: Self-hosted Duo Agent Platform and BYOMIntroduces self-hosted GitLab Duo Agent Platform for online cloud licenses with usage-based billing via GitLab Credits, enabling data residency and control by allowing users to run models on their own infrastructure. Also introduces 'Bring Your Own Model' (BYOM) functionality, allowing connection of third-party or self-hosted models via the GitLab AI Gateway for granular mapping and governance.

Feb 2026Claude Opus 4.6 now available in GitLab Duo Agent PlatformThis post announces the availability of Claude Opus 4.6 within the GitLab Duo Agent Platform. It highlights the model's advanced capabilities, including its large context window (1 million tokens), highly agentic nature, deep reasoning, adaptive thinking, and multi-agent orchestration. It specifies that Opus 4.6 is available for all agents and Agentic Chat on GitLab.com, and details the credit multipliers for its usage. It also notes that Opus 4.6 is not available for GitLab Duo Classic features and will be available in supported IDEs soon.

Jan 2026Announcing general availability for GitLab Duo Agent PlatformAnnounces the general availability of the GitLab Duo Agent Platform, marking a significant step towards integrating agentic AI into the entire software development lifecycle. It introduces the concept of addressing the 'AI paradox' by automating tasks beyond code authoring. Key new capabilities include Agentic Chat for multi-step reasoning and autonomous actions, foundational agents like Planner and Security Analyst, a custom agent catalog, and integration with external agents. It also details new Flows for automating complex workflows and the MCP Client for connecting IDEs to external tools. The post also highlights flexible model selection and governance features.

Jan 2026Introducing GitLab CreditsIntroduces GitLab Credits as a new virtual currency for usage-based pricing of GitLab Duo Agent Platform capabilities, replacing seat-based pricing for agentic AI. Details how credits are pooled, consumed by various agents and flows (foundational, external, custom), and how consumption is calculated based on LLM requests. Outlines cost governance features including sizing calculators, usage visibility dashboards, usage controls, and automated notifications. Explains the upgrade path for existing Duo Pro/Enterprise customers and provides a competitive comparison to seat-based pricing.

Jan 2026AI Catalog: Discover, create, and share agents and flowsThis post introduces the AI Catalog as a central repository for discovering, creating, sharing, and managing AI agents and flows within GitLab. It details how to access the catalog, browse agents and flows, enable them in projects, and create custom agents and flows with visibility controls (Private/Public). Best practices for naming, documentation, and quality are provided. The post also explains the versioning mechanism for custom agents and flows, including version pinning behavior and how to update to the latest versions.

Jan 2026Get started with GitLab Duo Agent Platform: The complete guideThis post introduces the GitLab Duo Agent Platform, detailing its evolution from Duo Pro/Enterprise to a many-to-many team-agent collaboration model. It outlines the core components: Duo Agentic Chat, Duo CLI, Agents (foundational, custom, external), Flows (foundational and custom), AI Catalog, AI Menu, and Model Context Protocol (MCP). It also defines essential terminology and references related documentation for customization options like AGENTS.md, custom rules, agent skills, and review instructions. The post serves as a comprehensive guide to getting started with the platform.

Jan 2026Getting started with GitLab Duo Agentic ChatThis post introduces and details the GitLab Duo Agentic Chat interface, which serves as the primary interaction point for AI agents within the development workflow. It explains how Agentic Chat differs from simple chatbots by being an autonomous collaboration partner capable of taking action on behalf of the user, such as modifying code, opening merge requests, and triaging issues, all within the context of the SDLC platform. The post outlines access methods across Web UI, VS Code, JetBrains, Visual Studio, and the GitLab Duo CLI. It details model and agent selection, including foundational agents like Planner, Security Analyst, Data Analyst, and CI Expert, as well as custom agents. Common use cases are elaborated with example prompts for issue management, vulnerability analysis, code understanding, onboarding, debugging, code review, feature implementation, and refactoring. Troubleshooting tips for common issues are also provided.

Jan 2026How to customize GitLab Duo Agent PlatformThis post details customization options for the GitLab Duo Agent Platform, including user-level and project-level custom rules defined in `.gitlab/duo/chat-rules.md`, AGENTS.md files for project context at user, project, and subdirectory levels, custom review instructions defined in `.gitlab/duo/mr-review-instructions.yaml` for AI-powered code reviews, and agent skills defined via `SKILL.md` files. It also mentions MCP configuration and custom agents/flows as customization methods.

Jan 2026Introduction to GitLab Duo Agent PlatformThis post introduces the GitLab Duo Agent Platform, detailing its architecture, interaction methods (Agentic Chat, CLI, Custom Flows, Foundational Flows, External Agents), and the distinction between agents and flows. It highlights the platform's ability to automate tasks across the SDLC, provide enterprise governance, and integrate various AI models.

Jan 2026Monitor, manage, and orchestrate AI workflowsThis post introduces and details the AI management capabilities within the GitLab Duo Agent Platform. It covers the UI sections for managing Agents, Flows, and Triggers, explaining their purpose and functionality. It also describes the Sessions view for monitoring agent and flow execution, providing step-by-step logs and reasoning. The post outlines event-driven automation through triggers based on GitLab SDLC events (mentions, assignments) and introduces the concept of MCP Servers for agent integration.

Jan 2026Understanding agents: Foundational, custom, and externalThis post details the three types of agents within the GitLab Duo Agent Platform: Foundational (built by GitLab, e.g., GitLab Duo Chat, Planner, Security Analyst, Data Analyst, CI Expert), Custom (user-defined with system prompts for team-specific workflows), and External (run asynchronously on GitLab-managed compute, triggered by mentions, leveraging specialized AI providers like Anthropic Claude, OpenAI Codex, Amazon Q, and Gemini). It provides examples of prompts, use cases, and setup guidance for each type, emphasizing the role of system prompts for custom agents and the benefits of external agents for specialized tasks and compliance.

Jan 2026Understanding flows: Multi-agent workflowsThis post introduces the concept of 'flows' within the GitLab Duo Agent Platform, defining them as orchestrated collaborations between multiple agents to solve complex problems autonomously. It differentiates flows from agents, highlighting flows' suitability for autonomous, multi-step workflows. The post details two types of flows: foundational flows maintained by GitLab for common development tasks (e.g., Software Development, Code Review, SAST Vulnerability Resolution) and custom flows that users can create for specific team needs. It outlines how custom flows are created using YAML configuration, specifying components, prompts, and toolsets, and details various triggering mechanisms including mentions, assignments, reviewer assignments, and pipeline events. An example YAML for a custom feature implementation flow is provided, showcasing the structure and components involved.

Jan 2026Building trust in agentic tools: What we learned from our usersThis post details research findings on how users build trust in AI agents, identifying 'micro-inflection points' across four pillars: safeguarding actions (confirmation dialogs, rollback, secure boundaries), transparency (progress updates, action explanations, clear error handling), remembering context (preference retention, context awareness, adaptive learning), and anticipating needs (pattern recognition, intelligent agent selection, environment analysis). It provides practical implementation advice for organizations, emphasizing starting with low-risk environments, designing for continuous orchestration with human intervention, maintaining audit trails, and personalizing experiences.

Dec 2025GitLab 18.7: Advancing AI automation and developer experienceThe 18.7 release introduces Custom Flows for automating multistep workflows using YAML-defined sequences that orchestrate agents. It also adds a SAST False Positive Detection Flow that uses AI to identify potential false positives, a Custom Agent Versioning feature to pin projects to specific agent/flow versions, new settings for Foundational Agents allowing admins to turn them on/off at instance/group level, and a Data Analyst Agent for natural language exploration of GitLab data via GLQL. Core DevOps enhancements include Dynamic Input Selection in GitLab Pipelines for UI-driven triggers and CI/CD Catalog Publication Guardrails for administrators to control component publishing. Platform Security introduces Warn Mode for MR Approval Policies, allowing violations to be surfaced without blocking merges.

Nov 2025GitLab 18.6: From configuration to controlGitLab 18.6 enhances the GitLab Duo Agent Platform with the default availability of the Planner and Security Analyst agents, group-level awareness for the Planner agent, and support for the gpt-oss-120b open-source model for self-hosted deployments. Cloud-connected self-managed instances gain end-user model selection in the UI. Web IDE now supports air-gapped deployments. The modern interface is now the default for self-managed instances. Platform security is improved with custom business context labels for filtering security scan results.

Nov 2025GitLab engineer: How I improved my onboarding experience with AIThis post details an engineer's personal experience using GitLab Duo for onboarding, exploration, code review, and debugging. It highlights specific use cases for GitLab Duo Chat and Agentic Chat, including searching documentation across multiple sources, identifying edge cases and dependencies for issues, checking against GitLab best practices, reviewing merge requests before human reviewers, and debugging pipeline failures. The post also discusses how these AI-assisted workflows align with GitLab's CREDIT values and emphasizes the importance of cautious AI usage.

Nov 2025Secure AI agent deployment to GKEThis post details the secure deployment of AI agents to Google Kubernetes Engine (GKE) using GitLab CI/CD and Google Cloud integration. It outlines the setup of IAM and permissions on GitLab for Google Cloud authentication via Workload Identity Federation, configuration of Artifact Registry integration, and the creation of a CI/CD pipeline with build, test (including security scans), upload, and deploy stages. A critical aspect is the creation of a Kubernetes Service Account with specific IAM roles to access Vertex AI capabilities, enabling the AI agent to function correctly.

Oct 2025Ace your planning without the context-switchingThis post introduces GitLab Duo Planner, a new AI agent built on the GitLab Duo Agent Platform. It focuses on orchestrating product planning workflows, reducing overhead, and improving alignment and predictability. The agent leverages work items (epics, issues, tasks) and understands work breakdown structures, dependency analysis, and effort estimation. It offers six specific flows: prioritization (RICE, MoSCoW, WSJF), work breakdown, dependency analysis, planning, status reporting, and backlog management. The post demonstrates its usage through examples of checking initiative status and generating executive summaries, highlighting its availability as a custom agent in the Duo Chat side panel.

Oct 2025Modernize Java applications quickly with GitLab Duo with Amazon QThis post introduces the integration of GitLab Duo with Amazon Q to automate the modernization of Java applications. It details a workflow where a user creates an issue describing the modernization goal, triggers the transformation with a `/q transform` command, and GitLab Duo with Amazon Q analyzes the codebase, identifies deprecated features, and generates a merge request with updated source code and build configurations (e.g., pom.xml). The process preserves application functionality and includes a review step.

Oct 2025GitLab 18.5: Intelligence that moves software development forwardThis post introduces the 18.5 release of GitLab, focusing on AI-assisted features and UI modernization. Key contributions include the Security Analyst Agent for automating vulnerability triage, the GitLab Duo Planner for backlog management, and the integration of popular AI tools (Claude, OpenAI Codex, Google Gemini CLI, Amazon Q Developer, OpenCode) into the AI Catalog as native GitLab agents. The self-hosted GitLab Duo Agent Platform moves to beta, allowing AI agents and flows to run within an organization's infrastructure. Security enhancements include Static Reachability Analysis for Java (alongside Python, JavaScript, and TypeScript) to identify exploitable vulnerabilities, Secret Validity Checks for GitLab-issued security tokens to distinguish active from expired secrets, Custom Rules for Advanced SAST to define organization-specific detection logic, and Advanced SAST C and C++ language support.

Oct 2025Claude Haiku 4.5 now available in GitLab Duo Agentic ChatThis post announces the integration of Claude Haiku 4.5 into GitLab Duo Agentic Chat. It highlights Claude Haiku 4.5's speed and coding performance (73.3% on SWE-bench Verified) as a fast sub-agent for parallel tasks within the GitLab Duo Agent Platform. The post details how this enhances agentic workflows by combining speed with intelligence for accelerated development cycles and cost-effective AI assistance within the GitLab environment.

Sep 2025Greater AI choice in GitLab Duo: Claude Sonnet 4.5 arrivesThis post announces the integration of Claude Sonnet 4.5 into the GitLab Duo model selector, providing users with an additional advanced AI model for coding and agentic workflows. It highlights the model's performance on SWE-bench Verified and its strengths in cybersecurity, finance, and research. The post emphasizes how the GitLab Duo Agent Platform orchestrates this model, connecting it to internal systems and integrating it throughout the software lifecycle for faster development and more accurate outcomes within the existing GitLab workflow.

Sep 2025Agentic AI guides and resourcesThis post serves as a curated collection of resources and announcements related to agentic AI within GitLab. It defines agentic AI, links to various blog posts and guides on its application in development and platform engineering, and highlights GitLab's specific offerings: GitLab Duo with Amazon Q and the GitLab Duo Agent Platform. It details the capabilities of these offerings, including AI-powered test generation, code generation from issues, code review acceleration, and agent deployment. It also points to GitLab University courses and other AI resources. The post does not introduce a new system or a specific technical implementation detail but rather aggregates existing and upcoming capabilities and resources.

Sep 2025Model Context Protocol integrationThis post introduces the Model Context Protocol (MCP) integration into GitLab Duo Agent Platform. It details how GitLab can act as both an MCP client (connecting to external services like Jira, Slack, Grafana) and an MCP server (allowing AI tools like Claude Desktop and Cursor to access GitLab data). The post outlines setup for MCP clients, provides an example project for an incident response scenario, and lists GitLab's MCP server capabilities (Issues, Merge Requests, Pipelines, Work Item Notes, Search, Server Info).

Sep 2025GitLab 18.4: AI-native development with automation and insightThis post introduces the GitLab Duo AI Catalog for creating and sharing custom agents, Agentic Chat with enhanced session management and user model selection, and the GitLab Knowledge Graph for codebase navigation and RAG. It also details the Fix Failed Pipelines Flow for business-aware pipeline maintenance and introduces GitLab Duo Context Exclusion for granular data protection. Model selection is now generally available, and new MCP tools are added to the MCP server.

Sep 2025GitLab named a Leader in the 2025 Gartner Magic Quadrant for AI Code AssistantsThis post announces GitLab's recognition as a Leader in the 2025 Gartner Magic Quadrant for AI Code Assistants. It highlights the evolution of GitLab Duo from AI code assistance to a comprehensive AI strategy with the GitLab Duo Agent Platform. The platform enables developers to work with multiple AI agents that automate tasks across the software lifecycle, leveraging a Knowledge Graph for project context. Key features include specialized agents, human-agent collaboration via chat and customizable flows, and interoperability with external tools. The platform emphasizes security by design, with agents running within GitLab's DevSecOps environment and actions being visible and reviewable. It aims to enhance developer productivity, provide visibility for engineering leaders, and maintain control for IT organizations through governance features. The post concludes by reiterating GitLab's commitment to AI-native development and future updates to the Duo Agent Platform.

Sep 2025How GitLab Duo Agent Platform transforms DataOpsThis post details the practical application of the GitLab Duo Agent Platform for DataOps, specifically automating the generation of dbt models. It outlines a workflow involving extracting table metadata from Snowflake, using the VS Code plugin for GitLab Duo, and providing a detailed prompt to generate dbt source and workspace models, including `sources.yml`, `schema.yml` with tests and documentation, and `dbt_project.yml` updates. It also includes a generated validation query for comparing row counts between raw and workspace layers. The contribution is the demonstration of an end-to-end automated dbt model generation process using AI.

Sep 2025Vibe coding with GitLab Duo Agent Platform: 'Issue to MR' FlowThis post introduces the 'Issue to MR' agent Flow within the GitLab Duo Agent Platform. This Flow automates the process of converting a project issue into a draft merge request by analyzing the issue description, creating a development plan, and proposing code implementations. It details the prerequisites for using the Flow, the step-by-step process for initiating and tracking it, and the benefits of this automation for application updates, such as reduced development overhead and improved context for reviews. It also highlights the broader benefits of the GitLab Duo Agent Platform, including its unified data model, built-in security, interoperability, and collaborative capabilities.

Sep 2025Why enterprise independence matters more than ever in DevSecOpsThis post emphasizes the importance of enterprise independence and transparency in DevSecOps, particularly with the increasing integration of AI agents. It highlights GitLab Duo Agent Platform's role in providing visibility into agent decision-making, supporting multiple LLMs for vendor independence, and offering enhanced governance controls. Key aspects include the AI Transparency Center for clear data governance, privacy protections, and ethical AI principles, ensuring customer data is not used for training. It also details AI continuity plans for evaluating and switching models within 30 days if provider practices change. The post reiterates GitLab's deployment flexibility (on-premises, SaaS, Dedicated) and cloud neutrality, crucial for regulatory compliance and procurement leverage. Built-in security and compliance features like custom compliance frameworks, DAST, API fuzz testing, and coverage-guided fuzzing are contrasted with fragmented solutions. The commitment to open source and community engagement through the Co-Create program and open issue tracker is also mentioned. Data governance is reinforced with complete control over data processing, encryption standards, and audit capabilities, ensuring customer code is never used for AI model training. The overarching message is the choice between retaining control and vendor lock-in, transparency and uncertainty, and dedication to innovation versus ecosystem whims.

Aug 2025GitLab 18.3: Expanding AI orchestration in software engineeringGitLab 18.3 introduces a Knowledge Graph for real-time code indexing and faster code searches, an Orchestration Layer with an engine for multi-agent flows and event subscriptions, and first-class agents for every stage of development. It expands integrations with third-party AI tools via the MCP server and CLI agent support for Claude Code, Codex, Amazon Q, Google Gemini, and opencode. Agentic Chat support is extended to Visual Studio IDE. New automated development flows include Issue to MR Flow for automated code generation and Convert CI File Flow for migrating CI/CD configurations to GitLab CI format, with initial support for Jenkins migrations.

Aug 2025Custom rules in GitLab Duo Agentic Chat for greater developer efficiencyThis post introduces custom rules for GitLab Duo Agentic Chat, allowing developers to define specific guidelines for AI-generated code. It covers creating rules in `.gitlab/duo/chat-rules.md` to enforce version control (e.g., Java 8, Python 3 environments), style enforcement (e.g., C goto anti-patterns, VueJS design patterns, Ansible linter compliance), and DevSecOps automation (e.g., project bootstrapping with CI/CD security scanning and documentation standards). It provides practical examples, links to demo projects, and guidelines for rule development, emphasizing iteration and leveraging existing style guides. The post also touches on distribution and testing of custom rules and configuring IDEs for markdown language support in Duo Code Suggestions.

Aug 2025Get started with GitLab Duo Agentic Chat in the web UIThis post introduces the integration of GitLab Duo Agentic Chat directly into the GitLab UI. It details how users can toggle to 'Agentic mode' to enable the AI to interact with the GitLab API and perform actions. Specific capabilities highlighted include issue management (searching, summarizing, updating labels/milestones) and CI/CD pipeline debugging (analyzing failures, suggesting fixes, and committing them to merge requests). The post also provides guidance on crafting effective prompts for complex tasks like bug triage and offers tips for using action-oriented verbs and clear criteria for bulk operations.

Aug 2025Own your AI: Self-Hosted GitLab Duo models with AWS BedrockThis post details the implementation of GitLab Duo Self-Hosted models, specifically integrating with AWS Bedrock. It outlines the architecture involving a self-managed GitLab instance, an AI Gateway, and AWS Bedrock as the LLM backend. Key implementation steps include installing the AI Gateway (Docker or Helm), configuring GitLab to point to the AI Gateway, requesting access to AWS Bedrock models, configuring self-hosted models within GitLab Duo (specifying deployment name, platform, model family, and identifier), and assigning these models to specific GitLab Duo features (Code Suggestions, GitLab Duo Chat, etc.). Verification steps include running a health check, testing Duo features, and reviewing AI Gateway logs. The post also provides guidance on selecting the right model for each use case and mentions alternative deployment options like on-premises vLLM and Azure OpenAI Service.

Aug 2025Measuring AI ROI at scale: A practical guide to GitLab Duo AnalyticsThis post introduces a customer-driven, open-source solution for measuring GitLab Duo ROI. It details the implementation steps using GitLab CI/CD and GraphQL APIs to collect and aggregate AI usage data (code suggestions, chat events, license utilization). Key technical contributions include configuring CI/CD variables (`ENABLE_DUO_METRICS`), defining data ingestion variables (`GROUP_PATH`, `INCLUDE_SIMPLE_FIELDS`, `ARGUMENT_FIELDS`), and setting up aggregation rules in `.gitlab/Schedule.gitlab-ci.yml` for metrics like average time to merge and Duo Chat analytics. It also outlines the specific GitLab APIs used: `aiUsageData`, `selfManagedAddOnEligibleUsers`, `aiMetrics`, and the Service Ping API.

Jul 2025Fast and secure AI agent deployment to Google Cloud with GitLabThis post details the secure deployment of AI agents to Google Cloud using GitLab CI/CD components and Workload Identity Federation. It introduces a practical example of an AI agent for Canadian city recommendations, outlining the setup of IAM integration with Workload Identity Federation and Google Artifact Registry. The post provides a `.gitlab-ci.yml` configuration that leverages GitLab CI/CD components for building Docker containers, performing security scans (dependency, SAST, secret detection), uploading to Artifact Registry, and deploying to Cloud Run. It highlights security benefits such as no long-lived credentials, automated security scanning, an audit trail, and the principle of least privilege.

Jul 2025Enhance application quality with AI-powered test generationThis post introduces the capability of GitLab Duo with Amazon Q to automatically generate unit tests for Java code within merge requests. It details the user interaction via the `/q test` command in issue comments, the AI's analysis process, and the benefits of reduced test writing time, comprehensive coverage, and improved quality.

Jun 2025Speed meets governance: Model Selection comes to GitLab DuoIntroduces GitLab Duo Model Selection, a new capability allowing namespace owners to configure which AI models teams can use across different GitLab Duo features. This provides control over governance, compliance, and security standards, enabling organizations to select models from their pre-approved vendor list or use the GitLab default model. The feature is available in private beta for Duo Enterprise customers.

Jun 2025GitLab Duo Agent Platform: What’s next for intelligent DevSecOpsIntroduces the GitLab Duo Agent Platform, an evolution of Duo Workflow, enabling parallel collaboration between engineers and multiple AI agents across the SDLC. This platform supports specialized agents for tasks like research, bug fixing, code review, and incident investigation. It emphasizes interoperability with external tools and models, deep context integration within GitLab, an agent approval workflow for controlled autonomy, and community-driven customization. Beta access is available, with GA expected this winter.

Jun 2025Speed up code reviews: Let AI handle the feedback implementationIntroduces the integration of GitLab Duo with Amazon Q, enabling an AI agent to automatically implement code review feedback. This is achieved by using the `/q dev` quick action in a comment, which prompts Amazon Q to analyze reviewer comments within a merge request and modify the code accordingly. The changes are then visible in the 'Changes' tab for verification. This feature aims to automate the implementation of feedback, reducing manual effort and speeding up code review cycles.

May 2025GitLab Duo Chat gets agentic AI makeoverIntroduces GitLab Duo Agentic Chat, an evolution of GitLab Duo Chat that transforms conversational AI into an action-oriented assistant. Agentic Chat can autonomously determine information needs, execute operations across multiple sources (e.g., project structure, READMEs, issues, MRs), formulate comprehensive responses by combining insights, and create/modify files. It is built on the Duo Workflow architecture and is currently available as an experimental feature in VS Code for users with Duo Core, Duo Pro, or Duo Enterprise add-ons. The post details a four-step workflow demonstration: understanding the project, understanding the assigned task, implementing the solution by editing files, and verifying completion by analyzing MRs against issues. Known limitations include slower response times, keyword-based search, and limited support for non-GitLab projects. Future plans include general availability, improved response times, self-hosted model support, support for JetBrains and Visual Studio, integration with the GitLab web application chat, editing GitLab artifacts, and terminal command execution.

May 2025What is a large language model (LLM)?This post explains the fundamental concepts of Large Language Models (LLMs), including how they work (supervised/unsupervised learning, large data volumes, neural network architectures like transformers, predictive text generation), and their applications within a DevSecOps approach. It details how LLMs can improve documentation, aid in incident management and troubleshooting, create and improve CI/CD pipelines, and enhance security and compliance. The benefits discussed include improved productivity, efficiency, code quality, security, and accelerated development lifecycles.

May 2025Refactoring JavaScript to TypeScript with GitLab Duo WorkflowThis post details the technical process of using GitLab Duo Workflow to refactor a JavaScript file to TypeScript. It outlines the challenges of JS-to-TS migration, the specific capabilities of Duo Workflow (contextual awareness, multi-stage planning, human-in-the-loop, staged changes), and the underlying AI model (Claude 3.5 Sonnet). The analysis phase identified specific typing needs for store state, workflow objects, and GraphQL responses. The planning phase outlined steps for creating a new TypeScript file, defining interfaces, copying and annotating code, and updating imports. The execution phase involved user approval of the plan and visual progress indicators. The post highlights the shift from suggestion-only assistance to task-oriented programming and the importance of codebase-wide contextual understanding.

May 2025Unlocking AI for every GitLab Premium and Ultimate customerThis post announces the inclusion of GitLab Duo Code Suggestions and Chat in GitLab Premium and Ultimate tiers at no additional cost, starting with GitLab 18.0. It also details the availability of Duo Enterprise for Premium customers, which includes features like Root Cause Analysis and Code Review. The post highlights the benefits of these AI capabilities for accelerating development workflows and improving code quality.

May 2025Automate tedious coding tasks with GitLab Duo WorkflowThis post introduces GitLab Duo Workflow, an agentic AI solution in private beta that operates within VS Code. It demonstrates how Duo Workflow can automate complex development tasks by understanding project structure and making coordinated changes across a codebase, exemplified by implementing a new lint rule and updating multiple files. The workflow involves reading issue details, analyzing project structure, planning changes, drafting new rules, making consistent code modifications, and staging them for review. This enhances consistency, saves time, reduces context switching, and keeps a human in the loop.

Apr 2025GitLab Duo + Amazon Q: Transform ideas into code in minutesThis post introduces the integration of GitLab Duo with Amazon Q, enabling agentic AI capabilities to transform issue descriptions into working code within minutes. Users can invoke Amazon Q via a '/q dev' quick action in issue comments, which then analyzes the issue and source code to autonomously generate code, commit it to a merge request, and facilitate review and testing. This significantly reduces the time and manual effort required for application development.

Apr 2025Use GitLab Duo Workflow to improve application quality assuranceThis post demonstrates the use of GitLab Duo Workflow in VS Code to automate the generation of unit tests for a Java application and subsequently fix dependency errors in the generated test file by updating the pom.xml. It highlights the agentic workflow of analyzing a prompt, creating a plan, and executing it to modify project files.

Feb 2025GitLab Duo Self-Hosted: Enterprise AI built for data privacyIntroduces GitLab Duo Self-Hosted for Code Suggestions and Chat, enabling deployment on-premises or via AWS Bedrock and Azure OpenAI. Details supported LLMs (Mistral, Anthropic Claude 3.5 Sonnet, OpenAI GPT) and deployment options (vLLM for on-premises, AWS Bedrock, Azure AI). Highlights the AI abstraction layer for simplified integration and emphasizes data control and privacy by keeping data within the customer's environment.

Feb 2025GitLab Duo Workflow: Enterprise visibility and control for agentic AIThis post announces the private beta waitlist for GitLab Duo Workflow, an agentic AI feature built on the GitLab DevSecOps platform. It details the promise and challenges of AI agents in software development, highlighting the need for platform integration over add-on tools. The post outlines specific use cases for GitLab Duo Workflow, including automating project bootstrapping, modernizing legacy code, resolving tasks with full codebase context, generating and updating documentation, and enhancing test coverage. It emphasizes that the agents will leverage GitLab's unified data model for context and control.

Jan 2025Improve AI security in GitLab with composite identitiesIntroduces the concept of 'composite identities' for AI agents, linking them to human user identities to enhance security and auditability. Details the design of composite identities, including how they are represented, authenticated, and authorized. Explains the redesign of the authorization framework to support multiple principals (AI agent and human user) for resource access. Mentions the enhancement of job tokens to signed JWTs and contributions to open-source libraries. Highlights the initial implementation of composite identities for service accounts with GitLab Duo with Amazon Q.

Jan 2025DevSecOps + Agentic AI: Now on GitLab Self-Managed Ultimate on AWSThis post announces the availability of GitLab Duo with Amazon Q for GitLab Self-Managed Ultimate customers hosted on AWS, in Preview (Beta). It details the integration of Amazon Q for AI-powered feature development (using `/q dev`), automated code reviews (using `/q review`), and Java modernization (using `/q transform`). Setup prerequisites include upgrading to GitLab 17.8, having an Ultimate subscription, and configuring IAM roles in AWS and the GitLab AI gateway.

Dec 2024Automating with GitLab Duo, Part 3: Validating testingThis post details a validation test where engineers removed all existing tests (74% coverage) and used GitLab Duo to regenerate tests. The team achieved 84% test coverage in approximately two days by one engineer, a significant improvement over the previous four weeks of manual effort. Coverage has since increased to 89%. The post highlights that GitLab Duo enables developers with lower context to write valuable tests quickly, increasing confidence in feature development.

Dec 2024Modernizing a simple C++ application to Java with GitLab DuoThis post details the use of GitLab Duo's AI capabilities to refactor a C++ application to Java. It demonstrates using AI for code explanation, automated refactoring, and generating build configurations (pom.xml) and project structure. The post also shows how AI can assist in understanding build commands and running the refactored Java application. This contributes to the AI-assisted features thread by showcasing practical application of AI for code modernization and migration.

Dec 2024Automating with GitLab Duo, Part 2: Complex testingThis post details practical lessons learned from using GitLab Duo for complex test generation. It covers strategies for updating existing test cases (e.g., refactoring to use unittest), creating tests for legacy code by providing error snippets, handling complex or abstracted code by providing examples and requesting modifications one at a time, ensuring generated code adheres to standards through specific refactoring prompts, and leveraging AI to uncover and address new test cases, thereby increasing test coverage. Key takeaways highlight the importance of prompt engineering, understanding underlying code and frameworks, defining desired end states and standards, and acknowledging that AI-generated tests augment, but do not replace, traditional testing methodologies.

Dec 2024Streamline DevSecOps engineering workflows with GitLab DuoThis post details how GitLab Duo's AI capabilities are being applied to streamline DevSecOps engineering workflows. Specific features highlighted include: Merge Request Summary, Discussion Summary, Code Review Summary, Code Explanation, Code Suggestions (for IaC and configuration management), GitLab Duo Chat for troubleshooting and generation, automated test generation, CI/CD pipeline Root Cause Analysis, and Vulnerability Explanation/Resolution. The post emphasizes how these features reduce time spent on documentation, configuration, debugging, and vulnerability management, thereby increasing engineer efficiency.

Dec 2024GitLab Duo with Amazon Q: DevSecOps meets agentic AIThis post announces the integration of GitLab Duo with Amazon Q, creating a joint offering that brings AI agents directly into GitLab's DevSecOps platform. Key new capabilities include: - Invoking AI agents via quick actions like `/q dev` to convert issue descriptions into merge-ready code. - Automating Java modernization with `/q transform` to migrate to Java 17. - Accelerating code reviews with `/q review` for instant, intelligent feedback. - Automating unit test generation with `/q test`. - The integration emphasizes enterprise-grade security, guardrails, and granular controls for AI features at user, project, and group levels.

Dec 2024Automating with GitLab Duo, Part 1: Generating testsThis post details the practical application of GitLab Duo for automated test generation within the VS Code IDE using the GitLab Workflow extension. It outlines the process of selecting code, invoking the 'Generate tests' command, and reviewing the AI-generated tests. It also provides a pro-tip for organizing generated test files and highlights the efficiency gains in achieving code coverage.

Nov 2024Chat about your merge request with GitLab DuoIntroduces GitLab Duo Chat's capability to engage in in-depth conversations about merge requests. It can answer questions regarding failure scenarios, privacy concerns, rationale behind changes, potential risks, and trade-offs within the context of a specific MR. The AI is aware of the MR description, discussions, code diff, and metadata.

Oct 20243 GitLab features to level up DevSecOps workflowsThis post introduces GitLab Duo Root Cause Analysis for diagnosing broken CI/CD pipelines by analyzing log files and suggesting fixes. It also highlights GitLab Duo Vulnerability Explanation for understanding security risks, providing vulnerability descriptions, exploit examples, and remediation suggestions. Finally, it details Advanced SAST, a new security scanner using a proprietary detection engine for more accurate vulnerability identification and reduced false positives.

Oct 2024Use GitLab Duo to build and deploy a simple Quarkus-native projectThis post details the use of GitLab Duo Chat to generate project files for a Quarkus-native application. It includes specific prompts and generated code for `HelloResource.java`, `Dockerfile.native`, `pom.xml`, `HelloResourceTest.java`, and `HelloResourceIT.java`, as well as the project directory structure. This demonstrates how AI can accelerate the initial setup and development of a new application.

Oct 2024GitLab Duo Chat: Get to know productivity-boosting AI enhancementsThis post details the migration of GitLab Duo Chat to Claude 3.5 Sonnet, the introduction of a Slash Command Picker in the GitLab UI, integration of Root Cause Analysis for CI/CD jobs, the ability to fix selected code in the IDE with specific slash commands, and the integration of the 'Explain Vulnerability' feature for SAST results. It also outlines future plans for enhanced contextual awareness (commits, pipeline jobs, merge requests), a `/help` slash command, and improved IDE support.

Sep 2024Build an ML app pipeline with GitLab Model Registry using MLflowThis post introduces a tutorial on building an ML app pipeline using GitLab Model Registry and MLflow. It details setting up environment variables for MLflow tracking, training and logging model candidates within merge requests, registering the most successful candidate, and Dockerizing/deploying the ML app. The post highlights the use of CI/CD components for reusability and the integration of MLflow with GitLab's project structure for model experiments. It also mentions the use of Random Forest Classifier, Decision Tree, and Logistic Regression for a loan prediction example.

Sep 2024Navigating the AI frontier: Lessons from the cutting edgeThis post details lessons learned from attending the AI Engineer World's Fair, emphasizing the shift in the traditional development lifecycle due to AI. Key takeaways include the need for rapid iteration (under three months for productization), prioritizing user experience early, adopting iterative development with base models and prompt templates, and the significant time required for evaluations ('The Great Eval Problem'). It highlights the importance of prompt engineering best practices, such as standardizing query languages, using LLMs to write code, and breaking down problems. The post also discusses the evolving role of AI engineers, the customer's point of view being top of mind, and future trends like prompt unification, autonomous agents, and advancements in RAG workflows.

Aug 2024Refactor code into modern languages with AI-powered GitLab DuoThis post details how GitLab Duo, powered by Anthropic Claude 3.5, can be used for code refactoring across different programming languages and standards. It provides examples of generating Java 7 code and refactoring it to Java 8, as well as refactoring C++ code across various standards (C++03 to C++14, C++23 to C++11). The post highlights the use of IDE extensions (VS Code, JetBrains) and specific prompts for code generation, explanation, and refactoring. It also mentions refactoring COBOL, C to Rust, Perl to Python, JavaScript, and Bash to ZSH/SH.

Aug 2024Mastering GitLab admin tasks with GitLab Duo ChatThis post introduces GitLab Duo Chat as a tool for GitLab administrators, focusing on its ability to streamline complex administrative tasks. It provides a case study on updating group memberships across a large number of groups using the Rails console and a Ruby script, demonstrating how Chat can assist in crafting and refining such scripts. The post also highlights Chat's capabilities in interpreting Git errors and optimizing Gitaly configurations, along with best practices for formulating queries and using its suggestions incrementally. It showcases specific examples of how Chat can help with user management at scale and CI/CD performance.

Jul 2024Use GitLab AI features out-of-the-box in a GitLab WorkspaceThis post details the integration of GitLab Duo Chat and Code Suggestions within GitLab Workspaces and the VS Code editor via the GitLab Workflow extension. It explains how to set up and use these components together to create an AI-assisted remote development environment, focusing on the user experience of leveraging AI for code suggestions, unit test generation, and contextual chat interactions within a pre-configured workspace.

Jul 2024Developing GitLab Duo: A roundup of recent Chat enhancementsThis post details the integration of GitLab Duo Vulnerability Explanation into Chat, highlighting rapid cross-team collaboration. It expands on Chat's context awareness to include epics and issues in the UI, and selected code in IDEs. Prompt cancellation is now available on GitLab.com. Architectural improvements include the adoption of the Language Server Protocol (LSP) for better IDE integration. Future work includes migrating to Claude 3.5 Sonnet, enabling custom self-hosted models, synchronizing messages across clients, and migrating the 'Summarize Comments' feature to Chat.

Jun 2024Meet GitLab Duo Workflow - the future of AI-driven developmentThis post introduces GitLab Duo Workflow, an autonomous AI agent designed to automate and optimize the software development lifecycle. It details four key use cases: automated development (planning, coding, testing, merge requests, code review), intelligent continuous improvement (architectural optimization, refactoring, cloud resource management), proactive security and compliance (patching, vulnerability mitigation), and self-optimizing performance (feedback loops, continuous learning). The agent operates within GitLab Remote Development workspaces and leverages GitLab's unified data store. It aims to transition from prompt-based AI to AI that drives development workflows.

Jun 2024Top tips for efficient AI-powered Code Suggestions with GitLab DuoThis post provides practical guidance and best practices for using GitLab Duo Code Suggestions, focusing on prompt engineering, iterative development with AI assistance, and combining Code Suggestions with other GitLab Duo features. It includes specific examples for fixing missing dependencies in Go, generating optimized logging in Ruby, and creating regular expressions. The post emphasizes learning and practicing with AI tools to improve developer experience and efficiency.

Jun 2024GitLab Duo: AI-powered CI/CD pipeline root cause analysisIntroduces GitLab Duo Root Cause Analysis, an AI-powered feature that analyzes CI/CD job logs to identify the root cause of pipeline failures and suggest fixes. Details the mechanism of forwarding logs to the GitLab AI Gateway for LLM analysis and provides two detailed examples: diagnosing Python dependency errors (ModuleNotFoundError) and missing Go runtimes in containerized environments. Demonstrates how to fix these issues by modifying `.gitlab-ci.yml` and Dockerfiles, and suggests using GitLab Duo Chat for follow-up questions and advanced troubleshooting.

Jun 2024Developing GitLab Duo seriesThis series of posts details the development and integration of GitLab Duo, focusing on how AI models are validated and tested at scale, the creation of an AI Impact analytics dashboard to measure ROI, the dogfooding of AI features within GitLab's own SDLC, methods for securing and testing AI-generated code, the use of AI and Root Cause Analysis to fix CI/CD pipelines, recent enhancements to GitLab Duo Chat, and the use of AI to remediate security vulnerabilities.

Jun 2024Inside look: How GitLab's Test Platform team validates AI featuresThis post details the development of the AI continuous analysis tool by the Test Platform team to validate GitLab Duo features. It describes the automation of data collection within VS Code using WebdriverIO and GitLab CI/CD, focusing on measuring suggestion latency and leveraging existing code quality/security analysis. It also outlines performance validation strategies using mocked AI Gateway responses and multi-regional latency tests with the GitLab Environment Toolkit and GitLab Performance Tool. Functional testing approaches, including unit, integration, and end-to-end tests (using real and mock AI responses), are also covered.

May 2024Developing GitLab Duo: Secure and thoroughly test AI-generated codeThis post details the integration of GitLab Duo with GitLab Pages to secure and test AI-generated code. It provides a step-by-step guide for developers to: 1. Create a new project. 2. Enable GitLab Duo Code Suggestions. 3. Create a Flask web server. 4. Generate unit tests using the `/tests` command in Duo. 5. Identify security vulnerabilities and dependency issues using Duo Chat. 6. Generate test reports with a Python script. 7. Deploy test reports using GitLab Pages via a `.gitlab-ci.yml` configuration. 8. Embed test reports in MR widgets. It also includes a case study demonstrating the integration of SAST scanning to detect OS command injection vulnerabilities in AI-generated code.

May 2024GitLab Duo Chat 101: Get more done on GitLab with our AI assistantThis post introduces GitLab Duo Chat's capabilities, focusing on its ability to summarize issue comment threads and provide insights into issues and epics. It details how to craft effective prompts for context and simplicity, and highlights the importance of follow-up questions for maintaining conversational flow. Use cases are provided for product managers, developers, QA engineers, and new employees. The post also mentions integration with IDEs like VS Code and JetBrains.

May 2024Developing GitLab Duo: How we are dogfooding our AI featuresThis post details how GitLab engineers are dogfooding GitLab Duo features, including Code Suggestions and Chat. Specific use cases highlighted include summarizing merge requests, answering coding questions, explaining code snippets, condensing comment threads, creating new documentation, crafting release notes, optimizing documentation navigation, drafting and refining OKRs, streamlining hiring communication, summarizing production incidents, creating boilerplate `.gitlab-ci.yml` files, full-stack code generation (JavaScript and Ruby), generating Python scripts for non-GitLab tasks, generating test source code for CI/CD components, streamlining research tasks by using Chat instead of multiple browser tabs, testing new features like Markdown support in Code Suggestions, and using the `/explain` feature to understand external projects. The post emphasizes the benefits of these AI features in terms of automation, time savings, improved code quality, and streamlined administrative tasks.

May 2024Developing GitLab Duo: AI Impact analytics dashboard measures the ROI of AIThis post introduces the AI Impact analytics dashboard for GitLab Duo, available in GitLab 17.0. This dashboard provides real-time visibility into the ROI of AI features by visualizing improved metrics, comparing AI-using teams to non-AI-using teams, tracking AI adoption, and automating insights extraction. Key features include detailed usage metrics for Code Suggestions, correlation analysis between AI usage and SDLC performance metrics (Cycle Time, Lead Time, Deployment Frequency, Change Failure Rate, Critical Vulnerabilities), and a comparison view of AI-influenced teams. Future plans include new tile visualizations for seat usage, acceptance rates, and chat users, as well as a comparison bar chart and AI statistics in contribution analytics.

May 2024Developing GitLab Duo: How we validate and test AI models at scaleThis post details GitLab's AI model validation process for GitLab Duo features. It outlines the creation of a prompt library as a proxy for production, the process of baselining model performance using metrics like Cosine Similarity Score and LLM Judge, and the iterative development cycle involving focused and broader dataset testing. The post emphasizes the importance of testing at scale to identify patterns and mitigate risks associated with LLMs, and highlights the use of models from Google and Anthropic. It also mentions the Centralized Evaluation Framework (CEF) and its role in identifying patterns and assessing overall behavior.

Apr 202410 best practices for using AI-powered GitLab Duo ChatThis post details 10 best practices for using GitLab Duo Chat to improve prompt engineering and integrate it into DevSecOps workflows. It covers conversational prompting, refining prompts with more context, following prompt patterns, using low-context communication, repeating and refining prompts, and leveraging slash commands in IDEs. It also provides examples of how to interact with the chat feature for code generation, configuration, and explanations.

Feb 2024How-to: Detecting secrets in video contentThis post details the development of a custom scanner for detecting secrets in video content, leveraging Google Cloud's Video Intelligence API for OCR and implementing approximate regular expression matching to account for OCR inaccuracies. It also highlights the use of GitLab Duo Chat to assist in writing a C++ Node.js addon for integrating the TRE library for approximate regex matching.

Feb 2024Measuring AI effectiveness beyond developer productivity metricsThis post introduces the concept of 'AI Impact' as a new dashboard within GitLab's Value Stream Analytics. It details the challenges of measuring AI effectiveness, particularly for developer productivity tools, by critiquing metrics like lines of code and acceptance rates. It advocates for focusing on business outcomes (lead time, cycle time, production defects, user satisfaction) and proposes combining quantitative SDLC data with qualitative developer feedback. The post outlines the planned approach for the AI Impact dashboard, which will blend Value Stream Analytics, DORA metrics, and GitLab Duo usage data to provide a comprehensive view of AI's influence on the SDLC.

Feb 2024New report on AI-assisted tools points to rising stakes for DevSecOpsThis post emphasizes the increasing importance of AI-assisted tools in DevSecOps, citing a report that highlights the competitive disadvantage for enterprises not adopting these technologies. It details how AI-powered tools can improve developer productivity, enhance security by reducing testing bottlenecks, and streamline workflows. The post specifically mentions GitLab Duo as a product suitable for enterprise-grade application development, noting its integration throughout the SDLC, its privacy-first approach (not using client code for model training), and its model-agnostic gateway. It also highlights Duo Code Suggestions and Chat as features that improve collaboration and security, with "security guardrails consistently applied throughout."

Jan 2024Write Terraform plans faster with GitLab Duo Code SuggestionsThis post details the setup and usage of GitLab Duo Code Suggestions for accelerating the creation of Terraform plans. It outlines the steps to install the GitLab extension for IDEs, authenticate, enable code suggestions, and configure third-party extensions for Terraform. It also demonstrates how to prompt GitLab Duo with comments to generate Terraform code and how it provides context-aware suggestions for provisioning resources on Google Cloud Platform.

Jan 2024GitLab uses Anthropic for smart, safe AI-assisted code generationThis post details the integration of Anthropic's Claude generative AI model into GitLab Duo Code Suggestions for AI-assisted code generation. It explains how developers can use comments to generate code blocks, providing examples of JavaScript and Python code generation. The post highlights the safety and trustworthiness aspects of Claude, emphasizing its ability to mitigate unsafe behaviors and provide accurate code generation. It also mentions the general availability of Code Suggestions and encourages users to try the free trial.

Dec 2023GitLab Duo Code Suggestions is generally availableThis post announces the general availability of GitLab Duo Code Suggestions with GitLab 16.7. It details the capabilities of code generation and code completion, lists supported languages and IDEs, and highlights the benefits of reduced context switching and improved developer efficiency. It also mentions other GitLab Duo AI features and reiterates GitLab's commitment to data privacy.

Oct 2023GitLab AI, CI/CD and customization for secure scaled growthThis post details the expansion of GitLab Duo capabilities across the entire SDLC, including Vulnerability Explanation (Beta) for summarizing and suggesting mitigations for detected vulnerabilities, Code Suggestions (Beta) for faster code creation and updates, and Suggested Reviewers (GA) for informed reviewer selection. It also highlights the extension of GitLab Duo to self-hosted instances, starting with Code Suggestions.

Oct 2023Learn advanced Rust programming with a little help from AIThis post demonstrates the practical application of GitLab Duo Code Suggestions for learning advanced Rust programming. It details how to set up a remote development environment, initialize a Rust project, define RSS feed URLs using `HashMap`, and organize code into modules with the `feed_reader` module and `get_feeds` function. It also touches upon using external crates like `feed-rs` for XML parsing, handling program arguments, and exploring optimization techniques such as asynchronous execution and multithreading. The post includes a benchmark for sequential vs. parallel execution and mentions CI/CD integration with Rust caching.

Oct 2023Building GitLab with GitLab: Why there is no MLOps without DevSecOpsThis post details how GitLab's Data Science team uses GitLab CI/CD to build and store standardized data science container images in the GitLab Container Registry, enhancing experiment reproducibility. It also explains how GPU-enabled GitLab Runners are used for faster ML model training, triggered by commit messages, and introduces the use of GitLab's ML experiment tracker for storing pipeline metadata and artifacts.

Sep 2023Modern software development problems require modern AI-powered DevSecOpsThis post details the integration of several AI-powered features within the GitLab DevSecOps platform to address modern software development challenges. It showcases how AI can be applied to: 1. Summarize lengthy GitLab issues to improve problem definition and collaboration. 2. Provide code suggestions within IDEs to accelerate solution development. 3. Suggest relevant code reviewers based on contribution graph data to streamline code reviews. 4. Generate test cases to improve code quality and identify edge cases. 5. Offer GitLab Duo Chat for natural language interaction and minimizing context switching. The post also illustrates how these AI touchpoints integrate with GitLab CI/CD pipelines for automated build, test, and deployment.

Aug 2023Explore the Dragon Realm: Building a C++ adventure game with AIThis post details the use of GitLab Duo Code Suggestions to learn C++ by building a text-based adventure game. It covers setting up the development environment (VS Code, Clang), writing basic C++ code (Hello World, I/O streams), using variables (string, int), and introducing conditional logic. The post highlights how AI suggestions can guide the learning process and assist in code generation for game development.

Aug 2023How GitLab Duo Code Suggestions helped me make long car rides funThis post details the practical application of GitLab Duo Code Suggestions for developing a simple Python guessing game, demonstrating how natural language comments can be translated into functional code. It also showcases the use of GitLab Remote Development workspaces as a method to provide access to a cloud-hosted development environment for a non-technical user on a mobile device. The post highlights the beta status of these features and encourages user feedback.

Jul 2023Combine GitLab Flow and GitLab Duo for a workflow powerhouseThis post details the integration of GitLab Duo's AI capabilities into GitLab Flow. Specifically, it highlights how GitLab Duo features like Issue description generation, Discussion summary, Merge request summary, Code Merge request template population, Code Suggestions, Code explanation, Suggested reviewers, Code review summary, Test generation, and Chat can enhance each stage of the GitLab Flow. The post emphasizes how these AI features improve efficiency, collaboration, and code quality throughout the DevSecOps lifecycle.

Jul 2023GitLab plugins for JetBrains and Neovim now available in BetaThis post announces the beta availability of GitLab plugins for JetBrains IDEs and Neovim, extending GitLab Duo Code Suggestions to these development environments. It details the installation and basic configuration for both platforms and links to feedback issues for each plugin. It also mentions ongoing work on a GitLab Language Server for Code Suggestions to standardize IDE extensions.

Jul 2023Supercharge productivity with generative AI and GitLab DuoThis post introduces and details several new AI-assisted features within GitLab Duo, focusing on enhancing developer productivity and code review processes. New capabilities include: Code Suggestions (Beta), Code Explanations (Experiment), AI-generated tests for code changes, Vulnerability Explanations (building on previous 'explain this vulnerability' work), Merge Request Change Summary (using `/summarize_diff` quick action), Issue Comment Summary, Suggested Reviewers (building on existing functionality), and Merge Request Review Summary (using 'summarize my code review'). It also mentions future experiments like GitLab Duo Chat and 'fill in merge request description'.

Jul 2023GPU-enabled runners for ModelOps and HPC workloads in CI/CDIntroduces GPU-enabled runners on GitLab.com SaaS for ModelOps and HPC workloads. Details how to use them by tagging jobs and selecting appropriate Docker images with NVIDIA CUDA drivers. Provides examples for basic model training and scientific simulations, as well as an advanced example of building a custom Docker image for model training, including steps for building, testing, and publishing the model. Also mentions using GPU runners for ML-powered GitLab issue triage.

Jun 2023GitLab 16: AI and security take center stageGitLab 16 introduces GitLab Duo, a suite of enterprise-grade AI capabilities integrated into the DevSecOps platform. GitLab Duo aims to improve workflow efficiency by 10x and includes features like Code Suggestions, Explain this Code, Explain this Vulnerability, Summarize Issue Comments, and Chat. The partnership with Google Cloud ensures privacy and security for AI features, preventing customer intellectual property from being used for AI model training. The post also highlights CARFAX's use of GitLab for CI/CD pipeline creation and the general availability of GitLab Dedicated, a single-tenant SaaS offering. Value Stream Dashboards and Product Analytics are also mentioned as enhancements for observability and user feedback.

Jun 2023GitLab for Visual Studio, including code suggestions, available in BetaThis post announces the beta release of the GitLab for Visual Studio extension, enabling GitLab Duo code suggestions within the IDE. It details the download and setup process, demonstrates how to use the code suggestions, and mentions ongoing work on IDE extensions for JetBrains IDEs and Neovim, as well as a GitLab Language Server for code suggestions.

Jun 2023Meet GitLab Duo, the suite of AI capabilities powering your workflowsIntroduces GitLab Duo, a suite of AI capabilities integrated into the DevSecOps Platform. Capabilities include Code Suggestions, Explain this Code, Explain this Vulnerability, generating descriptions for epics/issues/tasks, summarizing issue comments, and Chat. Mentions future capabilities like assisting with planning descriptions, CI configuration, chart generation, refactoring vulnerabilities, suggesting fixes for failed tests, resolving CI/CD pipeline failures, summarizing vulnerability reports, and assisting with merge request reviews. Emphasizes a privacy-first approach and the goal of 10x workflow efficiency improvement.

Jun 2023Train and deploy AI models with GitLab and Google Cloud's Vertex AIThis post details a tutorial on how to use GitLab and Google Cloud's Vertex AI to deploy an AI model for credit card fraud detection. It outlines the solution architecture, including data preprocessing with SMOTE, model training with RandomForestClassifier, and model deployment to Vertex AI via GitLab CI/CD. The post provides a step-by-step walkthrough covering GitLab and Google Cloud connection, data upload to Vertex AI, CI/CD pipeline creation (test, train, deploy stages), model training script, model deployment script, and prediction testing. It highlights the use of GitLab's DevSecOps platform to orchestrate ModelOps workloads.

Jun 2023ML experiment: Extending Code Suggestions to more development environmentsThis post announces experimental support for GitLab Code Suggestions in Visual Studio, JetBrains IDEs, and Neovim via a language server. It details the engineers who built these rapid prototypes and provides links to getting started instructions and feedback issues. The post also reiterates the ongoing iteration on AI/ML features and the expansion beyond current IDE integrations.

May 2023How Code Suggestions can supercharge developers' daily productivityThis post introduces and demonstrates the practical application of GitLab Code Suggestions, an LLM-based technology, for enhancing developer productivity. It showcases specific use cases including importing packages, completing functions, filling boilerplate code (e.g., database connections), building data frames, and generating unit tests. The post also highlights the expansion of language support to 13 languages and the availability of Code Suggestions for free on GitLab.com during beta.

May 2023ML experiment: Summarize my merge request reviewIntroduced a rapid prototype of an AI action that summarizes merge request reviews, providing authors with a concise overview of feedback to speed up the review cycle. This experiment is part of ongoing efforts to integrate AI/ML features into the DevSecOps platform.

May 2023Code Suggestions available to all GitLab tiers while in BetaCode Suggestions is now available to all GitLab tiers on GitLab.com for free during its Beta phase. Language support has been expanded to 13 languages. The underlying AI model is being improved weekly. Privacy is a core focus, with source code kept secure and not used for training. IDE support is expanding to include the GitLab WebIDE and JetBrains IntelliJ-based IDEs, with ongoing work on user experience and setup. Self-managed instances will also receive support via a secure connection to GitLab.com.

May 2023ML experiment: Use a chatbot to answer how-to questionsThis post introduces an experimental chatbot feature developed by the Global Search team that answers how-to questions about the GitLab product. The chatbot overlays the GitLab UI and provides explanations and links to documentation, aiming to reduce context switching and improve user efficiency. This is presented as an early step in infusing AI/ML into GitLab.

May 2023GitLab details AI-assisted features in the DevSecOps platformThis post details GitLab's comprehensive AI strategy and introduces a suite of AI-assisted features being integrated into the DevSecOps platform. It highlights a generative AI partnership with Google Cloud, emphasizing a privacy-first approach. The post outlines specific AI capabilities for developer teams (Code Suggestions, Suggested Reviewers, Summarize MR Changes, Summarize My MR Review), security and operations teams (Explain This Vulnerability, Generate Tests in MRs, Explain This Code), and for all users (Issue Comment Summaries, GitLab Chat, Value Stream Forecasting). It marks a significant expansion into AI-driven product development.

Apr 2023ML experiment: Generate tests for code changesThis post introduces an experiment where AI is used to generate suggested test coverage for code changes directly within merge requests. A new option is added to merge request files to provide suggested tests in a sidebar. The post also outlines future iterations, including automatic detection of missing tests and automated review of proposed tests.

Apr 2023ML experiment: Summarize merge request changesIntroduced an experimental `/summarize_diff` quick action for merge requests, leveraging AI/LLMs to generate summaries of proposed code changes directly within a merge request comment. This experiment aims to improve reviewer and author efficiency by reducing the need to manually update descriptions and allowing more time for discussing changes.

Apr 2023ML experiment: Summarizing issue commentsThis post details an experiment in summarizing issue comments using generative AI LLMs. It describes the technical approach of using prompt engineering to guide LLM output and the engineering challenge of chunking long comment threads for summarization. The post also mentions investigating bringing this functionality to other objects like epics and merge requests.

Apr 2023ML experiment: Explain this source codeThis post introduces an experiment for AI-assisted code explanations within GitLab's repository source code file viewer. It demonstrates a rapid prototype where developers can highlight code selections and receive natural language explanations. The experiment is positioned as a starting point for infusing AI/ML capabilities across the DevSecOps lifecycle, with potential extensions to merge requests and snippets.

Mar 2023ML experiment: Writing SQL is about to get a lot easierThis post details an experiment in AI-assisted SQL generation for GitLab Product Analytics. It showcases how natural language queries can be used to generate SQL for populating dashboard charts and graphs, demonstrating a practical application of AI/ML to improve user efficiency in data analysis.

Dec 2022Testing ChatGPT: Can it solve a GitLab issue?This post explores the use of ChatGPT as a tool to assist in contributing to GitLab. It details the process of finding suitable issues ('good for new contributors' and 'refactor' labels) and using ChatGPT to generate code for de-duplicating Vue components and refactoring tests using `it.each`. While the generated code required manual review and testing, it demonstrated the potential for AI to accelerate the contribution process.

Mar 2022GitLab and Tabnine: AI-powered code completion for GitLab repositoriesThis post details the integration of Tabnine's AI-powered code completion technology with GitLab repositories. It explains how users can connect their GitLab repositories to Tabnine to build custom AI models based on their private code, enabling knowledge sharing, reduced technical debt, faster code reviews, and quicker onboarding. The process involves logging into the Tabnine app, navigating to the 'Team AI' tab, connecting GitLab repositories, and allowing Tabnine to build, test, and upload the private model.

Jan 2022The road to smarter code reviewer recommendationsThis post announces the acquisition of UnReview and its integration into GitLab as a new AI-assisted feature for suggested reviewers. It introduces the concept of a new 'ModelOps' stage focused on data science workloads and the end-to-end lifecycle of AI models. The UnReview algorithm's functionality is described as leveraging contribution history to recommend reviewers. A customer beta is announced for early 2022.

Sep 2018Fighting the opioid epidemic with ML & human-centered designThis post details the creation of Telesphora, a human-centered data science platform that uses machine learning and predictive analytics to combat the opioid epidemic. It describes the use of a spatiotemporal Poisson process to project future opioid overdose trends, leveraging real-time and future-trend data to alert local responders and authorities of potential overdose outbreaks. The post highlights the importance of human-centered design in understanding the impact of the crisis and designing actionable solutions.

What this trail covers