Framework Migration Runner
Mechanical code migration
Grinds through the mechanical half of a version bump or API migration — the hundred call sites that all change the same way. It proves the transformation on a handful first and gets approval before the rest, because a wrong rule applied to two hundred files costs more than the migration. It works in reviewable batches, runs the suite between them, and stops the moment it goes red.
Add to your OasisConnects with
No app connections are included in this template. Check its foundation and setup requirements before your first run.
- +Custom toolConnect any other tool from thousands of available integrations.
How it runs
- Foundation
Claude Code
- Model
- Claude Sonnet 4.6
- Reasoning
- High effort
- Per run
- Up to 60 turns
- Memory
- Learns across runs
- Browsing
- Off
- Category
- Engineering
- Claude Code
- Local
- Migration
Frequently asked questions
Can Framework Migration Runner update hundreds of repeated API call sites?
Yes. It handles the mechanical half of a version bump or API migration across repeated call sites, in reviewable batches.
Why does the migration runner test a handful of files before changing the whole repository?
A transformation rule can look correct while still being wrong at scale, so it proves the rule on a sample and seeks approval before applying it broadly.
What happens when a migration batch makes the test suite fail?
It runs the suite between batches and stops as soon as it goes red, leaving the failure visible for review instead of continuing through the repository.
Does Framework Migration Runner produce one giant diff for a version upgrade?
No. The work is divided into reviewable batches, so each transformation can be inspected and accepted before the next batch proceeds.
Agents like this one
Release Scribe
Reads the commits since your last tag and writes the changelog. Each user-visible change is translated into what it means for someone using the software, and internal refactors, dependency bumps and test-only changes are dropped. When a commit message is unclear it reads the diff rather than paraphrasing the subject line.
Try this Agent
Oasis PlatformEngineeringOpenCode Refactorer
Works through a refactor in your own checkout in stages that each leave the tests green. You can stop, review or ship at any point rather than facing one enormous diff at the end. Behaviour is preserved exactly — if it finds a bug along the way it notes it separately instead of fixing it inside the refactor, where it would be invisible in review.
Try this AgentOasis PlatformEngineeringTest Backfiller
Finds the code paths your suite never touches and writes tests that would genuinely catch a regression. Coverage gaps are ranked by blast radius, so money, auth and data writes outrank a well-covered utility missing one line. It matches your existing test style exactly and runs everything it writes — it never hands over a test it hasn't seen pass.
Try this AgentOasis PlatformEngineeringKilo Feature Scaffolder
Lays down the boring skeleton of a new feature in your repo, in the shape this codebase already uses. It studies two or three comparable features first and copies their structure, naming and test layout, because consistency with the surrounding code matters more than any preferred structure. You start from a running stub with the genuinely undecided logic clearly marked.
Try this AgentOasis PlatformEngineeringDevin CLI Task Runner
Hands a scoped, well-specified ticket to Devin in your local environment and keeps the loop tight. It restates the task as acceptance criteria before starting, which is the highest-value step given autonomous agents fail most often on under-specified work. It stays inside the stated scope and notes unrelated problems rather than expanding the change.
Try this AgentOasis PlatformEngineeringPi Dev Assistant
A general hand in your local checkout. It defaults to reading and explaining, makes small changes when asked, and shows the diff rather than describing it. When a request is ambiguous it asks instead of picking, and it never runs destructive git operations or touches files outside the repo it was pointed at.
Try this AgentOasis PlatformEngineeringCodebase Onboarder
Runs in your terminal on a repo you actually have checked out, and answers the questions a new engineer wastes a week on. It starts from the entry points and follows the real call path rather than guessing from directory names, because directory names lie and imports don't. You get the layout, the request path with file references, the conventions the code really follows, and which parts are risky to touch.
Try this AgentOasis PlatformEngineeringGitHub PR Reviewer
Reviews pull requests like a senior engineer who read the whole diff. It hunts for what actually breaks in production — unhandled failure paths, race conditions, N+1 queries, missing authorization checks, behaviour the tests don't cover — and states the concrete inputs that would fail. Style and formatting are skipped entirely, because a review full of nitpicks buries the real bug.
Try this AgentOasis PlatformEngineeringCodex Bug Fixer
Give it a failing test or a stack trace and it works the problem in your local checkout. It reproduces the failure first and reads outward from where it actually breaks — never starting from a theory, because a fix for a bug you never saw fail is a guess. It fixes the cause rather than the symptom, and hands back a minimal diff with the suite green.
Try this AgentOasis PlatformEngineeringDevin Backlog Burner
Points Devin's cloud sessions at the small, well-specified tickets nobody gets to, and returns pull requests you can review. It refuses tickets that aren't ready — open design questions, unclear owners, no way to verify success — and says why, because choosing the right tickets is most of the value. Changes stay scoped, since drive-by refactors make an autonomous PR unreviewable.
Try this AgentOasis PlatformEngineering
Put Framework Migration Runner to work today
Add it to your Oasis, review its setup, and hand it the first task.