A Leading Commercial Vehicle Manufacturer in North America

Quick Facts

Executive Summary

A leading commercial vehicle manufacturer in North America was supporting a mission-critical legacy application built over decades, with limited documentation and too much system knowledge concentrated in too few people, many of whom were no longer with the organization. Axian built a RAG-backed support solution that could retrieve context from the codebase and supporting system knowledge, giving the client’s team a more usable way to diagnose issues without relying on a single expert. The result was faster troubleshooting, stronger internal support capability, and a more controlled path to modernizing selected legacy functionality.

About the Client

The client is a major commercial-vehicle manufacturer in North America. The application at the center of this work supported truck operations that the company could not afford to disrupt, as downtime is measured in millions of dollars lost.

That work depended on a fragile, critical legacy system that had already become difficult to support.

The Challenge

The client was relying on a legacy application that remained critical to the business even as it became less reliable and harder to support. Built over more than 20 years by different contributors, the system had little documentation and enough mainframe complexity to make troubleshooting slow and uncertain when issues surfaced. When the application ran into problems, teams had no dependable way to diagnose them quickly. 

The bigger risk sat in concentrated knowledge. Attrition and retirements had already thinned out the pool of people who understood the system, and unresolved vehicle issues were beginning to build up. As Axian worked through the root causes, the hardest support questions increasingly funneled to one expert. That helped in the short term, but it recreated the same problem in a new form: the most reliable path to keeping a strategic system running now depended on one person. 

That model could not scale. The application touched a critical internal system area that internal stakeholders viewed as too critical to fail, and the broader support pattern was already slowing response cycles across IT and engineering. Left alone, the client was facing a familiar enterprise problem: a system the business depended on, a shrinking pool of people who understood it, and no durable way to turn that knowledge into repeatable support.

The Solution

Axian built the solution as a support system first. At its core was a RAG knowledge base tied to an interface that the client team could query when the application failed or behaved unexpectedly. The aim was to make years of hard-won system knowledge usable beyond one person, so support did not depend on memory, escalation, or a shrinking pool of legacy expertise.

The implementation of RAG is pretty straightforward, but making it work and making it useful is the challenging part.

Rick White

Solution Architect at Axian 

That is where the work went. The first passes were weak because the codebase did not behave like clean reference material, and real support questions required more structure and context than raw ingestion alone provided. Axian tightened the guardrails, rewrote the retrieval approach around the way the client data was actually laid out, and stopped treating ingestion as a one-time step.

A meaningful part of the build journey was learning that real-world RAG quality had to be earned through iteration. Early ingestion of raw code alone did not produce reliable support answers, so Axian refined chunking, retrieval, guardrails, and CodeWalk-style supporting artifacts over multiple passes. Just as importantly, the team learned that retrieval gains only mattered if they were operationalized and carried through deployment, turning evaluation artifacts into managed production knowledge assets.

The biggest obstacle sat inside the COBOL itself. The client files were commented and structured differently from standard COBOL conventions, so the first chunking pass broke the code into the wrong units and buried the relevant context. Later, the system regressed again after deployment because an evidence file built during evaluation was left behind. Axian then ingested that file as a primary source and expanded it into a detailed code walk, which gave the RAG system a far better map of the codebase and improved answer quality.

That experience also showed that raw source code was not always the best retrieval surface by itself; structured CodeWalk artifacts made the system more useful because they added missing explanation and context.

Axian also treated expert review as part of the build, working with subject matter experts and vehicle engineering to distinguish grounded answers from answers that only sounded convincing. That discipline mattered in a support environment where a technically convincing answer could still be wrong if it was not rooted in the client systems and data.

The project reinforced that a RAG prototype is not the same as a production-ready support system; the surrounding retrieval, evaluation, and deployment discipline mattered just as much as the model itself.

Technologies and Architecture

Technology Stack:

• Frontend: React/Vite UI
• Backend: .NET 9 API
• Data layer: Postgres with vector indexing
• Infrastructure: Azure, Kubernetes 
• Agent tooling: Specialized MCP skills with CLI/IDE integration

Architecture Highlights:

The front end gave the client team a direct interface for querying the support system. The .NET 9 API handled application logic and retrieval flow, while Postgres with vector indexing enabled contextual retrieval across the codebase and supporting artifacts. Specialized MCP skills with CLI/IDE integration supported both agent-assisted analysis and the development team’s work on the system. Azure and Kubernetes provided the deployment foundation as the system moved toward launch. 

The more important architectural decisions sat upstream of the stack. Retrieval quality depended less on the model itself and more on how the source material was prepared, structured, and promoted into production. The client COBOL had to be chunked to match the way the code was actually structured, and the evidence file created during evaluation had to move into production as part of the knowledge base. Without that preparation, the stack could run, but the answers would not hold up.

Results and Impact

Quantified Outcomes:

Business Impact:

The biggest immediate win is giving the client’s internal team the ability to support complex strategic applications quickly and efficiently.

Bryant Alvey

Partner at Axian

• Gave the client’s internal team a faster way to support a complex strategic application.
• Reduced dependence on a narrow escalation path around one expert.
• Created a path to rely less on internal mainframe specialists over time.
• Established a support pattern that may transfer to other hard-to-support legacy applications

Client Perspective

This technology removes any excuses from my team to resolve system incidents in minutes, not days or weeks.  The impact to the business and our customers is immediately being felt..]

Level 4 IT Manager

Client

Looking Ahead

Axian’s next step with the client is to move   a selection of related processes out of the mainframe and into Azure on .NET while preserving the existing DB2 environment. The scope is intentionally narrow, starting with one bounded slice of functionality rather than a broad rewrite. That gives the client a controlled way to modernize a critical system without taking on the risk of replacing everything at once.

Support Legacy Systems with More Control

When legacy systems outlast their documentation, support risk grows quickly. Axian helps organizations turn fragile, expert-dependent systems into scalable, supportable solutions.

www.axian.com/contact | 503-644-6106 | salesinfo@axian.com

Related Case Studies

Strategies to Deliver Real World Success with AI

Deployment of Containers and Kubernetes