What the agent does
The agent clones the repository into its own cloud sandbox and reads how the applications are defined before it adds anything. In a repository like argoproj/argocd-example-apps, apps/templates/applications.yaml is one Helm template that stamps out an Application named example.<name> per entry in apps/values.yaml, all pointing at the same repoURL on targetRevision: master with automated sync, prune and selfHeal. The entries differ in how they render: helm-guestbook and blue-green carry a tool.helm.releaseName, kustomize-guestbook and sock-shop have a kustomization.yaml in their directory, guestbook is plain YAML, three plugin-* apps use config management plugins, and jsonnet-guestbook is raw Jsonnet. The images are concrete: gcr.io/google-samples/gb-frontend:v5 in guestbook/guestbook-ui-deployment.yaml, kustomize-guestbook/guestbook-ui-deployment.yaml and as image.repository plus image.tag in helm-guestbook/values.yaml and blue-green/values.yaml; eleven weaveworksdemos/* images with semver tags such as orders:0.4.7 and front-end:0.3.12 under sock-shop/base/, next to untagged mongo and kbudde/rabbitmq-exporter.
That inventory decides the scope, because Image Updater changes image references only where it can write a parameter: a Helm value or a Kustomize image override. The plain guestbook directory and the Jsonnet apps are out, and the agent says so in the pull request rather than annotating them and waiting for nothing to happen. For the rest it writes an ImageUpdater resource in the argocd-image-updater.argoproj.io/v1alpha1 API, in a new image-updater/ directory with its own kustomization.yaml so it can be registered as one more entry in apps/values.yaml. Its applicationRefs select by namePattern (example.helm-guestbook, example.blue-green, example.kustomize-guestbook, example.sock-shop), and each images entry has an alias, the imageName and manifestTargets: helm.name: image.repository and helm.tag: image.tag for the two charts, and kustomize.name set to the original image name for the two Kustomize apps.
The update strategy is semver for images whose tags are versions, with allowTags set to a regexp: that matches v5-style or 0.4.7-style tags so a latest push is ignored, and the mongo, redis:alpine and exporter images in sock-shop are left out of the list because an untagged or floating image has nothing for a semver strategy to compare. Write-back is git, set in writeBackConfig with gitConfig.branch left to follow the Application's targetRevision, and writeBackTarget set to kustomization for the Kustomize apps and helmvalues:values.yaml for the charts, so the controller commits to the file a person would edit rather than to a .argocd-source-<appName>.yaml sidecar. The credentials reference stays at the default repocreds, which means the repository must already be registered in Argo CD with push rights; the pull request lists that as the one step done outside the repository, together with installing the controller in the argocd namespace.
Before opening anything it validates its work in the sandbox: kustomize build image-updater/ renders the resource, helm template apps/ shows the new entry becomes an Application like the others, and kustomize build sock-shop/ and kustomize build kustomize-guestbook/ confirm the image names it put in kustomize.name match what the manifests actually contain. It changes no Deployment, no chart and no existing Application, and adds a short section to README.md that explains which apps are managed, which are not and why.
Start it with one API call
POST https://api.phoenix.so/o/{org}/sessions with this body:
{
"agent": "claude",
"input": "Set up Argo CD Image Updater for the applications in this repository. First list every Application and how it renders (Helm, Kustomize, plain YAML, Jsonnet, plugin) and which container images each one uses. Add an ImageUpdater resource, in its own directory registered like the other apps, that covers only the Helm and Kustomize applications: one image entry per image with a semver update strategy and an allow-tags pattern that excludes floating tags, helm.name and helm.tag or kustomize.name manifest targets as appropriate, and git write-back to the values file or kustomization rather than a sidecar file. Leave plain YAML and Jsonnet apps out and say why. Validate with kustomize build and helm template in the sandbox, document the controller install and repository credential steps in the README, and open a pull request.",
"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
What comes back is a pull request on its own branch that adds image-updater/kustomization.yaml and image-updater/image-updater.yaml, adds one entry to apps/values.yaml, and extends README.md. The description has the inventory table (application, render tool, images, managed or not), the allowTags pattern per image with the tags it would accept today, and the kustomize build and helm template output from the sandbox.
The run's record keeps every command with its output, including the builds that checked each kustomize.name against the rendered manifests, so a reviewer can see the names line up before the controller ever runs.
Before merging, a reviewer decides whether every selected app should take new versions automatically or whether some should get a pull request from the controller instead, confirms the repository credential Argo CD holds can push, and installs the controller if it is not already there. The first commit from the controller is the proof that the setup works, and it lands in the same repository where the reviewer can read it.
Run it on every new Application added
In the console, an automation in the Project that has the repository, with a github trigger on pull_request.opened and pull_request.synchronize and branch_patterns for your default branch, starts one run per pull request, with the pull request as its context. Its prompt asks the run to check whether the pull request adds an entry to apps/values.yaml that renders through Helm or Kustomize, and if so to comment with the images entry and namePattern the ImageUpdater resource needs; the saved prompt is the whole instruction and the trigger fills in no placeholder.
For the first setup across several GitOps repositories, a script sends one POST /o/{org}/sessions per repository with this body, each with a fresh UUID as request_id so a retry returns the run already started, and each run ends in its own pull request scoped to the applications that repository defines.
The use case this job follows, with its automation and trigger: Hand off a long task.
Why run it on Rush?
Image Updater configuration fails quietly: a kustomize.name that does not match the manifest, an app that renders from a plain directory, or a semver strategy on a latest tag all produce a controller that logs and does nothing. The agent reads the real manifests, renders them in its sandbox and matches each image name against what the build produced, so the pull request carries evidence instead of hope.
The sandbox is its own computer with kustomize, helm and git, and every command it runs stays in the run's record. Several GitOps repositories can be set up at once in separate sandboxes, each with an inventory and a pull request of its own.
Frequently asked questions
Why are some of my applications left out?
Image Updater writes a Helm parameter or a Kustomize image override, so an application that renders from plain YAML or Jsonnet has nowhere for it to write. The agent lists those apps in the pull request with the reason, and converting one to Kustomize is a one-line kustomization.yaml if you want it managed later.
Will the controller commit straight to my default branch?
With writeBackConfig.method: git and no gitConfig.branch, it commits to the branch the Application tracks, which in this repository is master. The reviewer can set gitConfig.branch to a base:target pair, or configure gitConfig.pullRequest so the controller opens a pull request instead, and the pull request body shows both forms.
What stops it from picking up a `latest` or `dev` tag?
The semver strategy only considers tags that parse as versions, and the agent adds an allowTags regular expression per image on top of that. Images that have no versioned tags at all, such as mongo with no tag, are not listed.
Does the agent install Argo CD Image Updater for me?
No. The run changes the repository only; installing the controller in the argocd namespace and giving Argo CD push credentials for the repository are steps on your cluster. The README section the agent adds names both and the pull request lists them as the two things to do before merging.
More Argo CD jobs
More jobs like this: Hand off a long task
- Add Infracost to CI for a Terraform Module (Terraform)
- Add Input Validation to an aiohttp App (aiohttp)
- Add Input Validation to an Axum API (Axum)