On June 10, 2026, GitLab used its Transcend event to preview a platform reshaped around agent-driven delivery. The pieces that matter aren't a new model — they are infrastructure: a context graph called Orbit, an AI Governance framework, and a re-architected source-code layer. The common theme is worth naming directly: the bottleneck for coding agents has shifted from reasoning to context and control.
The real failure mode of coding agents is missing context
A capable model still produces wrong answers when it can't see the whole picture. An agent fixing a bug needs to know which pipeline last failed, which work item describes the intended behavior, and which deployment is live in production. Stitch that together from scattered tools and you get the familiar problem: confident output built on partial information.
GitLab's answer, Orbit (public beta), maps code, work items, pipelines, deployments, and production signals into a single context graph spanning the software lifecycle. Both engineers and agents query it as one source of truth. GitLab's reported figures are striking: agents using Orbit responded up to 11x faster, used up to 4.5x fewer tokens, and produced up to 45x fewer hallucinations.
Treat vendor benchmarks with healthy skepticism. But the direction aligns with what we see in practice — most agent failures we debug are not reasoning failures, they are context failures. A graph that resolves "what is true about this system right now" attacks the actual problem.
Without a context graph:
agent → guesses from the open file → patches a symptom
With Orbit-style context:
agent → queries graph: failing pipeline #4821, linked to issue #233
(expected: idempotent retry), last deploy = v2.7.1
→ patches the root cause, consistent with intended behaviorGovernance: agents need identity, not just access
The second piece answers a question every team adopting agents eventually hits: who did what, and were they allowed to? GitLab's AI Governance framework (private beta) assigns each agent action an identity, a policy path, and an audit record. DevSecOps teams get real-time visibility into agent inputs, reasoning, tool calls, and anomalous patterns.
This is the unglamorous prerequisite for running agents at scale. The moment an autonomous process can open merge requests, touch pipelines, or trigger deployments, "an AI did it" is not an acceptable audit answer. Every action needs an actor, a permitted scope, and a trail. We have told clients for the past year: do not grant an agent more than you would grant a junior contractor on day one. A framework that enforces identity and policy per action makes that principle operational instead of aspirational.
Why the source layer got rebuilt
The third announcement is easy to overlook: a next-generation source-code management implementation, based on a distributed architecture, that GitLab says lets agents complete tasks up to 50x faster (private beta). The reasoning is straightforward — when humans drove Git, latency per operation was lost in human think-time. When agents drive it, performing hundreds of operations per minute, the underlying Git layer becomes the bottleneck. Re-architecting the protocol for machine-speed access is the unglamorous infrastructure work that agent-scale delivery requires.
What this means even if you never adopt GitLab
The specific products matter less than the pattern they confirm. If you are integrating AI agents into your delivery process, three things are becoming non-negotiable:
- A unified context layer. Agents reason badly over fragmented information. Whether through a vendor graph or your own consolidation, give the agent one queryable answer to "what is true about this system."
- Per-action identity and audit. Agent actions need the same accountability as human ones. Plan the audit trail before you grant write access, not after the first incident.
- Infrastructure built for machine speed. Tools tuned for human cadence become bottlenecks under agent load. Expect to revisit assumptions baked in when humans were the only operators.
Our recommendation
For teams piloting agentic delivery, we suggest a deliberate sequence. First, establish the audit and identity layer — even a lightweight one — so that every agent action is attributable from day one. Second, invest in context consolidation before expanding agent autonomy; an agent with broad permissions and poor context is the worst of both worlds. Only then widen the scope of what agents may do unattended.
The lesson from Transcend is that the frontier of agentic engineering is no longer model quality alone. It is the surrounding system — shared context, enforced governance, and infrastructure that keeps up. Those are exactly the layers teams tend to underinvest in, and exactly where the next wave of reliability problems will surface.
Sources: GitLab: Built for the agentic engineering era, GitLab Announces New Capabilities at Agentic Scale — VMblog, GitLab Previews Revamped DevOps Platform — DevOps.com