Stop reading AI migration plans. Watch them morph.

AI rewrites your system in seconds, then buries the plan in walls of markdown and disconnected diagrams. Morffy turns that into one interactive diagram that travels through time — watch your architecture evolve, milestone by milestone.

Try the playground Download the AI Skill
morffy — live demo
Click the milestones to morph it

A real AI-generated migration plan, auto-playing milestone by milestone. Grab the timeline strip and step through it yourself — watch services morph, connections reroute, and deprecated nodes dim out. Nothing here is a screenshot.

Load your own diagram in the playground
The problem

The "Disconnected Diagram" Tax

Plan a migration with an AI agent and it's brilliant at outlining the steps — but terrible at visualizing them.

Ask for diagrams and you get two or three standalone MermaidJS charts that have no relation to one another. A box is renamed, a connector vanishes, and you do the mental math to correlate Phase 1 into Phase 2.

The solution

Hand the marker over to your AI.

Morffy replaces the pile of disconnected charts with one time-aware JSON — every component tagged with the milestone it's born in and the one it retires in. From that single source, Morffy renders one interactive diagram you scrub through like a video: drag the timeline and watch nodes appear, reroute their connections, and fade out in place. Nothing to re-draw, nothing to correlate by hand — the continuity is built in.

And you don't draw any of it. The Prompt-to-Play pipeline takes you from a conversation to a living canvas in four steps.

  1. 1

    Grab the blueprint

    Download the Morffy skill — an open-source system prompt and JSON schema template — and drop it right into your favorite LLM or development agent.

  2. 2

    Describe the evolution

    Simply chat with your AI and tell it how you want your system to change over time. The AI takes care of the structured schema, mapping out exactly when components are added, modified, or retired.

  3. 3

    Validate the blueprint

    Run npx morffy --validate ./architecture.json to check the JSON against the schema and Morffy's integrity rules — milestone bounds, parent enclosure, and connector lifespans — before you render. Any mistakes are listed with the exact element, so you can hand them back to your AI to fix.

  4. 4

    Watch it come to life

    Fire up npx morffy ./architecture.json and let Morffy handle the layout math automatically. Want to twist the plan? Just tell your AI what to adjust, and your visual viewer updates instantly.

Example prompt Paste this in once the skill is loaded 
I want to use the Morffy Topology Generator skill to model our company's transition from a legacy monolithic application to a decoupled, event-driven microservices architecture.

Here is our initial high-level engineering plan:
We currently have a monolithic Ruby on Rails backend executing everything out of a single large PostgreSQL instance. Over the next year, we need to extract our "Order Processing" capabilities into a separate service, isolate our "Inventory Control" domain, and introduce an asynchronous message broker to handle communications so the services don't hard-couple to each other. Eventually, we want to split the database into isolated persistence layers for each domain and migrate our web clients.

Act strictly under the instructions of the Morffy Dynamic Topology Generator skill. Do not write or output any JSON structures yet. Instead, play the role of an expert software architect and ask me a focused, structured set of clarifying questions to gather the missing details required for the topology mapping. Specifically, please ask me about:

1. The Milestone Roadmap: What exact phases (e.g., Milestone 0, Phase 1, Phase 2) anchor this migration, and when should legacy monolith components be marked as deprecated or removed (EMS)?
2. The Dynamic Metadata Properties: What custom tracking attributes do we want to trace over time for filtering and color-coding on the canvas? (e.g., "domain", "communicationProtocol", "hostingEnvironment", "team", "dataStoreType")
3. Element Lifecycles & Taxonomy: Are there any specific network-level abstractions (like API Gateways or Service Meshes) or shared containers we need to map to establish parent-child structural boundaries?

Once I provide these variables, you will use them to build the pristine, schema-compliant Morffy JSON payload.

Goodbye, rotting diagrams. Hello, living architecture.

You spend hours pixel-pushing a beautiful architecture diagram, and it rots the very next time someone pushes code. Morffy turns architecture into a living timeline — whether it's a 48-hour sprint, a series of Pull Requests, or a migration that spans multiple quarters, you can zoom in, step back, and watch the change happen.

Any attribute, any tag

Slice layouts by custom characteristics — environments (Dev/Prod), tech stacks, teams, domain boundaries, vendors, or security zones. Click a tag and components snap into focus while everything else dims into context.

Time-travel slider

Drag across the timeline and watch nodes smoothly appear, reroute their connections, or fade away as milestones shift. The layout math is handled for you — nothing jumps around.

The visual diff

Flip on Comparison Mode to overlay two milestones and color-code components instantly: what was added, modified, or removed — across the graph, the timeline, and the legend at once.

Static drafts vs. one living state.

Every other tool makes you redraw. Morffy keeps a single source of truth and animates the change.

Feature The static way
Mermaid / Miro / Lucidchart		 The Morffy way
Chronological time Re-draw separate diagrams entirely for every sprint or release phase. Single source of truth. Slide milestones to animate the birth and death of nodes.
Component relations Manual side-by-side visual parsing to see what changed between drafts. Native morphing. Components smoothly shift states and map continuity across milestones.
Custom taxonomy Rigid boxes with static text labels that clutter the map. Dynamic metadata. Filter and color-code instantly by domain, tech stack, or team boundaries.
Local-first

Your data stays right where it belongs: with you.

Morffy runs entirely on your local machine, served straight out of your own npm environment. There are no cloud databases to worry about, no external servers, and absolutely zero tracking. Your system diagrams are parsed locally right in your workspace, so your architectural blueprints stay confidential, safe, and completely private.

No servers No cloud DB Zero tracking
~/your-workspace running locally
📁 project/
📄 architecture.json
📁 src/
📄 README.md
$ npx morffy ./architecture.json
→ serving on localhost:4242 (local only)