GitLab Layoffs Betting on AI Agents: Using Agents to Automate and Rebuild Internal Processes

In an internal memo on May 11, GitLab CEO Bill Staples announced a layoff plan. However, the rationale behind this round of layoffs differs from conventional cost-cutting — he explicitly stated that the funds saved will be reinvested into the business to seize opportunities in the AI Agent era.

What’s even more noteworthy is the execution detail: GitLab will use agentic AI to reconstruct internal workflows, automating review, approval, and handover processes. This isn’t just a slogan — it marks the first major move by a DevOps platform to apply Agents at scale to its internal operations.

The Layoffs Aren’t About Saving Money, But Redistributing Resources

Bill Staples was direct in his memo: “We must re-examine the size and composition of every team to ensure we are optimizing for speed and customer outcomes. In some cases, AI can augment and accelerate team members’ work; in others, we need to scale certain roles to move faster.”

This statement signals two key points:

1. AI does not replace all roles, but tackles bottlenecks in workflows. Tasks like approvals and handovers, which are highly repetitive and rule-based, are where Agents excel.
2. The money saved will be reinvested into R&D and product development. GitLab aims to flatten management layers, reorganize its R&D teams, and reduce the number of countries where it operates — a strategy of focusing its resources.

From a financial perspective, this aligns with the logic behind the massive tech layoffs of 2023–2024: cut low-efficiency roles and redirect resources into AI R&D. What makes GitLab unique is that it’s not only adding AI features to its products but also experimenting with Agents in its internal operations.

Agentic AI Rebuilding Internal Processes: Automating from Approval to Handover

So, what is the “Agentic AI” mentioned by GitLab? Simply put, it’s an AI system capable of autonomously executing multi-step tasks. Unlike traditional Copilot-style tools, Agents can:

• Understand goals and decompose tasks: For example, with “Approve this PR,” the Agent can automatically check code standards, run tests, identify risk points, and finally make an approve/reject decision.
• Coordinate across systems: The approval process might involve GitLab, Jira, and Slack. The Agent can automatically pass data between them.
• Handle exceptions: If a test fails, the Agent notifies the relevant developer and pauses the approval instead of simply failing out.

GitLab has already launched a public beta of its Duo Agent Platform — an orchestration tool allowing developers to collaborate asynchronously with AI Agents throughout the DevSecOps lifecycle. Now, they plan to use this capability internally — essentially “eating their own dog food.”

Why Are Approval Workflows Ideal for Agents?

Approval workflows have these characteristics:

1. Well-defined rules: Code review involves linting rules, test coverage thresholds, and security standards — all of which can be formalized.
2. High repetitiveness: Teams may handle dozens or hundreds of PRs per day — manual reviews are slow and error-prone.
3. Need for contextual understanding: It’s not just “approve/reject” — the decision must factor in code changes, history, and team norms.

Traditional automation tools (like CI/CD pipelines) can handle point 1. Agents, on the other hand, can manage all three. OpenAI’s o3 model scored 71.7% on the SWE-bench benchmark — capable enough for complex coding tasks, more than sufficient for approval-related work.

This Isn’t Just GitLab’s Choice — It’s an Industry Trend

Since 2023, the wave of layoffs in the tech industry has essentially been a reallocation of cost structure — cutting headcount while increasing AI R&D spending. The data speaks clearly:

• Over 150,000 tech employees were laid off worldwide in 2024, across 545 companies including Amazon, Google, and Microsoft.
• Meanwhile, R&D and capital expenditures rose sharply. Meta, Google, Microsoft, and Amazon’s AI business annual revenues are growing rapidly. Meta’s Advantage+ Shopping Ads revenue exceeded $20 billion — up 70% year-over-year.

GitLab’s move is a microcosm of this broader trend. The difference: most companies cut staff to reduce expenses; GitLab is cutting to fund AI investment. That distinction matters — the former is defensive, the latter offensive.

Has the Cost Inflection Point for AI Replacing Human Labor Arrived?

Take OpenAI’s o3 model, for instance. In the ARC Prize benchmark:

• A human worker completes the same task for $5.
• o3 requires $17–20 under low reasoning cost.

At first glance, AI still lacks a cost advantage — but that number is dropping fast. GPT-4o’s API price has already fallen from $5 per million tokens at launch to $2.5 — a 50% drop. DeepSeek’s training costs are just $6 million, ten times cheaper than traditional models.

At this rate, the cost inflection point where AI becomes cheaper than humans could arrive within 1–2 years. At that point, the question won’t be “Should we use AI?” but “If we don’t, we’ll be outpaced.”

GitLab’s Agent Strategy: Dual Drive in Product and Operations

GitLab’s work with AI Agents centers on two fronts:

1. On the Product Side: Duo Agent Platform

An orchestration tool enabling developers to collaborate with AI Agents throughout the DevSecOps lifecycle. Key features include:

• Code Review Agent: Auto-checks coding standards, security flaws, and performance issues.
• Test Generation Agent: Automatically creates unit and integration tests based on code changes.
• Deployment Coordination Agent: Manages multi-environment deployment, rollbacks, and exceptions.

These Agents don’t work in isolation — the orchestration system ensures coordination. For instance, if the Code Review Agent flags an issue, it triggers the Test Generation Agent to produce additional test cases and notifies developers for fixes.

2. On the Operations Side: Internal Process Automation

The “agentic AI reconstruction of internal workflows” mentioned in the layoff memo refers to using Duo Agent Platform capabilities internally at GitLab. Likely use cases include:

