What the agent does
The agent clones the repository into its own cloud sandbox and reads how the chart is released today. In a repository like helm/examples, charts/hello-world/Chart.yaml is apiVersion: v2, version: 0.1.0, appVersion: "1.16.0" and type: application; values.yaml sets an nginx image with an empty tag that falls back to appVersion, replicaCount: 1, a ClusterIP service on port 80 and a created service account; the templates are a Deployment with HTTP liveness and readiness probes on /, a Service, a ServiceAccount, NOTES.txt and _helpers.tpl. The README.md tells users to helm repo add examples https://helm.github.io/examples and helm install ahoy examples/hello-world, which is the GitHub Pages index that chart-releaser maintains.
.github/workflows/release.yaml runs on every push to main: actions/checkout@v2 with fetch-depth: 0, a git identity, azure/setup-helm@v1, and helm/chart-releaser-action@v1.2.0 with CR_TOKEN set to GITHUB_TOKEN, which packages any chart whose version is new, creates a GitHub release for it and updates the Pages index. lint-test.yaml runs on pull requests with helm/chart-testing-action@v2.0.1, ct list-changed, ct lint, and a kind cluster with ct install only when a chart changed; it still uses the ::set-output syntax to pass that result between steps. There is no helm push, no oci:// reference and no packages: write permission anywhere.
The agent adds a second job to release.yaml, publish-oci, that needs the chart-releaser job, with permissions of contents: read and packages: write. It logs in with helm registry login ghcr.io using github.actor and GITHUB_TOKEN on stdin, reads the version from Chart.yaml, and before pushing runs helm show chart oci://ghcr.io/<owner>/charts/hello-world --version <version> so a version that already exists in the registry is skipped rather than overwritten, since OCI tags are mutable and chart-releaser's own rule is that a published version is final. When the version is new it runs helm package charts/hello-world and helm push hello-world-<version>.tgz oci://ghcr.io/<owner>/charts. The README.md gains the OCI install form, helm install ahoy oci://ghcr.io/<owner>/charts/hello-world --version 0.1.0, next to the repository form, which keeps working.
To prove the commands before the workflow runs them, the agent installs Helm in the sandbox, runs helm lint and helm template on the chart, and, because the sandbox has no Docker, installs it with sudo apt-get install -y docker.io, starts dockerd and runs the registry:2 image on localhost:5000. It packages the chart, pushes it there with --plain-http, pulls it back with helm pull and helm show chart to confirm the name, version and appVersion survive the round trip, and pastes that output into the pull request. The old action majors in both workflows and the deprecated ::set-output line are listed as a separate cleanup and left alone, so the diff is about publishing.
Start it with one API call
POST https://api.phoenix.so/o/{org}/sessions with this body:
{
"agent": "claude",
"input": "Add OCI publishing to this Helm chart repository. Read every Chart.yaml and values.yaml under charts/, the README and every workflow under .github/workflows first. Keep the existing chart-releaser release as it is and add a second job to the release workflow that logs in to ghcr.io with the workflow token, skips any chart version that already exists in the registry, and otherwise packages the chart and pushes it with helm push to oci://ghcr.io/<owner>/charts, with packages write permission on that job only. Add the oci:// install form to the README beside the existing helm repo form. In the sandbox, run helm lint and helm template, then install docker.io, start dockerd, run a local registry and push and pull the packaged chart to prove the round trip. Do not bump action versions or change the lint workflow. Open a pull request that quotes the round-trip output.",
"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 that adds one job to .github/workflows/release.yaml and one paragraph to README.md, with the chart, its templates and lint-test.yaml unchanged. The description shows the helm lint result, the helm push and helm pull against the local registry with the chart's name, version and appVersion read back, and names the registry path the workflow will publish to.
The run's record keeps the Helm install, the lint and template runs, the Docker install, the registry container and the push and pull, so a reviewer can confirm the commands in the workflow are the ones that worked in the sandbox rather than ones written from memory. The existing Pages index and helm repo add path keep working alongside the new one.
Before merging, a reviewer checks the GHCR path and owner in the workflow, decides whether the package should be made public in the repository's package settings after the first push, and chooses whether to take the deprecated ::set-output and the old action majors in the same change or the next.
Run it on every pull request that changes Chart.yaml
Once charts publish to a registry, the mistake that matters is a version bump that does not package or a chart that does not install. An automation with a github trigger on pull_request.opened and pull_request.synchronize starts one run per pull request; the agent checks out the branch and, when the diff does not touch a Chart.yaml or anything under charts/, ends with a one-line note. Only work by an owner, member or collaborator fires the trigger; pull requests from forks never do.
When it does, the run lints and packages the changed chart, pushes it to a local registry as the release workflow would, pulls it back, and posts one review that confirms the version is new against the published registry and that the package round-trips, or cites the Chart.yaml line that blocks it. It pushes no commits.
The use case this job follows, with its automation and trigger: Hand off a long task.
Why run it on Rush?
Publishing to an OCI registry is three Helm commands, and the risk is in the details around them: a token without packages: write, a tag that silently overwrites a published version, a README that still points only at the Pages index. The agent writes the job from the commands it actually ran in its own sandbox against a real registry, with the push and pull in the record, so the workflow's first real run is not the first time anyone saw those commands succeed.
An organisation with many chart repositories sends the same request to each and gets one pull request per repository, each wired to that repository's own chart names and existing release job, each with its own round-trip output. The repositories that already push to a registry come back with a short note instead of a duplicate job.
Frequently asked questions
Will this replace chart-releaser?
No. The chart-releaser job and the GitHub Pages index stay as they are, and the new job runs after it. Users who added the repository with helm repo add keep getting updates; users who prefer oci:// get the same chart from GHCR.
What stops the workflow from overwriting a published version?
Before pushing, the job runs helm show chart against the registry at the chart's current version and skips the push when it answers. OCI tags can be overwritten, so this guard gives the registry the same rule chart-releaser applies to releases: a version, once published, is final.
Does the registry need a token of its own?
Not for GHCR in the same organisation. The job logs in with github.actor and the workflow's GITHUB_TOKEN, which is enough once the job has packages: write. A registry elsewhere needs a secret, and the pull request says where the login step would read it.
Why run a local registry in the sandbox?
Because helm push cannot be dry-run. Pushing to a registry:2 container on localhost:5000 and pulling the package back is the only way to show the exact commands work before the workflow runs them against GHCR, and the sandbox is discarded afterwards.
More Helm jobs
More jobs like this: Hand off a long task
- Publish dbt Docs to GitHub Pages (dbt)
- Reduce Cold Starts in Cloud Functions for Firebase (Firebase Functions)
- Reduce Cold Starts for a NestJS API on Serverless Framework (Serverless Framework)