Learning GitLab Duo Agent Platform - Cleveland

module-name: "GitLab Duo Agent Platform"  
area: "Product Knowledge"  
gitlab-group: "AI-powered:Agent Foundations"  
maintainers:
  - lkorbasiewicz
product_category: "GitLab Duo"

Introduction

This training module is intended to provide Support Engineers with an understanding of the GitLab Duo Agent Platform (DAP), including its capabilities, architecture, configuration, troubleshooting patterns, and support scope.

Version assumption: This module assumes GitLab 18.9 or later for all Self‑Managed and Dedicated configuration and credits/billing examples.

Goals of this training module

At the end of this module, you should be able to:

Explain what the GitLab Duo Agent Platform is and how it differs from standard Duo Chat.
Describe how Agentic Chat, agents, flows, AI Catalog, sessions, Knowledge Graph, and MCP fit together.
Configure or verify DAP settings on GitLab.com, Self‑Managed, and (optionally) Duo Self‑Hosted.
Troubleshoot common Agent Platform issues, including configuration problems and non‑happy paths.
Use Sessions and AI logging as part of your debugging workflow.
Triage issues using the Diagnosis Guidelines for DAP by Product Area and route them correctly.
Handle Agent Platform‑related support tickets, including basic usage‑based billing / GitLab Credits questions, and escalate non‑Support items appropriately.
Support peers with questions about the Agent Platform.

Key references (bookmark these)

You will refer to these throughout the module:

Prerequisites

Completion of the GitLab Duo training module is recommended.
You should be comfortable with:
- GitLab groups, projects, and permissions.
- Basic GitLab administration concepts (for the Self‑Managed parts).
- Navigating Support runbooks and internal docs.

General Timeline and Expectations

This issue should take you ~4 hours to complete.

Reminders:

This is a Public issue; do not include anything confidential.
Do Stage 0 first and the Final Stage last.
Outside of that, you can work through stages in any order.
Consider using Time Tracking on this issue so that we can refine the estimate over time.

Stage 0: Create Your Module

Create an issue using this template and title it:

Learning GitLab Duo Agent Platform - your name
Add yourself as the assignee.
Optionally set a milestone and/or a due date.
Update your Support Team yaml file to indicate that you've started learning this knowledge area:
```
knowledge_areas:
  - name: GitLab Duo Agent Platform
    level: 1
```
If you already have GitLab Duo as level 2 or 3 in your product_categories, you can skip the change below. Otherwise:
```
product_categories:
  - name: GitLab Duo
    level: 1
```
Consider using Time Tracking for this issue.

Stage 1: Foundational Concepts

Done with Stage 1

Goal
Build a mental model of DAP and the core terminology.

Tasks

Read What is Agentic AI? (approx. 5 minutes).
Watch Developer Onboarding with GitLab Duo Agent Platform (approx. 5 minutes).
From the DAP docs and "Get started" page, make sure you understand these terms:
- Agentic Chat
- Agent Platform
- Foundational Agents
- Custom Agents
- External Agents
- Flows
- AI Catalog
- Sessions
- Knowledge Graph
- MCP (Model Context Protocol)
In a comment on this issue, answer:
1. In your own words, what is the difference between GitLab Duo Chat (Agentic) and the broader GitLab Duo Agent Platform?
2. How do agents, flows, and the AI Catalog relate to each other?
3. What is the role of sessions in DAP?
Read about Agent Platform architecture to understand:
- How agents talk to the AI Gateway.
- The role of service accounts and composite identity.
- How agents access GitLab resources.
- Data flow and security considerations.

Stage 2: Agent Platform Overview and Documentation

Done with Stage 2

Goal
Understand the main DAP features, where they live in the UI, and which docs you’ll lean on in Support.

Product docs

Triage / ownership docs

Skim the Diagnosis Guidelines for DAP by Product Area and, in a comment, list:
- Which product areas are handled by:
  - Agent Foundations
  - Duo Chat (Agentic)
  - AI Catalog
  - Editor Extensions
  - Self‑Hosted Custom Models
- For each of these, give one example of the kind of issue that should go to them first.

Stage 3: Technical Setup and Configuration

Done with Stage 3

Goal
Know which settings matter for DAP and how to sanity‑check them on different deployments.

You do not have to complete all paths. Pick at least one that matches what you can access:

Path A: GitLab.com / Dedicated
Path B: Self‑Managed using GitLab‑hosted models
Path C: Self‑Managed using Duo Self‑Hosted

You can do more paths if you want deeper practice.

For Self‑Managed and Dedicated examples in this stage, assume GitLab 18.9 or later so that DAP, GitLab Credits, and dashboards behave as described.

Path A: GitLab.com / Dedicated

On GitLab.com (or Dedicated), go to a top‑level group where you can test:
- In Settings > GitLab Duo, confirm:
  - GitLab Duo availability is set to allow AI features.
  - GitLab Duo Core is on (if present and applicable for that namespace).
  - GitLab Duo Agent Platform is enabled (Agentic Chat, agents, flows).
