In 2025, the forces driving application modernization converged. Cloud innovation reset expectations for speed and adaptability. GenAI did the same, both as a capability embedded in products via the Model Context Protocol (MCP) and as a catalyst for GenAI-assisted development. Release cycles compressed. What once took months can now happen in days.
However, this acceleration came with limits. In greenfield systems, teams can change and adapt more quickly with relative ease. In brownfield applications, it isn’t that simple.
GenAI tools and agents can dramatically accelerate code generation, class refactoring, and fixing isolated issues, but only with sufficient context. Without it, especially in large code bases, they amplify dependency hell, accelerate architectural drift, and compound technical debt, often resulting in significant costs as teams burn through small fortunes of LLM tokens.
How 2025 laid the groundwork for reliable agentic modernization in 2026
Modernization works when teams understand how their software actually behaves and can act with confidence. In 2025, customer-led modernization of complex, business-critical systems directly shaped the releases we shipped, including:
- Architecture-aware prompts that guide code assistants like Cursor, Kiro, and GitHub Copilot for safe, fast modernization
- An architectural query engine that lets teams ask precise questions about dependencies, risk, and extraction paths at scale
- Support for megaliths and the ability to modernize massive, mission-critical applications at scale
- Real-time architecture documentation that replaces static diagrams with living UML and C4 views for application components, sequences, and flows
Alongside these releases, we expanded our collaboration with AWS, participating in key AWS modernization programs (ISV tooling, ISV accelerate), earning the AWS Resilience Competency, and supporting customers modernizing some of the largest and most complex applications running in the cloud.
Enabling the agentic shift
In 2025, we laid the foundation for architecture-driven, assistant-guided modernization. Instead of asking engineers to “go figure out” dependencies and risk manually, vFunction addressed hard questions at scale and delivered that context directly into developer IDEs.
The agentic baseline for modernization
Now, in 2026, the next step is clear: bringing that foundation together into a more agentic experience, where AI can act, guided by the system’s architectural intent. This puts users in the driver’s seat of the modernization project, giving them control and oversight, and allowing them to provide the intent (the “what”) while letting the agent handle the implementation details (the “how”).
vFunction 4.5 introduces the vFunction Agent, grounded in real architectural intelligence, establishing a new baseline for how monolith modernization happens.
This is no longer about surfacing architectural insight or asking better questions. The vFunction Agent is designed to act on that intelligence. Through a conversational interface in the vFunction UI, teams can move directly from architectural understanding to execution by reviewing, prioritizing, and acting on tasks (TODOs) within a single workflow.
Examples of how the vFunction Agent helps teams modernize applications:
- What should I do to extract domain A?
- Which domains and TODOs should I start with?
- Refactor class A while taking into account all domains that may be impacted.
The agent operates on top of a shared architectural context that spans the UI, MCP server, and coding assistants, ensuring every action aligns with the system’s architectural intent and delivers a smooth, consistent experience across platforms. Teams can also embed implementation notes directly into TODOs, allowing human input to shape how agent-driven refactoring is executed.
From insight to confident action
Agentic modernization only works if teams trust the recommended changes.
In 4.5, the TODO experience was designed to reduce friction and increase confidence. The revamped TODO dashboard allows teams to focus on relevant signals and review details in a dedicated reading pane, making it easier to move from identification to execution without losing context.
At the same time, clear confidence thresholds for dead code help teams understand when removal is safe. This capability was driven directly by a large financial services customer running a long-lived, business-critical application with an overwhelming amount of dead code. The issue wasn’t simply identifying unused classes; it was deciding what could be removed without introducing risk. Manual review wasn’t scalable, and abstract risk scores weren’t actionable enough for engineers responsible for core systems.
Instead of surfacing risk in the abstract, 4.5 provides practical signals that support decisive action. These signals are incorporated directly into the TODO creation algorithm, helping teams prioritize the right tasks and eliminate background noise so engineers spend less time debating risk and more time making forward progress.
From confidence to controlled execution
Teams use Agents as part of modernization efforts and may also want to develop their own agents as part of their product. With 4.5, vFunction makes it possible to turn specific business actions within an application into clearly defined entry points that AI agents can use through MCP. These actions are exposed intentionally, governed by the application’s architecture, and designed to integrate directly with AI agent platforms such as Amazon Bedrock.
This allows customers running on AWS to connect trusted, architecture-aware actions to Bedrock-based agents, enabling modernization work to move forward with clear boundaries, oversight, and alignment with AWS’s agent ecosystem.
Extending the agentic baseline to MongoDB
For agents to act with confidence, they need a complete and accurate view of how data is actually used. vFunction has long incorporated relational databases into its architectural model. This data is crucial for understanding the inner workings of the application, and for giving teams visibility into how services and domains interact with SQL-backed data. But as more applications adopt document stores and hybrid data architectures, gaps in data context become a limiting factor.
Modernization depends on eliminating those blind spots so recommendations and actions reflect the full reality of the system, not just part of it. With 4.5, MongoDB becomes a first-class part of the architectural model.
MongoDB collections are now parsed and analyzed alongside SQL database tables, giving the vFunction Agent a consistent view of data usage and dependencies across relational and non-relational stores, enabling safer, better-informed refactoring.
A shift in modernization
Together, these changes mark a shift in how modernization happens, laying the foundation for it to become increasingly autonomous. Agents don’t just suggest changes; they act within the boundaries defined by the system’s architecture:
- Architectural context determines what can change
- Confidence signals determine when it’s safe
- Agents carry that intent through execution
That combination, agentic automation grounded in architectural intent and confidence, is made possible by the foundation we laid in 2025 and defines the baseline we’re establishing for reliable agentic modernization in 2026.
