What the agent does
The agent starts with the shape of the repository, because that is what makes Dependabot a poor fit and Renovate a good one. In a repository like temporalio/samples-typescript, pnpm-workspace.yaml lists *, message-passing/*, polling/*, openai-agents/* and the food-delivery and monorepo-folders packages as workspace members, with sharedWorkspaceLockfile: true and hoist: false, so one pnpm-lock.yaml at the root covers every sample, and .scripts/list-of-samples.json names sixty-three of them. Each sample has its own package.json with @temporalio/activity, @temporalio/client, @temporalio/worker, @temporalio/workflow and @temporalio/envconfig at the same ^1.24.0 range plus its own devDependencies. There is no renovate.json and no .github/dependabot.yml.
It then reads how the SDK is upgraded today. .scripts/upgrade-versions.mjs, run as pnpm upgrade-versions <version>, walks every package.json with glob and rewrites every @temporalio/* entry in dependencies, devDependencies and resolutions to one version, which tells the agent that the SDK packages are meant to move together, across all samples, in one change. .github/workflows/ci.yml pins its actions to commit SHAs with a version comment (actions/checkout@9c091bb… # v7.0.0, pnpm/action-setup@fc06bc1… # v5, actions/setup-node@53b8394… # v6) and tests a Node matrix of 20, 22 and 24. The root package.json has pnpm.packageExtensions for eslint-config-next, mocha and @temporalio/strands-agents, and .github/CODEOWNERS gives pnpm-lock.yaml its own owners.
The configuration follows from that. renovate.json extends config:recommended, sets rangeStrategy: bump so the caret ranges in each package.json move with the lockfile, and has four packageRules: a temporal-sdk group that puts every @temporalio/* package across all samples into one pull request, matching what upgrade-versions.mjs does by hand; a weekly group for the shared tooling (typescript, ts-node, mocha, eslint, prettier and their types) so sixty-three samples do not each open a pull request for the same @types/node patch; a monthly group for everything else; and a rule that leaves the ai-sdk, openai-agents, google-adk-agents and strands-agents samples' model-provider packages to their own pull requests, since CODEOWNERS routes those directories to another team. lockFileMaintenance is enabled on a schedule so the shared lockfile gets a clean refresh, the github-actions manager keeps the SHA pins and rewrites the version comments, and prConcurrentLimit keeps the first week readable.
The proof is a dry run of Renovate itself. In the sandbox the agent runs pnpm install --frozen-lockfile on Node 22 to show the lockfile is consistent, validates the file with renovate-config-validator, then runs renovate --platform=local, which reads the checkout as a repository without any token, lists every dependency it extracted from the sixty-three manifests and the workflow, and prints the updates it would open and how the rules group them. That output is what the pull request description quotes, so a reviewer sees the first pull requests before any are opened.
Start it with one API call
POST https://api.phoenix.so/o/{org}/sessions with this body:
{
"agent": "claude",
"input": "Set up Renovate for this Temporal TypeScript monorepo. Read pnpm-workspace.yaml, the root package.json, .scripts/upgrade-versions.mjs, .scripts/list-of-samples.json, .github/CODEOWNERS and .github/workflows/ci.yml first, and note that one shared pnpm lockfile covers every sample, that an existing script bumps every @temporalio package to one version across all manifests, and that the workflow pins actions to commit SHAs with version comments. Write renovate.json extending config:recommended with rangeStrategy bump, a group that moves every @temporalio package across all samples in one pull request, a weekly group for shared tooling such as typescript, ts-node, mocha, eslint and prettier, a monthly group for the rest, a rule that keeps the model-provider packages in the AI samples separate because CODEOWNERS routes those directories elsewhere, lockFileMaintenance on a schedule, the github-actions manager, and a concurrent pull request limit. Run pnpm install --frozen-lockfile on the Node version in .nvmrc, validate the config with renovate-config-validator, run renovate with --platform=local as a dry run and include its detected dependencies and planned updates in the pull request description. 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 adding renovate.json and nothing else: no dependency is bumped and no sample is touched. The file is short enough to read in one screen, with a comment-free structure the validator accepts and a $schema line so editors check it.
The description walks through each packageRules entry with the reason it exists, quotes the validator result, the frozen install, and the dry run's list of detected dependencies and planned pull requests grouped by rule, so the reviewer can see that the @temporalio/* group would open one pull request and the tooling group another. The transcript at GET /o/{org}/sessions/{id}/messages keeps the full dry-run log.
Before merging, a reviewer checks the dry run against expectations: that the SDK group covers every sample, that the AI samples' provider packages appear in their own entries, and that the Node matrix in ci.yml is left alone. After the merge, the Renovate app opens its onboarding pull request against the committed config, and the first real pull requests follow the groups the dry run predicted.
Run it on every Monday morning
Renovate opens the pull requests on its own schedule once the config is merged, so the weekly job here is review, not setup: create an automation in the Project with a schedule trigger, a cron such as 0 8 * * 1 in your timezone, and a prompt that reads the open Renovate pull requests, runs the affected samples' build and tests in the sandbox, and comments on each with the result. An automation run has its own max_runs_per_hour cap.
To run the setup itself across several repositories, send POST /o/{org}/sessions with this body and each repository in resources, with a request_id that is a UUID v5 of the repository name, so a retried call returns the run already started.
The use case this job follows, with its automation and trigger: Upgrade dependencies weekly.
Why run it on Rush?
A monorepo of sixty-odd samples with one lockfile breaks the per-package model of most update bots: without grouping, a single @types/node release becomes dozens of pull requests, and the SDK packages, which the maintainers already bump together with a script, would arrive as separate changes that fail together. Writing the rules that avoid this means reading the workspace, the script, the code owners and the workflow first, which is slow by hand and routine for an agent.
The dry run is the part that makes the pull request reviewable: Renovate's own --platform=local output shows exactly which pull requests the config will produce before any is opened. Running it on Rush gives the job a sandbox with the repository's Node version and the whole log kept, and the same body can be sent for every repository the team maintains.
Frequently asked questions
Why Renovate rather than Dependabot here?
Because of grouping across manifests. The repository has sixty-three package.json files sharing one lockfile, and the SDK packages are meant to move together, which upgrade-versions.mjs already encodes. Renovate's packageRules can put every @temporalio/* dependency from every sample into one pull request and handle SHA-pinned actions with version comments; Dependabot groups within a directory and would open far more pull requests.
Does it replace the upgrade-versions script?
No. The script stays for the day an SDK release should be rolled out by hand or pointed at a local file: build, which Renovate cannot do. The Renovate group covers the routine case, a new SDK release on npm, with the same result: every sample on one version in one pull request.
Will it bump the Node versions in the CI matrix?
No. The matrix in ci.yml is a list of major versions the samples are meant to support, not a dependency, and the config does not touch it. The github-actions manager updates the action SHAs and their version comments only.
How does the dry run work without a GitHub token?
Renovate's --platform=local mode reads the current directory as the repository and makes no API calls to a code host. It still fetches package metadata from npm to find newer versions, so the sandbox needs network access, which it has, and it prints the dependencies it found and the updates it would open as a log rather than opening anything.
More Temporal jobs
The same job on other stacks
- Add Renovate to a Terraform Module Repository (Terraform)
- Set Up Renovate for an Ansible Role (Ansible)
- Add Renovate to Keep Docker Compose Image Tags Current (Docker Compose)