Inspiration
AI made writing code fast. It didn't make shipping it fast. On student teams and early-stage startups, nobody owns code review, security, releases or monitoring, so those steps get skipped or done badly at the last minute. I wanted to build the release crew those teams can't afford to hire.
What it does
Relay is an AI release crew built on GitLab Duo Agent Platform. You write the issue. Relay ships it. You approve the outcome.
- Relay Crew (one custom flow, three agents handing off the baton), triggered when an issue is created or the crew is mentioned:
- Triage labels and sizes the issue, writes acceptance criteria and an implementation plan, and decides BUILD or SKIP.
- Builder creates a branch, implements the change with tests and a changelog entry, runs the tests, and opens the merge request.
- Shepherd watches the pipeline, fixes failures itself, collects the evidence and posts a Relay Release Brief: a verdict (READY TO MERGE / BLOCKED), a stage-by-stage results table, security and governance results.
- Relay Captain (custom flow triggered by pipeline events) repairs failing merge request pipelines, and after a release posts a report back on the original issue.
- GitLab's foundational Code Review flow reviews every merge request.
The human makes one decision: merge. That is the Supervised level: the agents clear every gate on their own, and I approve the outcome, not the steps.
Real run shown in the demo
I opened one plain-language issue: "Support the 4.0 grading scale" for GradePoint, a GPA calculator for Nigerian universities. Without me touching code:
- Triage labeled it
type::feature,size::Mand posted a plan. - Builder implemented it (grading logic, API, UI selector), added tests, updated the changelog and opened MR !1.
- The MR pipeline went green: lint, 22 tests at 97% coverage, SAST, secret detection, dependency and container scanning, SBOM, and the governance gate.
- Shepherd posted the Release Brief: READY TO MERGE. Duo Code Review found nothing to fix.
- I merged. The main pipeline published release v1.0.11, and Relay Captain reported back on the issue, including honestly stating that no deployment ran.
Lifecycle coverage
- Plan: Triage agent labels, sizes and plans every issue
- Create: Builder agent writes code, tests and changelog, opens the MR
- Verify: lint, unit tests with an 80% coverage floor, JUnit reports; agents fix failing pipelines
- Secure: SAST, secret detection, dependency scanning, container scanning
- Package: container image in the GitLab registry, CycloneDX SBOM
- Govern: policy-as-code gate (
.relay/policy.json): license, security severity limits, coverage, forbidden code patterns; CODEOWNERS on pipeline and policy files - Release: automated release notes and a GitLab Release on every merge to main
- Configure / Monitor: per-environment config as code, Cloud Run per-MR previews, blue/green production rollout, smoke tests, a 60-second SLO watch with automatic rollback, and an hourly synthetic monitor are implemented in the pipeline and switch on when Google Cloud credentials are added. This submission runs without them.
How I built it
- GitLab Duo Agent Platform custom flows in YAML (multi-agent with routers), triggers (work item created, mention, assign, pipeline events), a flow runtime config (
.gitlab/duo/agent-config.yml) and shared agent rules inAGENTS.md. - The agents use the flow's own GitLab token through a small pipeline-watcher script that waits for pipelines and pulls the log tail of failed jobs, so every diagnosis is grounded in real output.
- GitLab CI/CD with the security templates, DAG
needs, environments and resource groups. - Node.js 22 with zero runtime dependencies.
Challenges
- The governance gate blocked my own release. SAST flagged two High SSRF findings in my CI scripts. Instead of weakening the policy, I fixed the code: every outbound request now goes through an allowlist. The gate did exactly what it is for.
- Flows can't trigger other flows (service accounts can't fire triggers), so the hand-offs happen inside one multi-agent flow, and Captain listens to human-started pipelines.
- Making the one human checkpoint meaningful: the Release Brief puts all the evidence in one place, so merging is an informed decision, not a rubber stamp.
What I learned
Agents are most useful when they are boxed in by hard evidence: real pipeline results, real logs, and policy as code. The human stays in charge of the one decision that matters.
What's next
Turning on the Google Cloud deploy path, a Hands-off mode behind a policy switch (auto-merge when the brief is READY and risk is low), and cost and carbon per release in the brief.
Built With
- devsecops
- docker
- gitlab
- gitlab-ci
- gitlab-duo-agent-platform
- google-cloud-run
- javascript
- node.js
- sast
- yaml