• HR approval workflows: Automating leave requests, reimbursements, and promotion approvals.
• Finance reconciliation: Automating invoice matching, budget approvals, and cost allocations.
• Customer support: Automating ticket classification, issue diagnosis, and recommendations.

The shared traits of these use cases: well-defined rules, high repetition, and cross-system coordination. Agent automation can connect these workflows, eliminating unnecessary human handoffs.

The Organizational Shift in the Agent Era: From Hierarchy to Task Orchestration

GitLab’s mention of “streamlining management layers” isn’t just trimming middle managers — it signals a deeper transformation in organizational structure.

In a traditional hierarchical model, information and decisions cascade upward:

Employee → Team Lead → Manager → Director → VP → CEO

Each layer adds delays and information loss. Introducing Agents can convert this into a task orchestration model:

Task Initiation → Agent Decomposition → Parallel Subtasks → Result Aggregation → Human Decision

Middle layers are replaced by Agents, while managers focus on key decision points. It’s not that managers become unimportant — their role shifts from “information relay” to “goal definition.”

Technical Challenges in Multi-Agent Coordination

As promising as this model sounds, implementation faces key challenges:

1. Accuracy of Task Decomposition: Can the main Agent interpret objectives correctly and break them into sub-tasks?
2. Reliability of Sub-Agents: What happens if one sub-Agent fails — does the workflow collapse?
3. Access Control: How to handle risky operations (like data deletion) safely?

GitLab’s Duo Agent Platform employs several design principles:

• Main Agent handles orchestration and results aggregation; sub-Agents execute specific tasks.
• Atomic locking mechanisms prevent concurrent edits of shared resources.
• Risky operations require “mailbox approvals” — sub-Agents must request permission from the main Agent.

These concepts borrow from distributed system design — treating Agents as microservices.

Implications for Developers: From Coding to Agent Management

What does this shift mean for developers? The most direct change: the focus moves from writing code to managing Agents.

Previously, a developer’s daily work included:

1. Writing code
2. Submitting PRs
3. Waiting for review
4. Fixing issues
5. Merging code

Now it might look like:

1. Defining task goals
2. Configuring Agent parameters
3. Monitoring Agent execution
4. Handling exceptions beyond the Agent’s scope
5. Validating final results

Developers still code — but less time is spent writing, more time on orchestration and monitoring. It’s akin to the DevOps shift, where sysadmins evolved from manual server setup to scripting Infrastructure as Code.

New Skills Developers Need

1. Prompt Engineering: How to write prompts that Agents can accurately interpret?
2. Agent Orchestration: How to design multi-Agent workflows?
3. Exception Handling: How to debug and fix when Agents fail?

These skills lack standardized training today — but as Agent adoption grows, best practices will emerge.

Competitive Landscape: GitLab vs. GitHub Copilot Workspace

GitLab isn’t the only DevOps platform betting on Agents. GitHub launched Copilot Workspace in 2024, also aimed at AI-assisted development. The key differences:

| Dimension | GitLab Duo Agent | GitHub Copilot Workspace | |------------|------------------|---------------------------| | Positioning | Orchestration tool supporting multi-Agent collaboration | Integrated development environment with a single assistant | | Use Cases | Complex DevSecOps workflows | Everyday coding and debugging | | Openness | Supports custom Agents | Closed ecosystem — GitHub-only Agents | | Pricing | Usage-based billing | Included in Copilot subscription |

GitLab’s edge is flexibility and openness, appealing to enterprise-scale clients with complex workflows. GitHub’s strength lies in ease of use and ecosystem integration, ideal for small teams.

Strategically, GitLab’s layoffs and internal revamp are experiments to validate Agents’ viability in enterprise operations. If successful, it will serve as a powerful product case study.

Risks and Challenges: Agents Aren’t Magic Bullets

No matter how capable, Agents have limitations. GitLab’s transformation comes with several risks:

1. Reliability Issues

Today’s LLMs still hallucinate — they can make critical judgment errors. A code review Agent might misidentify a security flaw or mistakenly reject a valid request.

Mitigation: retain human oversight for high-stakes actions. This slows automation, requiring a balance between reliability and efficiency.

2. Employee Acceptance

Replacing certain roles with AI inevitably triggers resistance. GitLab must communicate clearly about what tasks Agents will assume vs. what remains human-led.

As Bill Staples emphasized: “AI augments team members’ work” — not “AI replaces team members.” That distinction is pivotal for employee morale.

3. Technical Debt

Implementing Agents increases system complexity. Poorly designed Agent interactions can create serious technical debt and maintenance costs.

GitLab will need to balance rapid rollout with sound architecture to avoid trading short-term gains for long-term instability.

Industry Lessons: Organizational Evolution in the AI Era

GitLab’s example offers valuable insight: organizational change in the AI era isn’t mere cost reduction — it’s a redefinition of human–AI collaboration.

Three key principles:

1. Identify work suitable for Agents: Tasks that are rule-based, repetitive, or require cross-system coordination.
2. Retain human judgment: Tasks involving creativity, value-based decisions, or high risk.
3. Build human–machine workflows: Agents execute, humans supervise and handle exceptions.

Transformation will take time and iteration. GitLab’s results will likely unfold over the next 1–2 years. If successful, it could become a benchmark for AI-enabled organizational evolution; if not, it will still offer critical lessons.

For developers, the takeaway is clear: Either learn to manage Agents — or be managed by them. The choice is yours.

---

References

• GitLab to Lay Off Employees: Retaining Funds to Capture Market Opportunities in the AI Agent Era — IT Home report on GitLab’s layoff plan
• GitLab Launches Public Beta of Duo Agent Platform — InfoQ technical analysis of GitLab’s AI Agent product