More Software Engineering Daily episodes

GitLab and the Evolution of DevSecOps thumbnail

GitLab and the Evolution of DevSecOps

Published 10 Nov 2026

Duration: 56:11

GitLab integrates AI agents into the full software lifecycle using a knowledge graph and composite identity to ensure enterprise-grade governance and auditability.

Episode Description

AI coding agents can already reach well beyond the code in front of them. Through connections to tools like Slack, Jira, and Sentry, an agent can pull...

Overview

GitLab is positioning its platform as the foundation for AI agents across the full software development lifecycle, arguing that agents are most useful when they draw on the complete context of a project - issues, discussions, builds, deployments, and observability data - while remaining under enterprise governance and audit controls. Tim Zalman, VP of Engineering at GitLab, explains that the company's wide view of everything around the code shapes how it approaches the agent era, distinguishing its approach from point tools bolted onto a single repository.

The discussion covers GitLab's agent platform (Duo), which combines agentic steps with deterministic ones in custom flows triggered by events like issue status changes or pipeline failures; Orbit, a knowledge graph in beta that indexes all platform data and references to let agents traverse relationships across repositories; a dedicated AI gateway supporting self-managed and air-gapped deployments; and a composite identity model that tracks which human initiated an agent's autonomous work.

Zalman also addresses the realities of supporting air-gapped customers who may run versions years old, the competitive pressure as companies like Cursor move into code hosting, and how GitLab flattened its organization a year and a half ago to move faster in the AI space.

What If

  • What if you built a reference graph for your codebase so your AI agent could query cross-file dependencies directly instead of brute-forcing searches?

    • Move: Index your project's function references, imports, and component usage into a queryable graph, then give your agent access to write queries against it.
    • Why Now? Agents "have the tendency to be very happy if they find something and then be like, oh, I found something. I should be done to some extent", missing other references in large codebases.
    • Expected Upside: (Possibility) Your agent could answer "where is this function used across my project?" in seconds rather than minutes of file traversal, reducing missed references.
  • What if you structured your CI/CD automation to separate deterministic steps from agentic ones?

    • Move: Run linting, tests, and other binary-outcome tasks as deterministic pipeline steps, reserving agent calls only for ambiguous work like diagnosing and fixing a failing test.
    • Why Now? Deterministic steps have "the outcome is binary, which is, I think, very important in the AI space" and are "much cheaper than having an agent try to figure out something".
    • Expected Upside: (Possibility) You could reduce agent token costs and error surface while maintaining reliability on the parts that do not need reasoning.
  • What if you logged a composite identity for every autonomous task you hand to an AI agent?

    • Move: Record both your user identity and the agent's service account for each task, plus every tool call and approval in a session log, so the full chain is auditable.
    • Why Now? As agents take on more autonomous work, "we want to know and understand at a later point" who initiated what, and you need to track "which human is behind an agent's actions".
    • Expected Upside: (Possibility) You could audit months later exactly which human, which model, and which sequence of tool calls produced a given code change, supporting compliance and debugging.

Takeaway

  • Structure your AI agent workflows to pair deterministic steps (linting, tests) with agentic steps, since deterministic steps have binary outcomes and cost less than having an agent figure out how to run them.
  • Build a reference graph of your codebase's cross-file and cross-repo dependencies so your agent can query relationships directly instead of brute-forcing file searches.
  • Record a composite identity (your user plus the agent's service account) for every autonomous task so you can trace back who initiated what, months later.
  • If you run self-managed infrastructure, deploy your own AI gateway on-premise to avoid routing from your instance to a cloud gateway and back to your model.
  • Minimize breaking changes in your software releases and announce them well in advance, since self-managed and air-gapped customers may not upgrade for months or years.

Recent Episodes of Software Engineering Daily

6 Oct 2026 Security in the Age of Instant Exploits

"AI is transforming cybersecurity, accelerating both attacks and defenses, with defenders potentially gaining an edge through contextual insights and automation, while proactive measures and collaboration are key to mitigating risks."

1 Oct 2026 The State of Browser Testing

"Automated browser testing's evolution, challenges, and future are explored, highlighting cross-browser tooling, WebDriver advancements, AI's impact, and the need for human oversight in software reliability."

29 Sept 2026 Cory Doctorow on AI, Work, and Power

"Examines AI's impact on labor, contrasting human-AI collaboration with exploitative automation, while addressing corporate incentives, job losses, unionization struggles, data privacy, and the need for ethical AI adoption to prevent inequality."

24 Sept 2026 Chroma and Agentic Retrieval

"Explores AI data retrieval advancements, ChromaDB's solutions for scalable vector search, subagent efficiency, open-source benefits, and future AI-driven product trends like BYOC deployment."

10 Sept 2026 A Rust Framework to Simplify Distributed Systems

"Explores distributed software challenges, database solutions, programming paradigms, AWS's Hydro framework, CAP/CALM theorems, Rust vs. JVM, LLM impacts, and research-to-production hurdles, with insights on mentorship and creativity in CS."

More Software Engineering Daily episodes