[{"data":1,"prerenderedAt":823},["ShallowReactive",2],{"/topics/source-code-management/secure-scm-ai-generated-code":3,"navigation-en-us":121,"banner-en-us":559,"footer-en-us":567,"next-steps-en-us":813},{"id":4,"title":5,"body":6,"category":6,"config":6,"content":7,"description":6,"extension":111,"meta":112,"navigation":113,"path":114,"seo":115,"slug":6,"stem":119,"testContent":6,"type":6,"__hash__":120},"pages/en-us/topics/source-code-management/secure-scm-ai-generated-code/index.yml","",null,[8,22,29,91,109],{"type":9,"componentName":9,"componentContent":10},"CommonBreadcrumbs",{"crumbs":11},[12,16,20],{"title":13,"config":14},"Topics",{"href":15},"/topics/",{"title":17,"config":18},"Source code management",{"href":19},"/topics/source-code-management/",{"title":21},"Secure SCM for AI-generated code",{"type":23,"componentName":23,"componentContent":24},"CommonArticleHero",{"title":25,"text":26,"config":27},"Secure source code management for AI-generated code","Secure source code management (SCM) for AI-generated code is source control that governs what agents can access, what they can change, and what evidence their work produces. It connects identity, authorization, review, security validation, and auditing in one control path.",{"id":28},"secure-scm-for-ai-generated-code",{"type":30,"componentName":30,"componentContent":31},"CommonSideNavigationWithTree",{"anchors":32,"components":59},{"text":33,"data":34},"On this page",[35,39,43,47,51,55],{"config":36,"text":38},{"href":37},"#what-is-secure-scm-for-ai-generated-code","What is secure SCM for AI-generated code?",{"config":40,"text":42},{"href":41},"#why-ai-generated-code-changes-scm-governance","Why AI-generated code changes SCM governance",{"config":44,"text":46},{"href":45},"#a-secure-scm-control-path-for-ai-generated-code","A secure SCM control path for AI-generated code",{"config":48,"text":50},{"href":49},"#protect-the-control-path-from-prompt-injection","Protect the control path from prompt injection",{"config":52,"text":54},{"href":53},"#a-rollout-sequence-for-engineering-and-security-leaders","A rollout sequence for engineering and security leaders",{"config":56,"text":58},{"href":57},"#how-gitlab-supports-a-secure-scm-control-path","How GitLab supports a secure SCM control path",[60,66,71,76,81,86],{"type":61,"componentName":61,"componentContent":62},"TopicsCopy",{"header":38,"text":63,"config":64},"Secure SCM for AI-generated code treats identity, authorization, isolation, review, security validation, and auditability as one control path. Agents can work in parallel, open merge requests, and change pipeline configuration, so source control has to define the boundaries they work within and keep evidence that people and systems can inspect later.\n\nEngineering and security leaders reviewing agent-generated changes need more than a passing pipeline and an approved merge request. They need to know which agent produced the change, what it was allowed to access, which policies were applied, and whether the code can be traced from generation through deployment.\n\n> Read the [Rethinking source code management for the agentic era](https://learn.gitlab.com/whitepaper-scm/whitepaper-scm-agentic-era) whitepaper to learn more about how SCM must evolve as agents take a larger role in software delivery.",{"id":65},"what-is-secure-scm-for-ai-generated-code",{"type":61,"componentName":61,"componentContent":67},{"header":42,"text":68,"config":69},"Agent workflows create a provenance gap and a control problem.\n\n[Traditional Git workflows](https://about.gitlab.com/topics/version-control/what-is-git-workflow/) are built around a human contributor who clones a repository, makes changes, pushes a branch, and participates in review. An agent may repeat that pattern many times, across parallel sessions, with different tools, models, prompts, and levels of autonomy.\n\nThat creates a provenance gap. A normal commit can identify the code change and its author, but a secure agent workflow also needs to preserve the context around the change: the initiating user, the agent or service identity, the workflow that ran, the tools it called, and the approvals or policy decisions that shaped the result.\n\nIt also creates a control problem. An agent that can read source code, modify files, open merge requests, change pipeline configuration, or access external tools has more than one possible risk boundary. Treating every action as equally safe either creates excessive friction or grants more autonomy than the task requires.\n\nGitLab’s [governance framework for agentic AI](https://about.gitlab.com/blog/govern-agentic-ai-mcps-code-assistants/) describes this shift as a move from asking which model writes the best code to asking what an agent is allowed to do and how the organization can prove what it did. The same principle applies to SCM: source control must become part of the security boundary for agent-generated change.",{"id":70},"why-ai-generated-code-changes-scm-governance",{"type":61,"componentName":61,"componentContent":72},{"header":46,"text":73,"config":74},"A practical model has six layers. Each layer answers a different security question, and together they create a chain of evidence from agent request to production change.\n\n### The six layers at a glance\n\n| **Layer** | **Question it answers** | **Control described in this article** |\n| :---- | :---- | :---- |\n| **Identity** | Who initiated and performed the action? | Composite identity, where supported: link the agent or service identity to the requesting human and authorize both principals |\n| **Authorization** | What is the agent allowed to access? | Least privilege; policy-driven controls for which agents, flows, and models are allowed; tool approval guardrails (run autonomously, pause for human review, or remain blocked) |\n| **Isolation** | Where does speculative work happen? | Recommended design patterns: short-lived credentials, ephemeral branches, and lightweight agent workspaces |\n| **Review and approval** | Where does human judgment remain required? | Merge request approval policies and tool-level approval rules |\n| **Security validation** | What evidence must the code produce? | Tests, code quality checks, SAST, software composition analysis, secret detection, and infrastructure scanning; scan execution policies and approval policies |\n| **Auditability** | Can the organization explain what happened? | Define the evidence your organization needs to retain; GitLab describes flow-session trigger details and links to CI/CD job logs, and its governance guidance recommends audit event streaming for agent activity |\n\n### 1. Identity: Who initiated and performed the action?\n\nAn agent should not appear as an anonymous automation token, and a human should not be able to hide behind a generic service account. Secure identity connects the person who initiated the work with the agent or service identity that performed it.\n\nGitLab’s [composite identity model](https://about.gitlab.com/blog/improve-ai-security-in-gitlab-with-composite-identities/) combines a human user and a service account. It limits access to what both principals are authorized to use and maintains a record that links automated activity back to the initiating user. This is especially important when an agent creates commits or merge requests: the workflow must preserve both machine provenance and human accountability.\n\nFor engineering leaders, the policy requirement is simple: every [AI-generated](https://about.gitlab.com/topics/devops/ai-code-generation-guide/) change should be attributable to a known workflow, a known agent identity, and a known initiating user. If those relationships cannot be reconstructed, the organization has a review and audit problem even when the code passes its tests.\n\n### 2. Authorization: What is the agent allowed to access?\n\nAuthentication answers who the agent is. Authorization answers where it can operate and what it can do.\n\nStart with least privilege. A code review agent may need to read a merge request and its associated files, but it may not need permission to delete resources, run arbitrary commands, modify deployment configuration, or write comments. A remediation flow may need to create a branch and open a merge request, while still being prevented from merging directly to a protected branch.\n\n[GitLab Duo Agent Platform](https://about.gitlab.com/gitlab-duo-agent-platform/) provides policy-driven controls for deciding which agents and flows are allowed, where they can operate, and which models they can use. Tool approval guardrails can let an action run autonomously, pause for human review, or remain blocked. That gives security teams a more useful policy model than a single “AI enabled” switch: autonomy can be assigned to the action, role, project, or environment where risk actually differs.\n\nA useful policy matrix asks:\n\n* Which projects may this agent access?  \n* Which repositories, branches, files, and environments are in scope?  \n* Which actions are read-only?  \n* Which actions require human approval before execution?  \n* Which actions are never appropriate for this agent?  \n* What happens when the agent runs without a human available to approve a request?\n\n\u003Cbr>\n\nBackground workflows deserve special attention. Interactive sessions can pause for approval. Headless flows cannot rely on a person responding to an approval prompt, so their policy must default to a safe, explicit allowlist or denylist rather than assuming that human review will happen in real time.\n\n### 3. Isolation: Where does speculative work happen?\n\nAI-generated code is often exploratory. An agent may produce several candidate implementations, abandon partial work, or need to retry after a failed test. Those operations should not contaminate the main branch or share uncontrolled state with other sessions.\n\nShort-lived credentials, ephemeral branches, and lightweight agent workspaces are ways to keep sessions isolated. These patterns support a basic security principle: speculative work should be easy to identify, review, discard, and trace without being confused with an approved production change.\n\nIsolation also reduces the blast radius of a compromised or misdirected agent. If a workflow has only the access it needs for a bounded task, an unexpected instruction in a file, issue, or merge request has fewer paths to cause damage.\n\n### 4. Review and approval: Where does human judgment remain required?\n\nHuman-in-the-loop does not mean a person manually reviews every token an agent produces. It means the organization defines which decisions require a person before the change can advance.\n\nFor AI-generated code, common checkpoints include:\n\n* Opening or updating a merge request  \n* Changing security-sensitive code or configuration  \n* Modifying CI/CD or deployment behavior  \n* Introducing or upgrading dependencies  \n* Resolving a vulnerability or changing a security control  \n* Merging to a protected branch or promoting to production\n\n\u003Cbr>\n\n[Source code management](https://about.gitlab.com/solutions/source-code-management/) can provide a policy boundary that applies regardless of whether a human or an agent opened the merge request. Tool-level approval rules add a second boundary for the agent’s actions before the change reaches the merge request stage.\n\nThe important design choice is to place approval at the point of risk. Read-only investigation can often be automated. A write that changes a production path, weakens a security control, or introduces an unreviewed dependency should require stronger evidence and, where appropriate, named human approval.\n\n### 5. Security validation: What evidence must the code produce?\n\nAI-generated code should enter the same validation path as human-written code. It should not receive a shorter route to merge because it was generated by an approved agent.\n\nThe validation path may include tests, code quality checks, SAST, software composition analysis, secret detection, infrastructure scanning, and other controls defined by the organization. Scan execution policies can make required checks consistent across projects, while approval policies can prevent a merge when findings or policy violations require review.\n\nGitLab [application security testing](https://about.gitlab.com/solutions/application-security-testing/) runs scans in the same pipeline as the code and shows findings in the merge request and IDE, so reviewers and agents get feedback before merge. With [GitLab Source Code Management](https://about.gitlab.com/solutions/source-code-management/), code owners, approval rules, and security scans apply to agent-authored merge requests the same way they apply to human ones, so teams set one policy for both. Compliance pipelines enforce the policies teams define, and audit events keep a history of sensitive actions.\n\nThe policy question is not whether the agent ran a scan; it’s “what evidence must be present before this category of AI-generated change is eligible to merge, and what blocks the change when the evidence is missing?”\n\n### 6. Auditability: Can the organization explain what happened?\n\nA secure SCM workflow should leave a durable record of the agent session and the resulting code change. The record should make it possible to answer:\n\n* Who initiated the session?  \n* Which agent, workflow, model, and tools were involved?  \n* What resources did the agent access?  \n* Which actions were allowed, approved, rejected, or blocked?  \n* Which commit, merge request, pipeline, vulnerability finding, or deployment resulted?  \n* Which human approved the change, and under which policy?\n\n\u003Cbr>\n\nGitLab’s [agent-governance guidance](https://about.gitlab.com/blog/govern-agentic-ai-mcps-code-assistants/) recommends audit event streaming for agent activity. A record configured to capture the required details turns provenance from a best-effort reconstruction into an operational control.\n\nAuditability is not only for compliance. It improves incident response, helps reviewers understand how a change was produced, and gives future agents structured context instead of forcing them to infer history from scattered logs and conversations.",{"id":75},"a-secure-scm-control-path-for-ai-generated-code",{"type":61,"componentName":61,"componentContent":77},{"header":50,"text":78,"config":79},"AI-generated code introduces another SCM concern: the repository, issue tracker, merge request, and external tools can all contain untrusted text. That text may be interpreted as instructions by an agent rather than as data to analyze.\n\nFor SCM workflows, that means:\n\n* Limit each agent to the tools required for its task  \n* Separate read-oriented analysis from write-oriented actions where possible  \n* Restrict access to local files, credentials, and external network paths  \n* Require approval for sensitive writes and deletes  \n* Treat repository content, issue comments, merge-request descriptions, and tool outputs as untrusted input  \n* Keep secrets out of agent-visible context and prevent them from being posted into repositories or review comments\n\n\u003Cbr>\n\nA narrowly scoped reader agent and a separately permissioned writer agent may be safer than a single agent that can read arbitrary content and immediately publish changes. The exact architecture will depend on the workflow, but the principle is durable: separate the ability to interpret untrusted content from the ability to perform high-impact actions.",{"id":80},"protect-the-control-path-from-prompt-injection",{"type":61,"componentName":61,"componentContent":82},{"header":54,"text":83,"config":84},"A secure SCM program does not need to begin with maximum restriction. It should begin with visibility and a deliberate expansion of autonomy.\n\n### Start with an agent inventory\n\nList the agents, flows, IDE integrations, MCP servers, and automation jobs that can read or write source code. Record their purpose, owner, project scope, tools, credentials, and output path.\n\n### Define an action policy\n\nClassify actions as read, write, or delete, then assign the appropriate enforcement mode. Make the policy more restrictive for production repositories, security configuration, deployment definitions, secrets, and destructive operations.\n\n### Establish a governed change path\n\nRequire AI-generated code to move through branches, merge requests, pipelines, security checks, and approval rules. Do not create an exception for an agent simply because the workflow is automated.\n\n### Make provenance part of the definition of done\n\nA change is not fully governed unless the organization can connect the generated code to its initiating user, agent session, policy decisions, review record, and resulting delivery activity.\n\n### Pilot with measurable boundaries\n\nBegin with a bounded workflow, such as test generation, documentation updates, or low-risk code review. Measure adoption, review rework, policy interventions, vulnerabilities, remediation time, and rollback or revert activity before expanding the agent’s permissions.\n\n### Revisit the policy as the system changes\n\nNew models, tools, MCP servers, agent flows, and repository types can change the risk profile. Governance should be reviewed as part of the rollout lifecycle, not treated as a one-time configuration exercise.",{"id":85},"a-rollout-sequence-for-engineering-and-security-leaders",{"type":61,"componentName":61,"componentContent":87},{"header":58,"text":88,"config":89},"GitLab builds this control path into the platform that already covers software delivery from commit to production. Manual, agent-assisted, and autonomous work share one data model and security boundary, and the same policy model applies whether you run GitLab self-managed, as multi-tenant SaaS, or on GitLab Dedicated. Teams extend the governance they already apply to human contributors to agents, without adding another toolchain.\n\nTo see the architecture behind this approach and the case for source code management in the agentic era, read the [Rethinking source code management for the agentic era](https://learn.gitlab.com/whitepaper-scm/whitepaper-scm-agentic-era) whitepaper.",{"id":90},"how-gitlab-supports-a-secure-scm-control-path",{"type":92,"componentName":92,"componentContent":93},"CommonFaq",{"header":94,"groups":95},"Frequently Asked Questions",[96],{"questions":97},[98,100,103,106],{"question":38,"answer":99},"Secure SCM for AI-generated code is a source-control approach that governs agent identity, permissions, workspace isolation, provenance, review, security validation, and auditability throughout the software delivery lifecycle.",{"question":101,"answer":102},"How should AI-generated code be approved?","AI-generated code should follow the same governed change path as human-written code: isolate the work, open a merge request, run required tests and security checks, apply approval policies, and prevent merging when required evidence is missing.",{"question":104,"answer":105},"How do you trace AI-generated code?","Connect the resulting commit or merge request to the initiating user, agent or service identity, workflow, tools, policy decisions, approvals, pipeline results, and deployment record. Composite identity and audit events are examples of controls that support this traceability in GitLab.",{"question":107,"answer":108},"Why do AI agents need least-privilege permissions?","Agents can process untrusted repository and project content and may have tools that read, write, delete, or communicate externally. Limiting each agent to the smallest set of resources and actions needed for its task reduces the impact of prompt injection, misconfiguration, or unintended behavior.",{"type":110,"componentName":110},"CommonNextSteps","yml",{},true,"/en-us/topics/source-code-management/secure-scm-ai-generated-code",{"config":116,"title":38,"ogTitle":38,"description":118,"ogDescription":118},{"noIndex":117},false,"Learn how secure SCM can govern AI-generated code with identity, permissions, provenance, review, security checks, and auditability.","en-us/topics/source-code-management/secure-scm-ai-generated-code/index","pLKpuXub8ltaAjtkQnGQ7PmjCInpJS7lBG15qEMzvA4",{"logo":122,"freeTrial":127,"sales":132,"login":137,"items":142,"search":478,"minimal":510,"duo":529,"switchNav":538,"pricingDeployment":549},{"config":123},{"href":124,"dataGaName":125,"dataGaLocation":126},"/","gitlab logo","header",{"text":128,"config":129},"Get free trial",{"href":130,"dataGaName":131,"dataGaLocation":126},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com&glm_content=default-saas-trial/","free trial",{"text":133,"config":134},"Request a demo",{"href":135,"dataGaName":136,"dataGaLocation":126},"/request-a-demo/","sales",{"text":138,"config":139},"Sign in",{"href":140,"dataGaName":141,"dataGaLocation":126},"https://gitlab.com/users/sign_in/","sign in",[143,229,317,322,402,456],{"text":144,"left":113,"config":145,"menu":147},"Platform",{"dataNavLevelOne":146},"platform",{"type":148,"link":149,"columns":153,"feature":218},"lists",{"text":150,"config":151},"Explore the Platform",{"href":152,"dataGaName":146,"dataGaLocation":126},"/platform/",[154,177,200],{"title":155,"items":156},"DevOps",[157,162,167,172],{"text":158,"config":159},"CI/CD",{"href":160,"dataGaLocation":126,"dataGaName":161},"/solutions/continuous-integration/","ci/cd",{"text":163,"config":164},"Source Code Management",{"href":165,"dataGaLocation":126,"dataGaName":166},"/solutions/source-code-management/","source code management",{"text":168,"config":169},"Agile Delivery",{"href":170,"dataGaLocation":126,"dataGaName":171},"/solutions/agile-delivery/","agile delivery",{"text":173,"config":174},"Artifact Management",{"href":175,"dataGaLocation":126,"dataGaName":176},"/artifact-central/","artifact management",{"title":178,"items":179},"Security & Governance",[180,185,190,195],{"text":181,"config":182},"Application Security Testing",{"href":183,"dataGaLocation":126,"dataGaName":184},"/solutions/application-security-testing/","application security testing",{"text":186,"config":187},"Governance & Compliance",{"href":188,"dataGaLocation":126,"dataGaName":189},"/solutions/software-compliance/","governance and compliance",{"text":191,"config":192},"Secrets Management",{"href":193,"dataGaLocation":126,"dataGaName":194},"/gitlab-secrets-manager/","secrets management",{"text":196,"config":197},"Supply Chain Security",{"href":198,"dataGaLocation":126,"dataGaName":199},"/solutions/supply-chain/","supply chain security",{"title":201,"items":202},"Agentic AI & Context",[203,208,213],{"text":204,"config":205},"Duo Agent Platform",{"href":206,"dataGaLocation":126,"dataGaName":207},"/gitlab-duo-agent-platform/","duo agent platform",{"text":209,"config":210},"Orbit Context Graph",{"href":211,"dataGaLocation":126,"dataGaName":212},"/gitlab-orbit/","orbit",{"text":214,"config":215},"Visibility & Measurement",{"href":216,"dataGaLocation":126,"dataGaName":217},"/solutions/visibility-measurement/","visibility and measurement",{"config":219,"title":222,"text":223,"link":224},{"background":220,"textColor":221},"url('https://res.cloudinary.com/about-gitlab-com/image/upload/v1790185102/o7dn32anqcb6z8dgd3as.jpg')","#000","GitLab Orbit is generally available","Higher agent accuracy, lower token cost",{"text":225,"config":226},"Read the announcement",{"href":227,"dataGaName":228,"dataGaLocation":126},"/blog/gitlab-orbit-ga/","orbit ga announcement",{"text":230,"left":113,"config":231,"menu":233},"Solutions",{"dataNavLevelOne":232},"solutions",{"type":148,"link":234,"columns":238,"feature":308},{"text":235,"config":236},"View all Solutions",{"href":237,"dataGaName":232,"dataGaLocation":126},"/solutions/",[239,257,275],{"title":240,"items":241},"Outcomes",[242,247,252],{"text":243,"config":244},"DevOps Modernization",{"href":245,"dataGaLocation":126,"dataGaName":246},"/assessments/devops-modernization-assessment/","devops modernization",{"text":248,"config":249},"Security Modernization",{"href":250,"dataGaLocation":126,"dataGaName":251},"/assessments/security-modernization-assessment/","security modernization",{"text":253,"config":254},"AI Modernization",{"href":255,"dataGaLocation":126,"dataGaName":256},"/assessments/ai-modernization-assessment/","ai modernization",{"title":258,"items":259},"By size",[260,265,270],{"text":261,"config":262},"Enterprise",{"href":263,"dataGaLocation":126,"dataGaName":264},"/enterprise/","enterprise",{"text":266,"config":267},"Small Business",{"href":268,"dataGaLocation":126,"dataGaName":269},"/small-business/","small business",{"text":271,"config":272},"Startups",{"href":273,"dataGaLocation":126,"dataGaName":274},"/solutions/startups/","startups",{"title":276,"items":277},"Industries",[278,283,288,293,298,303],{"text":279,"config":280},"Financial Services",{"href":281,"dataGaLocation":126,"dataGaName":282},"/solutions/finance/","financial services",{"text":284,"config":285},"Public Sector",{"href":286,"dataGaLocation":126,"dataGaName":287},"/solutions/public-sector/","public sector",{"text":289,"config":290},"Telecommunications",{"href":291,"dataGaLocation":126,"dataGaName":292},"/solutions/telecommunications/","telecommunications",{"text":294,"config":295},"Automotive",{"href":296,"dataGaLocation":126,"dataGaName":297},"/solutions/automotive/","automotive",{"text":299,"config":300},"Education",{"href":301,"dataGaLocation":126,"dataGaName":302},"/solutions/education/","education",{"text":304,"config":305},"Aerospace",{"href":306,"dataGaLocation":126,"dataGaName":307},"/solutions/aerospace/","aerospace",{"config":309,"title":310,"text":311,"link":312},{"background":220,"textColor":221},"GitLab Security Standard","Learn how to harden your software factory and let AI agents earn autonomy, without trading away security.",{"text":313,"config":314},"Explore the standard",{"href":315,"dataGaName":316,"dataGaLocation":126},"/gitlab-security-standard/","gitlab security standard",{"text":318,"config":319},"Pricing",{"href":320,"dataGaName":321,"dataGaLocation":126,"dataNavLevelOne":321},"/pricing/","pricing",{"text":323,"config":324,"menu":326},"Resources",{"dataNavLevelOne":325},"resources",{"type":148,"link":327,"columns":331,"feature":393},{"text":328,"config":329},"View all resources",{"href":330,"dataGaName":325,"dataGaLocation":126},"/resources/",[332,365],{"title":333,"items":334},"Discover",[335,340,345,350,355,360],{"text":336,"config":337},"Docs",{"href":338,"dataGaName":339,"dataGaLocation":126},"https://docs.gitlab.com/","docs",{"text":341,"config":342},"University",{"href":343,"dataGaName":344,"dataGaLocation":126},"https://university.gitlab.com/","university",{"text":346,"config":347},"Demo Series",{"href":348,"dataGaName":349,"dataGaLocation":126},"/gitlab-technical-demo-series/","demo series",{"text":351,"config":352},"Demo Hub",{"href":353,"dataGaName":354,"dataGaLocation":126},"/demo-hub/","demo hub",{"text":356,"config":357},"Services",{"href":358,"dataGaName":359,"dataGaLocation":126},"/services/","services",{"text":361,"config":362},"Well Architected",{"href":363,"dataGaName":364,"dataGaLocation":126},"/resources/well-architected/","well architected",{"title":366,"items":367},"Connect",[368,373,378,383,388],{"text":369,"config":370},"Blog",{"href":371,"dataGaName":372,"dataGaLocation":126},"/blog/","blog",{"text":374,"config":375},"Community",{"href":376,"dataGaName":377,"dataGaLocation":126},"/community/","community",{"text":379,"config":380},"Customers",{"href":381,"dataGaName":382,"dataGaLocation":126},"/customers/","customers",{"text":384,"config":385},"Partners",{"href":386,"dataGaName":387,"dataGaLocation":126},"/partners/","partners",{"text":389,"config":390},"Events",{"href":391,"dataGaName":392,"dataGaLocation":126},"/events/","events",{"config":394,"title":395,"text":396,"link":397},{"background":220,"textColor":221},"What’s new in GitLab","Stay updated with our latest features and improvements.",{"text":398,"config":399},"Read the latest",{"href":400,"dataGaName":401,"dataGaLocation":126},"/whats-new/","whats new",{"text":403,"config":404,"menu":406},"Company",{"dataNavLevelOne":405},"company",{"type":148,"columns":407},[408],{"items":409},[410,415,421,426,431,436,441,446,451],{"text":411,"config":412},"About",{"href":413,"dataGaName":414,"dataGaLocation":126},"/company/","about",{"text":416,"config":417,"footerGa":420},"Jobs",{"href":418,"dataGaName":419,"dataGaLocation":126},"/jobs/","jobs",{"dataGaName":419},{"text":422,"config":423},"Press",{"href":424,"dataGaName":425,"dataGaLocation":126},"/press/","press",{"text":427,"config":428},"Handbook",{"href":429,"dataGaName":430,"dataGaLocation":126},"https://handbook.gitlab.com/","handbook",{"text":432,"config":433},"Leadership",{"href":434,"dataGaName":435,"dataGaLocation":126},"/company/team/e-group/","leadership",{"text":437,"config":438},"Investor relations",{"href":439,"dataGaName":440,"dataGaLocation":126},"https://ir.gitlab.com/overview/default.aspx","investor relations",{"text":442,"config":443},"Trust Center",{"href":444,"dataGaName":445,"dataGaLocation":126},"/security/","trust center",{"text":447,"config":448},"AI Transparency Center",{"href":449,"dataGaName":450,"dataGaLocation":126},"/ai-transparency-center/","ai transparency center",{"text":452,"config":453},"Newsletter",{"href":454,"dataGaName":455,"dataGaLocation":126},"/company/contact/#contact-forms","newsletter",{"text":457,"config":458,"menu":459},"Contact us",{"dataNavLevelOne":405},{"type":148,"columns":460},[461],{"items":462},[463,468,473],{"text":464,"config":465},"Talk to sales",{"href":466,"dataGaName":467,"dataGaLocation":126},"/sales/","talk to sales",{"text":469,"config":470},"Support portal",{"href":471,"dataGaName":472,"dataGaLocation":126},"https://support.gitlab.com/hc/en-us","support portal",{"text":474,"config":475},"Customer portal",{"href":476,"dataGaName":477,"dataGaLocation":126},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":479,"login":480,"suggestions":487},"Close",{"text":481,"link":482},"To search repositories and projects, login to",{"text":483,"config":484},"gitlab.com",{"href":140,"dataGaName":485,"dataGaLocation":486},"search login","search",{"text":488,"default":489},"Suggestions",[490,493,496,498,502,506],{"text":491,"config":492},"GitLab Duo Agent Platform",{"href":206,"dataGaName":491,"dataGaLocation":486},{"text":494,"config":495},"Code Suggestions (AI)",{"href":206,"dataGaName":494,"dataGaLocation":486},{"text":158,"config":497},{"href":160,"dataGaName":158,"dataGaLocation":486},{"text":499,"config":500},"GitLab on AWS",{"href":501,"dataGaName":499,"dataGaLocation":486},"/partners/technology-partners/aws/",{"text":503,"config":504},"GitLab on Google Cloud",{"href":505,"dataGaName":503,"dataGaLocation":486},"/partners/technology-partners/google-cloud-platform/",{"text":507,"config":508},"Why GitLab?",{"href":509,"dataGaName":507,"dataGaLocation":486},"/why-gitlab/",{"freeTrial":511,"mobileIcon":516,"desktopIcon":521,"secondaryButton":524},{"text":512,"config":513},"Start free trial",{"href":514,"dataGaName":131,"dataGaLocation":515},"https://gitlab.com/-/trials/new/","nav",{"altText":517,"config":518},"Gitlab Icon",{"src":519,"dataGaName":520,"dataGaLocation":515},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":517,"config":522},{"src":523,"dataGaName":520,"dataGaLocation":515},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"text":525,"config":526},"Get Started",{"href":527,"dataGaName":528,"dataGaLocation":515},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/get-started/","get started",{"freeTrial":530,"mobileIcon":534,"desktopIcon":536},{"text":531,"config":532},"Learn more about GitLab Duo",{"href":206,"dataGaName":533,"dataGaLocation":515},"gitlab duo",{"altText":517,"config":535},{"src":519,"dataGaName":520,"dataGaLocation":515},{"altText":517,"config":537},{"src":523,"dataGaName":520,"dataGaLocation":515},{"button":539,"mobileIcon":544,"desktopIcon":546},{"text":540,"config":541},"/switch",{"href":542,"dataGaName":543,"dataGaLocation":515},"#contact","switch",{"altText":517,"config":545},{"src":519,"dataGaName":520,"dataGaLocation":515},{"altText":517,"config":547},{"src":548,"dataGaName":520,"dataGaLocation":515},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1773335277/ohhpiuoxoldryzrnhfrh.png",{"freeTrial":550,"mobileIcon":555,"desktopIcon":557},{"text":551,"config":552},"Back to pricing",{"href":320,"dataGaName":553,"dataGaLocation":515,"icon":554},"back to pricing","GoBack",{"altText":517,"config":556},{"src":519,"dataGaName":520,"dataGaLocation":515},{"altText":517,"config":558},{"src":523,"dataGaName":520,"dataGaLocation":515},{"title":560,"button":561,"config":565},"GitLab Orbit is generally available. Increase agent accuracy and lower token cost",{"text":225,"config":562},{"href":227,"dataGaName":563,"dataGaLocation":564},"orbit-ga-banner","global-banner",{"layout":566,"disabled":117},"release",{"data":568},{"text":569,"config":570,"items":575,"minimal":802},"Git is a trademark of Software Freedom Conservancy and our use of 'GitLab' is under license",{"twitter":571,"facebook":572,"youtube":573,"linkedin":574},"https://twitter.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[576,624,682,729,770],{"title":318,"links":577,"subMenu":593},[578,583,588],{"text":579,"config":580},"View plans",{"href":320,"dataGaName":581,"dataGaLocation":582},"view plans","footer",{"text":584,"config":585},"Why Premium?",{"href":586,"dataGaName":587,"dataGaLocation":582},"/pricing/premium/","why premium",{"text":589,"config":590},"Why Ultimate?",{"href":591,"dataGaName":592,"dataGaLocation":582},"/pricing/ultimate/","why ultimate",[594],{"title":595,"links":596},"Contact Us",[597,600,602,604,609,614,619],{"text":598,"config":599},"Contact sales",{"href":466,"dataGaName":136,"dataGaLocation":582},{"text":469,"config":601},{"href":471,"dataGaName":472,"dataGaLocation":582},{"text":474,"config":603},{"href":476,"dataGaName":477,"dataGaLocation":582},{"text":605,"config":606},"Status",{"href":607,"dataGaName":608,"dataGaLocation":582},"https://status.gitlab.com/","status",{"text":610,"config":611},"Terms of use",{"href":612,"dataGaName":613,"dataGaLocation":582},"/terms/","terms of use",{"text":615,"config":616},"Privacy statement",{"href":617,"dataGaName":618,"dataGaLocation":582},"/privacy/","privacy statement",{"text":620,"config":621},"Cookie preferences",{"dataGaName":622,"dataGaLocation":582,"id":623,"isOneTrustButton":113},"cookie preferences","ot-sdk-btn",{"title":144,"links":625,"subMenu":641},[626,629,631,633,635,637],{"text":627,"config":628},"Explore the platform",{"href":152,"dataGaName":146,"dataGaLocation":582},{"text":204,"config":630},{"href":206,"dataGaName":207,"dataGaLocation":582},{"text":158,"config":632},{"href":160,"dataGaName":161,"dataGaLocation":582},{"text":209,"config":634},{"href":211,"dataGaName":212,"dataGaLocation":582},{"text":191,"config":636},{"href":193,"dataGaName":194,"dataGaLocation":582},{"text":638,"config":639},"Why GitLab",{"href":509,"dataGaName":640,"dataGaLocation":582},"why gitlab",[642],{"title":13,"links":643},[644,648,653,657,662,667,672,677],{"text":158,"config":645},{"href":646,"dataGaName":647,"dataGaLocation":582},"/topics/ci-cd/","cicd",{"text":649,"config":650},"GitOps",{"href":651,"dataGaName":652,"dataGaLocation":582},"/topics/gitops/","gitops",{"text":155,"config":654},{"href":655,"dataGaName":656,"dataGaLocation":582},"/topics/devops/","devops",{"text":658,"config":659},"Version Control",{"href":660,"dataGaName":661,"dataGaLocation":582},"/topics/version-control/","version control",{"text":663,"config":664},"DevSecOps",{"href":665,"dataGaName":666,"dataGaLocation":582},"/topics/devsecops/","devsecops",{"text":668,"config":669},"Cloud Native",{"href":670,"dataGaName":671,"dataGaLocation":582},"/topics/cloud-native/","cloud native",{"text":673,"config":674},"AI for Coding",{"href":675,"dataGaName":676,"dataGaLocation":582},"/topics/devops/ai-for-coding/","ai for coding",{"text":678,"config":679},"Agentic AI",{"href":680,"dataGaName":681,"dataGaLocation":582},"/topics/agentic-ai/","agentic ai",{"title":230,"links":683},[684,687,690,693,696,699,701,703,705,707,709,712,714,717,721,725],{"text":685,"config":686},"DevOps modernization",{"href":245,"dataGaName":246,"dataGaLocation":582},{"text":688,"config":689},"Security modernization",{"href":250,"dataGaName":251,"dataGaLocation":582},{"text":691,"config":692},"AI modernization",{"href":255,"dataGaName":256,"dataGaLocation":582},{"text":694,"config":695},"Financial services",{"href":281,"dataGaName":282,"dataGaLocation":582},{"text":697,"config":698},"Public sector",{"href":286,"dataGaName":287,"dataGaLocation":582},{"text":289,"config":700},{"href":291,"dataGaName":292,"dataGaLocation":582},{"text":294,"config":702},{"href":296,"dataGaName":297,"dataGaLocation":582},{"text":299,"config":704},{"href":301,"dataGaName":302,"dataGaLocation":582},{"text":304,"config":706},{"href":306,"dataGaName":307,"dataGaLocation":582},{"text":261,"config":708},{"href":263,"dataGaName":264,"dataGaLocation":582},{"text":710,"config":711},"Small business",{"href":268,"dataGaName":269,"dataGaLocation":582},{"text":271,"config":713},{"href":273,"dataGaName":274,"dataGaLocation":582},{"text":649,"config":715},{"href":716,"dataGaName":652,"dataGaLocation":582},"/solutions/gitops/",{"text":718,"config":719},"Software composition analysis",{"href":198,"dataGaName":720,"dataGaLocation":582},"software composition analysis",{"text":722,"config":723},"Value stream management",{"href":216,"dataGaName":724,"dataGaLocation":582},"value stream management",{"text":726,"config":727},"All solutions",{"href":237,"dataGaName":728,"dataGaLocation":582},"all solutions",{"title":323,"links":730},[731,736,741,743,745,747,749,751,753,755,757,759,761,763,766],{"text":732,"config":733},"Install",{"href":734,"dataGaName":735,"dataGaLocation":582},"/install/","install",{"text":737,"config":738},"Quick start guides",{"href":739,"dataGaName":740,"dataGaLocation":582},"/get-started/","quick setup checklists",{"text":336,"config":742},{"href":338,"dataGaName":339,"dataGaLocation":582},{"text":341,"config":744},{"href":343,"dataGaName":344,"dataGaLocation":582},{"text":346,"config":746},{"href":348,"dataGaName":349,"dataGaLocation":582},{"text":351,"config":748},{"href":353,"dataGaName":354,"dataGaLocation":582},{"text":356,"config":750},{"href":358,"dataGaName":359,"dataGaLocation":582},{"text":369,"config":752},{"href":371,"dataGaName":372,"dataGaLocation":582},{"text":374,"config":754},{"href":376,"dataGaName":377,"dataGaLocation":582},{"text":379,"config":756},{"href":381,"dataGaName":382,"dataGaLocation":582},{"text":384,"config":758},{"href":386,"dataGaName":387,"dataGaLocation":582},{"text":389,"config":760},{"href":391,"dataGaName":392,"dataGaLocation":582},{"text":452,"config":762},{"href":454,"dataGaName":455,"dataGaLocation":582},{"text":764,"config":765},"What's new",{"href":400,"dataGaName":401,"dataGaLocation":582},{"text":767,"config":768},"All resources",{"href":330,"dataGaName":769,"dataGaLocation":582},"all resources",{"title":403,"links":771},[772,774,776,778,780,782,784,786,788,792,797],{"text":411,"config":773},{"href":413,"dataGaName":405,"dataGaLocation":582},{"text":416,"config":775},{"href":418,"dataGaName":419,"dataGaLocation":582},{"text":422,"config":777},{"href":424,"dataGaName":425,"dataGaLocation":582},{"text":427,"config":779},{"href":429,"dataGaName":430,"dataGaLocation":582},{"text":432,"config":781},{"href":434,"dataGaName":435,"dataGaLocation":582},{"text":437,"config":783},{"href":439,"dataGaName":440,"dataGaLocation":582},{"text":442,"config":785},{"href":444,"dataGaName":445,"dataGaLocation":582},{"text":447,"config":787},{"href":449,"dataGaName":450,"dataGaLocation":582},{"text":789,"config":790},"Sustainability",{"href":791,"dataGaName":789,"dataGaLocation":582},"/sustainability/",{"text":793,"config":794},"Diversity, inclusion and belonging (DIB)",{"href":795,"dataGaName":796,"dataGaLocation":582},"/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":798,"config":799},"Modern Slavery Transparency Statement",{"href":800,"dataGaName":801,"dataGaLocation":582},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"items":803},[804,807,810],{"text":805,"config":806},"Terms",{"href":612,"dataGaName":613,"dataGaLocation":582},{"text":808,"config":809},"Cookies",{"dataGaName":622,"dataGaLocation":582,"id":623,"isOneTrustButton":113},{"text":811,"config":812},"Privacy",{"href":617,"dataGaName":618,"dataGaLocation":582},{"header":814,"blurb":815,"button":816,"secondaryButton":821},"Start building faster today","See what your team can do with the intelligent orchestration platform for DevSecOps.\n",{"text":817,"config":818},"Get your free trial",{"href":819,"dataGaName":131,"dataGaLocation":820},"https://gitlab.com/-/trial_registrations/new?glm_content=default-saas-trial&glm_source=about.gitlab.com/","feature",{"text":598,"config":822},{"href":466,"dataGaName":136,"dataGaLocation":820},1795221696589]