Know exactly what couples you to your AI vendor — in verified terms.
Migrai scans an AI-powered codebase, cites every point of provider coupling down to file and line, and turns "we should switch models" from a leap of faith into a planned, reversible operation.
Every AI feature quietly
marries a vendor.
SDK imports, model names, streaming flags, tool schemas, prompt shapes — coupling accumulates across the codebase, and nobody can answer what switching would actually take.
Provider assumptions hide in imports, client calls, response parsing, and env vars. There is no inventory.
"How hard is it to move to Anthropic / a local model?" gets answered by opinion, not evidence.
Migration attempts mutate code with no snapshot, no diff, no validation, and no honest way back.
Tools that "analyze your code" with a chat model can't show their work. Findings without evidence are vibes.
A control plane for
the whole migration.
Migrai treats vendor migration as an engineering operation: scan deterministically, assess with evidence, plan the change, apply it reversibly, and watch every step in an event-sourced monitor.
No model in the loop. Every finding cites file, line, and snippet — same input, same output, testable against golden fixtures.
Findings roll up into provider-neutral capabilities, checked against target providers for real compatibility — not marketing parity.
The migration runtime snapshots before touching anything. Every applied change has a diff, a validation, and a rollback path.
The migration copilot reads the evidence and drafts assessments. It never acts alone; the operator stays in command.
200 hits, no context →
"should be easy?" →
3-week surprise
capability graph →
compat check vs target →
plan → apply + validate →
rollback if not
From "who are we coupled to?"
to a verified move.
Every stage emits structured events into the monitor. A migration is a state machine with evidence at each gate — not a heroic branch.
Point a workspace at any local git repository.
Deterministic coupling scan; findings with cited evidence.
Findings roll up into provider-neutral capabilities.
Check capabilities against the target provider.
Scope the migration into ordered, reviewable changes.
Snapshot, apply, validate — or roll the whole thing back.
Built like infrastructure,
not a demo.
Nineteen milestones, each closed with specs, ADRs, and a verification report. The console is the projection of an event log — not the other way around.
SDK imports, invocations, streaming, tools, prompts — no LLM in the loop, golden-tested.
Every finding opens to file, line, snippet, and confidence. Claims are checkable.
Provider-neutral rollup of what the codebase actually uses — the migration's real surface.
Capabilities scored against target providers before anyone writes a line of migration code.
Closed event vocabulary; every run streams live and replays later, byte for byte.
Snapshot → apply → diff → validate → rollback. Changes are operations, not accidents.
Evidence-first agent with a strict settings chain — workspace, global, env, or fully scripted.
Runs entirely on your machine. Credentials never leave the server process — by doctrine.
Real screens.
Real scan.
Not a mockup — a live scan of an OpenAI-coupled agent codebase: grouped findings, cited evidence, and the event monitor streaming the run.
One scan.
A checkable coupling inventory.
Every scan resolves to grouped, evidence-cited findings — the raw material for the capability graph, the compat check, and the migration plan.
Migrai is migration control for AI systems — not a linter, not a chat log, not a leap of faith.
It is the operator layer for teams who refuse to let a vendor choice made in a sprint become a permanent architecture decision.