# What Changed in This Release, in Words Support Can Use? A Payroll Software Company Briefs Its Support Team on Each GitLab Release

A payroll software company's agent reads each new GitLab release's merge requests and issues and writes support a brief: what changed and what to say.

[Run this on Rush](https://cloud.getrush.ai/run/brief-support-on-each-release/gitlab/). Opens the console with this prompt ready to send. Connect GitLab there first.

## What the agent does

This is for a company that sells payroll and time-tracking software to small employers, with a support team that answers business owners and bookkeepers by email and chat. The engineers ship a release every week or two, tagged in GitLab, and support learns what changed when the first customer writes in to ask why the overtime report has a new column. The release notes the engineers write are a list of merge request titles. The agent turns each release into a brief the support team reads before the tag reaches customers: what changed for users, what they will notice, and what to say when they ask.

The run reads GitLab through GitLab's own MCP server, the GitLab entry in the Rush catalog. A lead with access to the product's project connects it once with `POST /me/connections {"type": "mcp", "name": "gitlab-mcp", "url": "https://gitlab.com/api/v4/mcp", "auth": {"mode": "oauth"}}` and finishes GitLab's sign-in from the `authorize_url`. GitLab's docs say the server must be allowed for the top-level group on GitLab.com before anyone can use it. No repository is cloned: the work is reading what the merge requests and issues say, not the code.

On a run the agent calls `list_releases` on the product's project and takes the release the prompt names and the one before it, with each one's `released_at`. It calls `list_commits` with `ref_name` set to the new tag and `since` set to the previous release's time, to know which changes are in this release, and `list_merge_requests` with `state` set to `merged` to find the merge requests behind them. It reads each with `get_merge_request` (the description, and `include` set to `notes` when the description is thin) and the issue a merge request closes with `get_work_item`, whose labels and description usually say which customers asked for the change.

It writes `release-brief.md` for support, in the support team's words, not the engineers': one section per change a customer can notice, saying what it does, where in the product it shows, who it affects (by plan, role or region, when the issue says), and a suggested answer to the question support expects. Changes labeled internal, refactors and test-only merge requests go in one closing line each. A change to how pay, tax or overtime is calculated goes first, quoted from the merge request, with a note that support should not explain the calculation beyond what the merge request says. The agent comments on nothing and changes nothing in GitLab.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "Write the support brief for release v4.18.0 of the project payroll/app. List releases with list_releases and take v4.18.0 and the release before it, with their released_at. Call list_commits with ref_name v4.18.0 and since set to the previous release's released_at to see which changes are in this release, and list_merge_requests with state merged on the same project to find the merge requests behind those commits. Read each merge request with get_merge_request (include notes when the description is under three sentences) and any issue it closes with get_work_item. Write release-brief.md for our support team in plain language: one section per change a customer can notice, saying what it does, where it shows in the product, who it affects if the issue says, and a suggested answer to the question support should expect. Put any change to pay, tax or overtime calculation first, quoting the merge request, and say not to explain beyond it. List internal, refactor and test-only merge requests in one line each at the end. Do not comment on, approve, update or create anything in GitLab.",
  "connections": [
    "gitlab-mcp"
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

The session returns `release-brief.md` as an artifact and a short answer naming the changes customers will notice. The support lead reads it the day the tag is cut, edits the suggested answers into the team's tone and posts the brief where the team keeps its saved replies. Every section links the merge request it came from, so an agent on the support team who needs more detail can read the engineer's own words.

What the support lead checks: that a change the brief calls invisible to customers really is (a renamed field in an export is visible to the bookkeeper who imports it), that the suggested answers promise nothing the merge request does not, and every calculation change with an engineer before support says a word about it. The transcript shows each GitLab call and what it returned, so a sentence that looks wrong can be traced to the merge request behind it.

## Run it on every a release is tagged

The release pipeline already knows the tag. Its last job sends `POST /o/{org}/sessions` with the body above and the new tag in `input`, using the company's API key, and a `request_id` that is a UUID v5 of the tag name, so a retried pipeline starts no second run for the same release. The key's webhook delivers `run.completed` with the brief's summary to the company's own endpoint, which posts it where support works.

A support lead can also start the same request by hand for an older release, when a customer asks about a change from months ago and nobody remembers which release carried it.

## Why run it on Rush?

The facts are in GitLab, spread across a dozen merge requests and the issues behind them, and writing them up for support means someone reads all of it every release. The GitLab sign-in stays in Rush's connection, scoped by GitLab's sign-in to the `mcp` scope, instead of a personal access token pasted into a CI variable that every pipeline can read.

Each run has its own computer and keeps a record of every GitLab call it made and what its model calls cost, so the company can see what each brief costs and show that the agent only read. Releases that land close together run at once, each in its own session, without one waiting for the other.

## Frequently asked questions

### Does this need GitLab Premium or GitLab Duo?

GitLab's docs list the MCP server on the Free, Premium and Ultimate tiers and say GitLab Duo is not required for the server itself. They also list a per-user limit on GitLab.com of 60 requests a minute on Free and 600 on Premium and Ultimate, answered with `429 Too Many Requests` past it. The agent makes a few calls per merge request, so a very large release on Free can reach that limit.

### Why not just publish the merge request titles?

Titles are written for engineers ("Refactor OT rule engine") and say nothing about who will notice. The brief reads the descriptions and the issues behind them, which is where the customer, the plan and the screen are named, and writes the answer support needs.

### Could the agent change our GitLab project?

GitLab's server includes tools that create merge requests, add notes and accept merge requests. The prompt forbids every one, and the transcript would show any such call. A lead who wants the brief attached to the release can paste it there after reading it.

### We self-host GitLab. Does this work?

GitLab's docs give the server at `https://<your GitLab host>/api/v4/mcp` on GitLab Self-Managed and Dedicated, and an administrator must allow it for the instance. The instance must be reachable from the internet for a cloud run to connect; connect it with your host in place of gitlab.com.

## More GitLab jobs

- [Report Stale GitLab Merge Requests](https://getrush.ai/run/merge-request-report/gitlab/)
- [Find Flaky GitLab Pipeline Jobs](https://getrush.ai/run/pipeline-failure-report/gitlab/)

## More jobs like this: Produce a report or file, no repo

- [Find Broken Backlinks With Ahrefs](https://getrush.ai/run/broken-backlinks/ahrefs/)
- [Find Slow Vercel Builds](https://getrush.ai/run/build-time-report/vercel/)
- [Report Email Campaign Performance From Klaviyo](https://getrush.ai/run/campaign-performance-report/klaviyo/)
- [Which Client Deliverables Are Stuck in Review? A Video Production Studio's Monday List From ClickUp](https://getrush.ai/run/chase-deliverables-waiting-on-client-review/clickup/)

## Keep reading

- [Connect GitLab to Rush: which of its connections a run names](https://getrush.ai/integrations/gitlab/)
- [Start your first run from the developer API quickstart](https://getrush.ai/docs/quickstart/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
