Meet Horst, Uwe and Greta: how three AI agents make legacy migration safe

Legacy modernization rarely fails because of technology. It usually fails because teams lack a clear overview. 

An MCP based toolkit combines code analysis, architectural knowledge and migration context. 

It is useful for mature client centered frontends built with Angular, React or Vue.js. The toolkit helps teams understand updates, templates, services and tests in a structured way and modernize them step by step. 

In this setup, specialized agents work together to turn legacy code into clear migration plans, actionable development steps and quality assured graph results.

Why migrations need central system knowledge 

Legacy systems are rarely cleanly separated. This is especially true for mature frontends, where a change to an Angular component can quickly affect UI behavior, data flows, business logic and test reliability. 

Teams therefore need clarity before they start. They need to understand what is connected, what is critical and where risks may arise. 

A generic AI agent can explain code and suggest migration steps. But these suggestions only become reliable when they are based on project specific and verified system knowledge. 

Turning code into structured knowledge 

The AI agent, automatically reads existing code. It identifies architecture, components, dependencies and business logic, then transfers this knowledge into a Neo4j knowledge graph. 

Instead of producing a loose report or a simple file list, it creates a connected system map in Neo4j. 

This map can be understood by people and used by AI agents through MCP. 

The illustration shows the core of the approach. The agent analyzes the code, the graph structures the knowledge and AI coding agents access it through MCP. 

This makes the verified context directly usable within the development environment. 

 Making parser output usable for AI agents 

Before AI agents can work reliably with a codebase, the code first needs to be translated into a common structure that is easier to compare, analyze and reuse. 

This is the role of the parser. It reads the source code and turns it into structured information. In the next step, this information is stored in a graph database, where the individual parts of the code are connected like points in a network. The graph can show, for example, which component uses which service, where data flows and which parts of the application depend on each other. 

This is especially important because frontend and backend systems are built differently. In frontend applications such as React or Angular, the focus is often on screens, components and the movement of data between them. In backend systems, the focus is more often on services, business logic and process flows.  

The analysis reflects these differences, so the results remain meaningful for each area. 

Once the structured parser output is available in the graph, it becomes usable AI context. Because the parser works in a deterministic way, the results are reproducible and consistent. The same code leads to the same analysis result every time. 

In practice, this gives teams a clearer view of their software. They can understand what exists, what depends on what and where changes may have an impact. This supports modernization, migration and refactoring projects across different technologies and programming languages. 

Seven system dimensions for safer migration 

In frontend modernization, many important dependencies are hidden across the codebase. A component may look isolated, while its real behavior depends on templates, services, routing, forms, state handling, tests and shared libraries. 

We can now make these connections visible through seven system views. Together, they show how the application is structured, where change creates risk and which areas need attention during modernization. 

1. Project structure: identifies which components, services, modules, libraries and layers exist in the system. 

2. State management: highlights where state is created, changed and used in application flows. 

3. Business logic and control flow: shows where business logic is located and which decision paths are critical. 

4. Design system migration: reveals which UI components, templates, bindings and forms are affected by a migration. 

5. Monorepo and architecture evolution: maps which project structures, imports, module boundaries and Angular or NX update paths need to be modernized. 

6. Test coverage: captures which artefacts are not sufficiently protected by tests and where test debt is building up. 

7. Template analysis: makes visible which templates, data bindings and UI patterns are relevant for a migration. 

The practical value of connected code knowledge 

The comparison shows the difference the graph makes in everyday work. 

In migrations, teams can make decisions based on traceable relationships in the code instead of relying on assumptions. 

This becomes especially useful when teams ask concrete migration questions.  

The table below shows such typical questions that become easier to answer with graph based analysis. Instead of asking an AI agent to guess from isolated code snippets, the team can query verified relationships in the system. 

The graph turns the codebase into a connected system map. It makes existing elements visible, shows how they depend on each other and reveals where a change will create an effect. 

From graph to guided workflow 

The main value comes from the interaction between specialized agents. We named these agents Horst, Uwe and Greta. 

• Horst uses the graph as a senior Angular architect. He prepares update paths, architecture decisions, module boundaries and migration waves with lower risk. 

• Uwe works from this foundation as an Angular frontend developer. He carries out concrete implementation steps for components, templates, services, tests and design system adjustments. 

• Greta takes care of graph quality assurance. She checks whether the knowledge base remains consistent, complete and reliable enough for further decisions. 

The MCP server connects these roles with the toolkit. As a result, all agents work with the same verified context instead of producing isolated answers.

Lessons from real migrations 

Real modernization projects reveal several lessons that are relevant beyond a single technology. 

• Clear phases make complexity manageable. Large migrations should be split into understandable waves instead of being handled in one big bang. 

• Frontend migrations benefit strongly from structured context. This is especially true for Angular updates, template adjustments, form logic, design system changes and NX monorepos. The graph reduces manual research and makes affected areas visible early. 

• The knowledge graph creates a reliable basis for decisions. Architecture decisions become explicit, verifiable and easier for the team to understand. 

• Test debt needs to become visible early. Once missing test protection can be seen in the graph, teams can address it in a targeted way. 

• The best migration path is not always the one that was originally planned. Verified system context helps teams check assumptions and adjust the path when needed. 

• Low risk transitions pay off. Step by step migrations, reviews, graph snapshots and fallback options increase stability during ongoing operations. 

• A safety net must be in place, even when it is ideally never needed. Documented phases, tags, snapshots and recovery information make progress more reliable. 

Controlled migration with shared system knowledge 

The real value of AI supported modernization is not faster answers alone. It comes from a shared and traceable knowledge base that helps teams understand complex systems, identify risks earlier and prepare migration decisions with more confidence.  This only works when knowledge and responsibility are clearly connected. The agents support analysis, research, implementation and quality assurance, but they do not make decisions on their own. Horst structures the migration path, Uwe supports concrete implementation steps and Greta checks the quality of the graph. Architecture decisions, approvals and responsibility remain with the team.  Each phase creates verifiable artefacts. The current state, change history and graph snapshots remain available, even when a chat session ends or another team member takes over. This creates a human in the loop process where AI accelerates analysis, while the team stays in control.  In customer projects, this workflow helps teams understand complex system landscapes faster and prepare migration decisions more precisely. This is especially useful for mature Angular frontends, where updates become more plannable and affected UI, service and test layers become visible earlier. Migration work can then be carried out step by step, with more stability and better conditions for future feature development.