# Set Up Argo CD Image Updater for Your Applications

Yes. An agent works out which of your Argo CD apps render through Helm or Kustomize, adds an ImageUpdater resource with git write-back for them, and opens a PR.

[Run this on Rush](https://cloud.getrush.ai/run/add-image-updater/argo-cd/). Opens the console with this prompt ready to send, in a Project that has your repository.

## 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`

```json
{
  "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"
    }
  ]
}
```

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

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.

## 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

- [Add Kubeconform Validation to CI for an Argo CD Repo](https://getrush.ai/run/add-kubeconform-to-ci/argo-cd/)
- [Post a Rendered Manifest Diff on Every PR to an Argo CD Repository](https://getrush.ai/run/add-manifest-diff-to-ci/argo-cd/)
- [Add Pod Disruption Budgets to Argo CD Applications](https://getrush.ai/run/add-pod-disruption-budgets/argo-cd/)

## More jobs like this: Hand off a long task

- [Add Infracost to CI for a Terraform Module](https://getrush.ai/run/add-infracost-to-ci/terraform/)
- [Add Input Validation to an aiohttp App](https://getrush.ai/run/add-input-validation/aiohttp/)
- [Add Input Validation to an Axum API](https://getrush.ai/run/add-input-validation/axum/)

## Keep reading

- [How a Rush run works on your repository, from request to pull request](https://getrush.ai/cloud/)
- [Compare cloud agents, agent sandboxes and AI code review](https://getrush.ai/compare/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
