Most AI coding agents have a memory problem. You ask someone to fix a bug. It reads the file. It makes a change. But it has no idea what that file connects to. It does not know which pipeline runs it. It does not know which deployment depends on it. So it guesses. It burns tokens reconstructing the context it should have had from the start. GitLab just fixed that. At its Transcend 2026 conference on June 10, 2026, GitLab launched GitLab Orbit – a context graph that connects code, work items, pipelines, deployments, and production signals into one queryable layer.
GitLab Orbit gives every AI agent full lifecycle context, not just the files sitting in its immediate view. This guide breaks down what GitLab Orbit actually does, the real performance numbers behind it, and how it changes the way GitLab AI developer tools work inside real development teams.
The Problem Every AI Coding Agent Was Facing
Why Agents Without Full Context Keep Failing
Here is the core issue. In large monorepos and multi-repository environments, agents without full lifecycle context can over-iterate, burn tokens reconstructing what they cannot see, and fail outright as context windows fill. So an agent working on one file does not automatically know how that file connects to a pipeline, a deployment, or a related work item somewhere else in the system. This gap is exactly what newer GitLab AI developer tools were built to close.
This is not a small inconvenience. It is the reason agentic coding tools often feel unreliable at scale. A small task can balloon into dozens of tool calls just to figure out what the agent should have known from the start. So teams pay more, wait longer, and get less consistent results – exactly the opposite of what agentic tooling promised.
Furthermore, Git itself was never built for this kind of work. Git was designed for human-speed operations. Agents cloning entire repositories to read or change files create a bottleneck that compounds at scale, leading some AI labs to build custom systems around their existing Git providers just to keep workflows running. So the problem went beyond a single tool. It touched the entire infrastructure underneath modern software development.
GitLab Orbit – What It Actually Is
A Context Graph for the Whole Software Lifecycle
GitLab Orbit is the lifecycle context graph for software engineering. It connects your code, merge requests, pipelines, and deployments into one continuously updated and queryable graph, so every agent can reason across your full software lifecycle rather than just the files in its immediate context.
So instead of an agent guessing at relationships between parts of your system, GitLab Orbit gives it a direct map. Duo agents query Orbit automatically, and those queries are zero-rated – meaning teams are not charged extra for the context lookups that make agents smarter. Moreover, GitLab Orbit also runs as a standalone data product with open APIs, making the same context layer available to third-party agents and external tools, not just GitLab’s own products.
Here is what the graph specifically maps:
- Code repositories – The structure and relationships across your codebase.
- Work items – Issues, tasks, and planning data linked to the code they affect.
- Pipelines – CI/CD jobs and their connection to specific changes.
- Deployments – What shipped, when, and to which environment.
- Production signals – Real-world data that ties code changes back to system behaviour.
So GitLab Orbit is not a search index. It is a connected map that lets the broader set of GitLab AI developer tools answer questions a flat file system never could.
The Numbers GitLab Is Reporting
GitLab Orbit, now in public beta, is a context graph for the entire software lifecycle that enables agents to deliver 11x faster responses requiring up to 4.5x fewer tokens. Furthermore, that capability is crucial in the age of AI because it reduces the number of tokens that would otherwise need to be consumed to complete each task.
So the gain is not just speed. It is costly. Fewer tokens per task mean lower bills for every team running these GitLab AI developer tools at volume. Consequently, GitLab Orbit changes the economics of running AI agents across a large codebase, not just the raw response time.
How GitLab Orbit Fits Into GitLab Duo Agent Platform
The Relationship Between Orbit and the Agents That Use It
GitLab Orbit is the lifecycle context graph that natively supports GitLab Duo Agent Platform and your software development agents. It is designed to make your agents faster, smarter, and more cost-effective. It connects your code, pipelines, and deployments as a grounded context for every agent.
So Orbit is not a standalone product sitting on the side. It is the foundation underneath every one of GitLab’s GitLab AI developer tools. Here is how the relationship works:
- Agents are orchestrated by software team members – To automate tasks across the software development lifecycle
- Flows combine one or more agents – Into guided sequences that automate manual steps while reinforcing organisational patterns
- Each agent uses GitLab context to deliver precise, relevant results – Supported directly by the GitLab Orbit graph underneath
- External agents can be integrated – Including Claude Code and Codex, connecting through GitLab workflows using the same context layer
- An AI Catalogue gives teams a centralised place – To explore, activate, and manage agents and flows across projects and groups
So whether a team uses GitLab’s own specialised agents – for planning, coding, security analysis, or analytics – or brings in an external tool, GitLab Orbit is the shared context layer underneath all of it.
AI coding agents and the Infrastructure They Actually Need
Why Context Alone Was Not Enough
Speed and context matter. But GitLab also rebuilt the underlying Git infrastructure alongside Orbit because AI coding agents were straining the old system differently. Next Generation Source Code Management, now in private beta, lets agents query the repository server-side for exactly what each task requires, with each agent limited to the minimum visibility its task needs.
So instead of cloning a full repository just to make a small change, AI coding agents can now ask for precisely what they need. Agents complete tasks up to 50x faster, consume up to two times fewer tokens, and generate up to 1000x less network traffic. Furthermore, this matters at scale. A single agent making this kind of request is manageable. Hundreds of agents doing it across a large engineering org is a different problem entirely – and one that traditional Git infrastructure was never built to handle.
Here is what changes for AI coding agents under this new architecture:
- Server-side queries – Agents request exactly what a task needs, not the entire repository
- Scoped visibility – Each agent only sees what its specific task requires
- Reduced network load – Up to 1000x less traffic generated per task
- Faster task completion – Up to 50x speed improvement on supported workflows
So the combination of GitLab Orbit for context and the new Git architecture for access creates a foundation built specifically for how AI coding agents actually operate – not how human developers used Git for the past two decades.
Governance – Keeping Agent Activity Accountable
Why Speed Alone Was Not the Whole Story
Faster agents create a new problem. Agents move faster than the controls around them. Acting by the hundreds, they push code, touch dependencies, and trigger deployments faster than teams can govern. That pace can break the chain of custody, with teams losing track of which agent acted, under which policy, and who approved it.
So GitLab paired Orbit with a governance layer. Governance for Agents, now in private beta, adds new AI auditing and control capabilities to meet compliance requirements. DevSecOps teams are now provided with real-time visibility into agent inputs, reasoning, tool calls, and anomalous patterns across the organization.
Here is what that governance framework covers:
- Identity for every agent action – each action gets an assigned identity and audit record
- Policy paths – clear rules for which agents can operate where, and under what conditions
- Real-time visibility – DevSecOps teams see agent reasoning and tool calls as they happen
- Anomaly detection – unusual agent behaviour gets flagged across the organization
- Self-hosted compliance options – Self-Managed deployments can utilise self-hosted large language models in alignment with compliance requirements
So GitLab Orbit does not just make agents faster. The governance layer built around it makes that speed something organizations can actually trust and audit.
What This Means for Engineering Teams Right Now
Practical Steps for Teams Evaluating Orbit
GitLab Orbit is currently in public beta. Teams already running GitLab Duo Agent Platform can connect agents to the context graph today, while teams evaluating external tools can explore the open API to bring third-party agents into the same context layer.
So what should engineering leaders actually do with this? Monitor the public beta and available benchmarks to validate the reported performance figures in your own environment. Track how the AI Governance private beta evolves, particularly whether agent audit trails include deterministic tool-call logs and verifiable provenance for generated code.
Furthermore, GitLab is also rolling out GitLab Flex for its GitLab AI developer tools lineup – a licensing option that combines seats and AI credits in a single annual commitment, letting teams shift spend as needs change without renegotiating contracts. So budgeting for AI coding agents at scale becomes more predictable, not less, as adoption grows.
Why Choose Working Not Working?
At Working Not Working, we connect serious technical and creative professionals with work that matches their actual skills.
The developers and technical leads in our network do not wait for a tool to become mainstream before they understand what it changes.
They are already exploring what GitLab Orbit means for agentic engineering, testing AI coding agents against real production workloads, and adjusting how their teams build software. We do not just list jobs.
We connect people who move early with briefs that need exactly that kind of judgment.
Conclusion
GitLab Orbit solves a real and overdue problem in agentic software development – agents that operate blind to the systems around them. By connecting code, pipelines, deployments, and production signals into one queryable graph, GitLab gives every agent the lifecycle context it needs to work reliably at scale. Faster responses. Fewer tokens. A governance layer that keeps fast-moving agents accountable.
For any team running serious agentic workflows, GitLab Orbit is worth evaluating now, not after the public beta closes. Want to apply or have a query? Reach out to Working Not Working on WhatsApp and follow us on LinkedIn and Facebook.
Frequently Asked Questions
Q1. What is GitLab Orbit and when was it launched?
GitLab Orbit is a lifecycle context graph for software engineering, launched in public beta at GitLab’s Transcend 2026 conference on June 10, 2026. It connects code, merge requests, pipelines, deployments, and production signals into one continuously updated graph that AI agents can query for full context.
Q2. How much faster do agents perform with GitLab Orbit?
According to GitLab, GitLab Orbit enables agents to deliver 11 times faster responses while requiring up to 4.5 times fewer tokens compared to traditional approaches. These figures come from GitLab’s own reporting during the public beta and should be validated against real workloads as adoption grows.
Q3. How does GitLab Orbit relate to GitLab AI developer tools like Duo Agent Platform?
GitLab Orbit is the context graph that natively supports the broader set of GitLab AI developer tools, including GitLab Duo Agent Platform. These GitLab AI developer tools all query the same graph. Duo agents query Orbit automatically at no extra token cost, and the graph also exposes open APIs so external agents can use the same context layer.
Q4. Can external AI coding agents use GitLab Orbit?
Yes. GitLab Orbit also runs as a standalone data product with open APIs, making the same context layer available to third-party agents and external tools – including integrations with tools like Claude Code and Codex inside GitLab workflows, not just GitLab’s own native agents.
Q5. What governance controls exist for agents using GitLab Orbit?
GitLab pairs Orbit with Governance for Agents, now in private beta, which assigns identity, policy paths, and audit records to every agent action. DevSecOps teams get real-time visibility into agent inputs, reasoning, and tool calls, helping organizations keep fast-moving AI coding agents accountable and compliant.