- At group or project level, confirm:
  - Allow flow execution is on where you want DAP to run.
  - Allow foundational flows is on, if you expect foundational flows to be available.
Identify a test project in a namespace where DAP is enabled and you have at least Developer access.
In a comment, describe:
- Which specific settings you would ask a customer admin to check first if a foundational flow doesn’t show up.

Path B: Self‑Managed, GitLab‑Hosted Models

(If you already have a working Self‑Managed instance on GitLab 18.9+ with Duo, you can focus on verification.)

Path C: Self‑Managed, Duo Self‑Hosted

(This is optional but useful if you expect to work with Self‑Hosted customers.)

Common DAP prerequisites checklist

Regardless of path, confirm:

GitLab Duo availability is configured correctly at the relevant scope (instance / top‑level group / project).
GitLab Duo Core is turned on where needed (for customers using Core rather than Pro/Enterprise).
GitLab Duo Agent Platform is turned on (for GitLab 18.9+).
Allow flow execution is enabled where flows should run.
Allow foundational flows is enabled where you expect them.
For Self‑Managed, base Duo configuration (network connectivity, cloud licensing vs offline licensing, etc.) matches the docs.
For Duo Self‑Hosted, AI Gateway and the DAP service are reachable and configured (AI Gateway URL and Agent Platform URL/port are correct, TLS vs DUO_AGENT_PLATFORM_SERVICE_SECURE matches reality).

Stage 4: GitLab Duo Agent Platform in Practice

Done with Stage 4

Goal
Use DAP in a realistic way: foundational flows, Sessions, Agentic Chat, and AI Catalog.

Foundational flows

Read about foundational flows in the docs.
Try at least one developer‑oriented flow (for example, Issue to MR or a similar flow that’s available):
- Create an issue in your test project.
- Trigger the flow (for example, "Generate MR with GitLab Duo").
- Observe what the agent does and what shows up in the UI.
Try the Fix CI/CD pipeline flow (or another foundational flow that makes sense in your environment):
- Create a failing pipeline in your test project.
- Run the flow.
- Note what the flow changes or recommends.

Sessions

After running at least one foundational flow:
- Open Automate > Sessions in your test project.
- Find the session for your flow run.
- From the Details tab, follow the link to the CI/CD job logs.
- In a comment, write down one or two things from the logs or session that would help you debug a customer issue.

Agentic Chat

Open GitLab Duo Chat (Agentic) in a project context (UI or IDE):
- Ask questions that should trigger agent behavior (for example, "Help me fix this pipeline" or "Implement this small feature").
- Pay attention to how it uses project context and tools.
- Try it in at least two different contexts (issue, MR, file, etc.).
In a comment, answer briefly:
- When would you reach for Agentic Chat first, and when would you prefer to run a flow directly?

AI Catalog

Open the AI Catalog in your test project:
- Identify at least one foundational agent and one foundational flow.
- In a comment, note:
  - Their names.
  - Which product area owns them (use the Diagnosis Guidelines as reference).
For one of the flows you used, answer in a comment:
- If this flow stopped working for a customer, which product area would you route it to first (Agent Foundations, AI Catalog, Editor Extensions, Duo Chat, etc.) and why?

Stage 5: Troubleshooting and Support

Done with Stage 5

Goal
Move beyond happy path usage and practice concrete troubleshooting patterns and triage.

Troubleshooting drills

From Troubleshooting the GitLab Duo Agent Platform, describe in a comment how you would handle:
1. Flows not visible in the UI
  - Which permissions to check.
  - Which DAP / Duo toggles to confirm (instance, group, project).
  - Any "toggle off / on and wait for propagation" steps you’d suggest.
2. Session stuck in "created" state
  - How composite identity and group restrictions can block sessions.
  - How push rules or email restrictions on the service account can stop DAP from committing.
  - What regex (or similar) changes you might ask the admin to make to allow Duo‑generated branches/commits.
Review and bookmark:
- DAP troubleshooting page.
- Diagnosis Guidelines for DAP by Product Area.

Diagnosis Guidelines & product area routing

Using the Diagnosis Guidelines, in a comment, summarize:
- When an issue is clearly:
  - Agent Foundations
  - Duo Chat (Agentic)
  - AI Catalog
  - Editor Extensions
  - Self‑Hosted Custom Models
- For two concrete symptoms (for example, "Agentic Chat broken only in VS Code" vs "flow stalls on runner"), note which product area you’d start with and why.

AI logging basics

Skim AI Logging – Core Fields and Patterns in the Diagnosis Guidelines and answer in a comment:
- What are correlation_id and request_id used for?
- For a Self‑Managed customer reporting "Duo Chat timed out", which one jq command from the doc you would start with, and why.

Do not paste real logs or customer data into this issue.

Stage 6: Handling Agent Platform Tickets

