Agents are good at writing code. They're far worse at navigating the system around it: the related code, the pipelines that run it, the deployments that ship it, the work items that asked for it, and the teams that own it. That gap is where AI-assisted engineering breaks down today.

In a large monorepo, the gap shows up as wasted iterations, blown token budgets, and code that looks correct but gets reverted. Across repos, it's worse: the context window fills before the agent finds the answer, and the task fails outright. Teams end up spending more time fixing agent output than the agent saved them.

GitLab Orbit, now in public beta, closes the gap. It's a live, queryable graph of all your code, merge requests, pipelines, deployments, vulnerabilities, and ownership, with every relationship between them kept current as your team works. Agents reason from first-party GitLab data instead of stitched-together tool calls. Engineers can query the same graph through the Data Explorer to trace changes, investigate incidents, and answer the cross-system questions that today take hours of manual reconstruction.

Proven on real merge requests at Compare the Market

Compare the Market, a U.K. price comparison platform, tested four context retrieval approaches for an internal AI code reviewer across 79 real merge requests. The Orbit-grounded reviewer placed accurate inline comments about 70% of the time, against about 58% for retrieval-augmented generation (RAG), and captured more of the key changes in summaries (68% vs. 66%). RAG underperformed every other approach, including no context at all.

"Orbit gave us an AI code reviewer that actually understands our codebase, not just the diff in front of it. We tested it against RAG and a few other approaches across real merge requests, and the gap was clear. Better comment placement, better summaries of what actually changed. RAG, which we'd assumed would be the natural solution, ended up performing worse than no context at all. For us, that result spoke for itself."
- Ryan Harvey, Head of AI Engineering, Compare the Market

What you can do with GitLab Orbit

Here are two examples of how you can use GitLab Orbit in your environment.

Scenario 1: With Claude Code or other coding agents
The work you already do, faster and more accurate

Say, you already run Claude Code. When you point it at a large monorepo, it spends its first stretch, and a real share of its token budget, just crawling files to work out where things live and what connects to what. In a big enough codebase it follows the wrong threads, misses a dependency, or runs out of room before it starts the actual work.

Connect Claude Code to GitLab Orbit through Model Context Protocol (MCP) and it stops crawling. It asks the graph the questions it was trying to reconstruct by iterating where does this code live, what depends on it, which tests and pipelines cover it. Instead, it gets a precise answer in one or two queries. On the same tasks, with the same model, it’s up to 11 times faster, uses up to 4.5 times fewer tokens, and generates up to 45 times fewer hallucinations.

Scenario 2: With GitLab Duo Agent Platform
Answers that were never possible before

Some questions were never really answerable by an agent, because the answer isn't in the code — it's in how code connects to pipelines, deployments, vulnerabilities, and ownership across your whole system. Agents on GitLab Duo Agent Platform query Orbit natively, so you can now ask them things that used to mean a manual investigation across four tools.

Triage pipeline failures across the lifecycle. Today, an agent looking at a failing pipeline sees one job in isolation. With Orbit, it traces the failure to the change that introduced it, the projects where the same job is now drifting, and the merge requests still in flight that will encounter the same problem. To run discovery, Orbit issues graph queries like this one:

      MATCH (job:CiJob {status: "failed", name: $job_name})-[:RAN_IN]->(pipeline)-[:FOR]->(mr:MergeRequest)
RETURN mr.title, mr.author, pipeline.started_at, mr.project_id
ORDER BY pipeline.started_at DESC LIMIT 20

    

One query, every in-flight MR that will hit the same failing job, across every project in your group. Your on-call team resolves the incident once instead of three teams resolving it three separate times.

Map vulnerability blast radius in minutes. Finding the vulnerable code is the easy part. Mapping the exposure (which services include the component, which pipelines build them, which environments they run in, which teams own them) is what slows teams down. One Orbit query returns the full graph, owner-by-owner. Security ships a remediation plan in the hour a CVE lands, not the week after, with each affected component already assigned to its owner.

Answer cross-system questions on demand. Cycle time by team, broken down by pipeline failure rate, joined to deployment frequency. One question, one answer, no dashboard request, no custom SQL. Engineering managers answer the question live in the executive review, not in a Slack follow-up three days later.

Scope migrations against current dependencies. Planning a migration today means searching for a shared component and hoping the search catches the downstream dependencies. With Orbit, every dependent service, job, environment, and owner returns in a single result. Platform teams commit to a migration date and meet it, instead of discovering hidden dependents three weeks in.

The graph supports any workflow where your team needs to understand how the system connects: code review, incident response, release planning, security, migration planning.

How GitLab Orbit works

Orbit ingests software development lifecycle data via change-data-capture into ClickHouse, parses code in 12 languages (Ruby, Java, Kotlin, Python, TypeScript, JavaScript, Rust, Go, C#, C, C++, PHP) through the Rails internal API, and serves the combined graph over a Cypher-like DSL, MCP, REST, and the GitLab CLI.

At GitLab's own scale, the indexer covers over 40,000 projects, 500 million nodes, and 2 billion edges in under 45 minutes. An event-driven engine picks up every change as it ships, so the graph stays current.

Indexing runs as a separate service; query traffic never hits your GitLab instance. Authorization mirrors GitLab permissions, so agents see exactly what their user can see in the UI. The query engine is built like a compiler: Every query goes through validation, planning, optimization, and security passes before it touches the database, so query speed doesn't degrade as your data grows.

There is no separate data infrastructure to stand up. Orbit builds on data GitLab already captures: issues, merge requests, pipelines, code, security findings, deployments, and incidents. You get value from day one with no new instrumentation.

Agents on GitLab Duo Agent Platform query the graph natively. External agents like Claude Code, Codex, and OpenCode connect through MCP and the GitLab CLI. Custom agents and internal tooling connect through REST. One graph, shared across your engineering organization.

Engineers query the same graph

The Data Explorer is the engineer-facing surface. Same graph, no agent in the way. Useful for the work that doesn't fit a fixed prompt: investigating an incident, tracing how a dependency spreads across services, figuring out why one area of the codebase keeps breaking CI. The answers come in seconds instead of hours of reconstruction across Git, CI, deploy tools, and dashboards.

GitLab Orbit Data Explorer

Try Orbit now

GitLab Orbit is currently available in public beta for GitLab.com Premium and Ultimate customers. You can sign up by heading to about.gitlab.com/gitlab-orbit.