Devops copilot

An AI system that automatically helps developers manage the development workflow.

Comment

Inspiration
Modern software teams spend countless hours debugging failed CI/CD pipelines, manually reviewing merge requests, and triaging a backlog of issues. These repetitive DevOps tasks drain engineering productivity and slow down delivery cycles. We were inspired by the idea of a true AI copilot that sits alongside your GitLab workflow — one that doesn't just suggest fixes, but actually acts on them. The rise of agentic AI and the GitLab Duo Agent
Platform made this the perfect moment to build it.

What it does

DevOps Copilot is an AI-powered multi-agent system that automates three core DevOps workflows on GitLab:

  1. Pipeline Auto-Fix — When a CI/CD pipeline fails, the agent fetches the job logs, analyzes the root cause using Claude, generates a fix for .gitlab-ci.yml, creates a new branch, commits the fix, and opens a Merge Request — all automatically.
  2. Automated Code Review — When a Merge Request is opened or updated, the agent fetches the diff, performs a thorough AI-driven review identifying bugs, security issues, and performance problems, then posts line-by-line comments directly on the MR.
  3. Intelligent Issue Triage — When a new issue is opened, the agent categorizes it (bug/feature/enhancement), assigns priority (critical/high/medium/low), severity (blocker/major/minor/trivial), estimates effort (XS–XL), and suggests appropriate labels and component ownership.

A React dashboard lets teams monitor all agent activity in real time.

How we built it

  • GitLab Duo Agent Platform — Agents are defined with agent.yml configs and orchestrated via flows/ YAML files, triggered by GitLab webhook events
    (pipeline failures, MR events, issue events).
  • Anthropic Claude (claude-3-5-sonnet) via @anthropic-ai/sdk — Powers log analysis, fix generation, code review, and issue triage.
  • Node.js + Express — Backend API handling webhook ingestion and GitLab API interactions.
  • PostgreSQL — Stores pipeline failures, review results, and triage history.
  • React + Tailwind CSS — Frontend dashboard for monitoring agent activity.
  • Docker — Containerized setup for easy deployment.

The architecture is fully event-driven: GitLab webhooks trigger agents → agents call Claude → Claude outputs structured analysis → backend executes
actions (create branch, commit, open MR, post comment, apply labels) via the GitLab REST API.

Challenges we ran into

  • GitLab CI image mismatch — The demo project's test pipeline was running on a ruby:3.1 Docker image but attempting to run npm commands, which don't
    exist in that image. This was a real failure we used to validate the pipeline-fix agent's ability to detect and fix environment mismatches.
  • Structured AI output — Getting Claude to produce consistently structured, actionable output (e.g., exact file paths, line numbers for MR comments,
    YAML patches) required careful prompt engineering.
  • GitLab API complexity — Posting inline MR comments requires precise diff position calculations; mapping AI suggestions back to diff positions was
    non-trivial.
  • Multi-agent orchestration — Coordinating three independent agents sharing the same GitLab project context without conflicts took careful flow design.

Accomplishments that we're proud of

  • A fully end-to-end working pipeline auto-fix: from a real failing GitLab pipeline to an AI-generated MR fix, entirely automated.
  • A multi-agent architecture that cleanly separates concerns (fix, review, triage) while sharing a common AI and backend layer.
  • Support for multiple AI providers (Anthropic, Gemini, OpenAI, Groq, Ollama) through a unified AI service interface.
  • A clean React dashboard giving full visibility into all agent activity.
  • Tight GitLab Duo Agent Platform integration using native agent.yml and flow definitions.

What we learned

  • Agentic AI is most powerful when it closes the loop end-to-end — reading context, reasoning, and taking action — rather than just generating suggestions for humans to act on.
  • Event-driven architectures are a natural fit for DevOps automation: GitLab webhooks + agents create a responsive, always-on system.
  • Prompt engineering for DevOps tasks (log analysis, diff review, YAML generation) is a distinct skill — domain-specific context and output formatting
    constraints are critical.
  • The GitLab Duo Agent Platform provides a compelling native way to define and deploy AI agents that feel like first-class GitLab citizens.

What's next for DevOps Copilot

  • Auto-merge approved fixes — If the pipeline fix agent's MR passes CI and has no review comments, auto-merge it.
  • Learning from history — Store past fix patterns in a vector database so the agent improves over time and avoids repeating the same mistakes.
  • Slack/Teams notifications — Notify engineers when agents take action or when a fix needs human approval.
  • Multi-project support — Scale the dashboard to monitor dozens of GitLab projects simultaneously with per-project agent configuration.
  • Security scanning agent — A fourth agent that triggers on MR events and runs AI-powered SAST analysis, posting findings before merge.
  • GitLab.com native deployment — Package as a GitLab Duo extension for one-click installation.

Built With

  • anthropic
  • next.js
  • shacn
  • supabase
  • tailwind
Share this project:

Updates