What the agent does
The agent reads what there is to update before writing a line of configuration. In a repository laid out like docker/awesome-compose, 39 sample directories each hold a compose.yaml, two of them a compose.yml, and 35 Dockerfiles sit one level further down in backend/, frontend/, app/ and similar folders. The images those files pin are a mix: mariadb:10.6.4-focal, mongo:4.2.0, kibana:7.16.1 and traefik:2.6 are exact tags, nginx, postgres and mongo appear with no tag at all, and wordpress:latest and gitea/gitea:latest float. The Dockerfiles are multi-stage with --platform=$BUILDPLATFORM and base images such as golang:1.18-alpine, python:3.10-alpine, rust:1.64, maven:3.8.5-eclipse-temurin-17 and node:lts. The only workflow is codeql-analysis.yml, pinned to commit SHAs of the v1 and v2 actions, and there is no .github/dependabot.yml.
Dependabot's docker ecosystem reads FROM lines in a Dockerfile, and its docker-compose ecosystem reads image: lines in compose files, so the configuration needs both, plus github-actions for the one workflow. Neither Docker ecosystem walks subdirectories, so the agent uses the directories key with globs instead of one entry per sample: /* for the compose files at the top of each sample, and /*/* for the Dockerfiles one level down, with the glob checked against the list it made so no Dockerfile sits outside a matched directory. Each entry gets a monthly schedule, since a repository of samples has no release to protect and a daily cadence across 39 samples would open more pull requests than two maintainers read, and an open-pull-requests-limit that keeps the queue short.
The agent then writes down what Dependabot will not touch. An image with no tag or a latest tag has nothing to bump, so nginx, postgres, mongo, wordpress:latest and gitea/gitea:latest are listed in the pull request with the exact tag each one resolves to today, so the maintainers can pin them in a follow-up and bring them under the schedule. node:lts and the eclipse-temurin:17-jre-focal family are floating aliases Dependabot leaves alone as well. A major base image jump, golang:1.18 to a current release for instance, can break a sample that builds, so the configuration ignores major updates for the docker entry with an ignore block and a comment, and lets minor and patch tags through.
Before opening the pull request the agent validates the file against the published Dependabot v2 JSON schema with a YAML parser and a schema checker in its sandbox, which catches a misspelled ecosystem or an unsupported key the way GitHub would on the first run. It also reads CONTRIBUTING.md, which asks for a Developer Certificate of Origin sign-off on every commit, and notes in the description that the maintainers decide how bot commits fit that rule. The repository's .npmrc and .yarnrc.yml already disable install scripts, and the agent leaves them as they are.
Start it with one API call
POST https://api.phoenix.so/o/{org}/sessions with this body:
{
"agent": "claude",
"input": "Add Dependabot to this Docker Compose repository. First list every compose.yaml, compose.yml and Dockerfile with the images and tags they pin, and every workflow under .github/workflows with its action pins. Write .github/dependabot.yml with a docker entry whose directories globs cover every Dockerfile, a docker-compose entry whose directories cover every compose file, and a github-actions entry, each on a monthly schedule with an open-pull-requests-limit; ignore major updates for the docker entry with a comment. Check the globs against your list so no file is left out. Validate the file against the Dependabot v2 JSON schema in the sandbox. In the pull request, list every image with no tag or a latest tag and the exact tag it resolves to today, every floating alias such as node:lts, and the CONTRIBUTING sign-off rule for the maintainers to decide on. Change nothing else.",
"resources": [
{
"url": "https://github.com/your-org/your-app"
}
]
}- 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.
- 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.
- 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 pull request adds .github/dependabot.yml and nothing else. Its description carries the inventory the agent made, every compose file and Dockerfile with the images they pin and which entry covers it, the schema check result, the list of untagged and latest images with the tag each resolves to today, the floating aliases, and the sign-off question.
After the merge, Dependabot opens its first pull requests on the next monthly run: one per directory where an exact tag has a newer minor or patch release, each updating a single image: or FROM line, and one for the CodeQL workflow's pinned actions. Each pull request builds nothing on its own, since the repository has no build workflow, which the description says plainly so the maintainers can add one if they want the bump proven before merging.
Before merging, a reviewer checks the globs against the directory layout once more, decides whether to pin the untagged images in the same change or a follow-up, and whether major base image updates should stay ignored or be grouped so a sample can move to a current golang or python image deliberately.
Run it on every month
A team that keeps several compose-based repositories sends this body once per repository from its own server, each a POST /o/{org}/sessions with that repository in resources and a request_id that is a UUID v5 of the repository's full name, so a retried call returns the run already started. Each run reads its own layout: a repository with a single compose.yaml and one Dockerfile gets two short entries, and one that already has a dependabot.yml gets the missing ecosystems added rather than a new file.
Once Dependabot runs, an automation on the Project with a schedule trigger set to the day after Dependabot's monthly slot and the prompt "for each open Dependabot pull request that bumps an image, read the sample's README and compose file, run docker-compose config on it, and comment with whether the new tag changes a default the sample relies on; push nothing" starts one run a month. A github trigger with an authors filter would not do: Dependabot is a bot sender, and bot senders never fire one. The run installs docker-compose first, since the sandbox has no Docker, before running the config check.
The use case this job follows, with its automation and trigger: Upgrade dependencies weekly.
Why run it on Rush?
Writing a Dependabot file is quick; knowing what it will and will not cover across 39 samples is the work, and getting a glob wrong means a Dockerfile that never gets a pull request and nobody notices. The agent makes the inventory first, writes the globs to match it, validates the file against the schema, and says which images are outside Dependabot's reach rather than leaving that to be discovered.
The inventory, the schema check and the tag lookups stay with the run as evidence, so the reviewer reads a map of the repository rather than guessing from the YAML. A team with many compose repositories runs the same request across all of them at once, each in its own sandbox, and each gets a file fitted to its own layout.
Frequently asked questions
Can Dependabot update an image with no tag?
No. Dependabot bumps a tag it can compare, and image: nginx or postgres has none, while latest is a name that never changes. The pull request lists each of those with the tag it resolves to today so the maintainers can pin them and bring them under the schedule.
Why two Docker ecosystems?
The docker ecosystem reads FROM lines in Dockerfiles and the docker-compose ecosystem reads image: lines in compose files; neither reads the other's file. A repository with both kinds of file needs both entries, each pointed at the directories where its files live.
Why ignore major updates for base images?
A sample pinned to golang:1.18-alpine or rust:1.64 builds against that toolchain, and a major jump can change a build in ways a one-line bump should not carry. Minor and patch tags flow through on the schedule; a major move is a deliberate change with a build to prove it.
Will Dependabot's pull requests be tested?
Only by whatever workflows the repository runs on pull requests, and a repository with just CodeQL runs no build. The description says so, and a docker compose config or build workflow for changed samples is the natural follow-up if the maintainers want each bump proven.