Done with Stage 6

Goal
Handle real DAP tickets end‑to‑end, including triage and basic credits/usage questions.

Ticket review and solving

Search Zendesk for closed Agent Platform tickets and review at least 5.

Suggested keywords:
- "Agent Platform"
- "Duo Agent"
- "Agentic"
- "Issue to MR"
- "Fix Pipeline"
Answer 3 Agent Platform‑related support tickets:
- Ticket 1: 692393
- Ticket 2: 707985
- Ticket 3: 703850

Triage and ownership reflection

For each of the 3 tickets you answer:

Add a short note in this training issue (comment) with:
- The product area that owned the problem (Agent Foundations, Duo Chat, AI Catalog, Editor Extensions, Self‑Hosted Custom Models, etc.), based on the Diagnosis Guidelines.
- Whether usage‑billing / GitLab Credits came up and:
  - What you answered (or would answer) as Support.
  - What you would route to:
    - The account team / Sales
    - AR / billing
    - Or #usage-billing-help

Credits / access‑cutoff scenario

Based on a real ticket or a hypothetical example, describe in a comment:
- How DAP behaves when a user or customer runs out of GitLab Credits (for example, banners in Chat, flows being stopped, IDE messages, Sessions showing "stopped due to insufficient credits").
- What you would tell the customer as a Support Engineer (what they can change themselves, and what is purely commercial).
- When you would involve:
  - The account team or Sales
  - AR / billing
  - #usage-billing-help

Stage 7: Advanced Topics (Optional)

Done with Stage 7 (Optional)

Goal
Understand how DAP interacts with other AI components and where Support fits.

Tasks

Read about Cloud Connector / Self‑Hosted Models.
- In a comment, using the Diagnosis Guidelines, summarize:
  - When an issue should be escalated to the custom models team vs handled directly by Support.
Review GitLab Knowledge Graph (GKG) docs.
- From the Diagnosis Guidelines, explain in a comment:
  - How MCP, Knowledge Graph, and Language Server logs relate for Agentic Chat.
  - Which errors are likely Knowledge Graph‑side vs Language‑Server‑side.
Review Editor Extensions docs (VS Code, JetBrains, Visual Studio).
- Explain, based on the Diagnosis Guidelines and docs, when an Agentic Chat issue in an IDE should go to:
  - Editor Extensions,
  - Duo Chat (Agentic),
  - Agent Foundations.
Review GitLab Duo with Amazon Q docs:
- Note how Amazon Q events appear in AI logging and how that differs from native DAP flows.
If you have access to non‑production logs, pick one jq example from the AI Logging section and run it just to see what llm.log entries look like.
Do not paste real outputs here. Instead, note:
- Which fields you saw.
- One way those fields would help when debugging Duo / Agentic issues.

Penultimate Stage: Review

You should now be able to:

Explain DAP capabilities and limitations.
Verify DAP configuration in different environments.
Use docs, Sessions, and logs to troubleshoot common issues.
Triage to the correct product area using the Diagnosis Guidelines.
Handle Agent Platform support tickets, including basic credits/usage questions.

Reflection and module improvement

In this section, answer briefly:
- Are DAP prerequisites and settings (Duo Core, DAP availability, flow execution, foundational flows, and the new Agent Platform toggle in 18.9+) explained clearly enough here to help you debug configuration issues?
- Did the Sessions‑based troubleshooting exercise feel close to what you see in tickets?
- Do you now have a basic understanding of GitLab Credits / usage billing and where to route billing questions?
If you found any of the following in this module or linked docs:
- Dead links
- Out‑of‑date or incorrect content
- Missing troubleshooting steps
- Unclear explanations of DAP settings or credit behavior
list them here as tasks for yourself.
If your findings warrant a change, open a merge request (for this template or relevant docs) and paste the MR link here.

Final Stage

Have your trainer or a DAP expert review your tickets and this issue.
If you don’t have a trainer, ask an expert to review.
Ask your manager to:
- Review how the module went.
- Confirm you’re ready to work DAP tickets.
- Capture any follow‑ups in your 1:1 agenda.
Update your Support Team YAML file to indicate that you’re ready to work tickets in this knowledge area:
```
knowledge_areas:
  - name: GitLab Duo Agent Platform
    level: 2
```
If you already have GitLab Duo as level 2 or 3 in product_categories, you can skip changing that. Otherwise:
```
product_categories:
  - name: GitLab Duo
    level: 1
```

You will now be listed as "Ready to work tickets" in GitLab Duo Agent Platform on:

Skills by Person page, and
Product Categories by Person page.

🎉 Congratulations

You are now prepared to assist customers and colleagues with Agent Platform‑related tickets. 🎉

If you think of further improvements to this module (structure, steps, troubleshooting drills, or links), please submit an MR to the support-training repository. The file lives as an issue template there.

Edited Apr 27, 2026 by Cleveland Bledsoe Jr