AGENTIC AI MODERNIZATION
VELO

Agentic AI for Legacy Application Modernization

VELO combines agentic AI with GAPVelocity AI’s modernization expertise to move your applications to modern platforms while preserving the business rules that matter. Start with an assessment of your application, its dependencies, and the work ahead.

See how it works
Our partners
Microsoft Solutions PartnerProgress
20x
faster to production
60%
lower cost than a manual rewrite
35+
years of modernization expertise
1B+
lines of code modernized
Our customers

What modernization makes possible

  • Recover the business knowledge your original developers took with them.
  • Modernize in funded phases instead of one long rewrite.
  • Move onto a supported platform that holds up to support and audit review.
  • Get past the point where an AI coding assistant stalled.
  • Give customers the modern platform they are asking for.
  • Bring overlapping systems from an acquisition onto common ground.
CUSTOMER PROOF

Real applications. Measurable results.

One story at a time. Slide to see the next.

01 / 03
Customer story
5 min watch

How JETNET is modernizing a mission-critical VB6 application without rebuilding it from scratch.

Eric Foss, Head of Technology at JETNET, on choosing a phased path, why Blazor suited experienced VB6 developers, and how C# and .NET training preserved the team’s domain knowledge. Featured at .NET Conf: Focus on Modernization.

VB6 · ~250K linesWinForms → Blazor
Drag or swipe between stories
“GAP has done so many modernizations – they have a total command of the modernization domain space.”
— Greg Duhachek, CEO at AgWorks, as attributed in the published case study
INTERACTIVE PLAYGROUND

See VELO in action

Pick a legacy technology, then compare the original code with VELO’s modernized output, watch both applications side by side, or open the deployed app.

Choose a sample technology
VBVisual Basic 6C#
Click a pane to focus it
VB6 frmUsersManage.frm
Private Sub cmdSave_Click()
  If TextBoxEmpty(txtUsername) Then Exit Sub
  If TextBoxEmpty(txtPassword) Then Exit Sub
  If TextBoxEmpty(txtFullname) Then Exit Sub
  If ComboEmpty(cboLevel) Then Exit Sub

ExecuteSql "Select * from Users where Username = '" _
& txtUsername & "'"

If cmdSave.Caption <> "&Update" Then
If Not rs.EOF Then
MsgBox "Add failed: Username already exists"
Exit Sub
End If
If cboLevel.text <> "Administrator" Then
ExecuteSql2 "Select * from Users where " &
"level = 'Administrator'"
If rs2.EOF Then
MsgBox "No any Administrator found..."
Exit Sub
End If
End If
If Not CurrentUserAdmin And _
cboLevel.text = "Administrator" Then
MsgBox "You cannot add another level..."
Exit Sub
End If
rs.AddNew
msg = "Added new user " & txtUsername
End If
' ...
rs.Fields!UserName = txtUsername
rs.Fields!Password = txtPassword
rs.Fields!Level = cboLevel
rs.Fields!Fullname = txtFullname
rs.Update
LogStatus msg
End Sub
C# · Blazor Server UsersManageService.cs
public async Task SaveAsync(
UserManageSaveRequestDto request,
bool currentUserIsAdmin,
CancellationToken ct)
{
if (string.IsNullOrWhiteSpace(request.UserName))
return new(..., "Fill in all required fields");
// ... same check for Password, Fullname, Level

await using var db =
await _dbFactory.CreateDbContextAsync(ct);

if (!request.IsUpdate) {
var existing = await db.Users
.FirstOrDefaultAsync(
u => u.UserName == request.UserName, ct);
if (existing != null)
return new(false, "Username already exists");

if (!request.Level.Equals("Administrator", ...)) {
  var adminCount = await db.Users
    .Where(u => u.Level == "Administrator")
    .CountAsync(ct);
  if (adminCount == 0)
    return new(false, "No Administrator found");
}

if (!currentUserIsAdmin &&
    request.Level == "Administrator")
  return new(false, "Cannot add Admin without...");

db.Users.Add(new User {
  UserName = request.UserName,
  PasswordHash = request.Password,
  Fullname = request.Fullname,
  Level = request.Level,
  IsActive = true,
  CreatedDate = DateTime.UtcNow
});
await db.SaveChangesAsync(ct);
return new(true, $"Added new user {request.UserName}");

}
// ... update path
}

What this does

All four account rules carry over one-to-one: a username must be unique, the system must always keep an Administrator, only an Administrator can create another, and renames are checked for collisions. The lookups become parameterized queries, and the form controls and globals are replaced by a typed request.

Public reference apps · Source on GitHub · Live deployed demosScan my code

FAQ's

How is this different from using an AI coding assistant?

An AI coding assistant works at the level of a file or a prompt. It sees the code you paste into it, generates a plausible translation, and has no record of the rules that live elsewhere in the application. That works for isolated functions, and it is why assistants often make early progress and then stall on a real application.

VELO works at the level of the whole application, in four stages with engineers involved in each:

  • Evaluate the initiative: the application, its goals, the source and target technologies, and the initial scope.
  • Audit the codebase: analysis of the actual code to find dependencies, complexity, and the business rules spread across forms, modules, and the database.
  • Modernize: transformation toward an agreed target architecture, carrying those rules forward.
  • Evaluate the results: validation of the modernized application against the agreed requirements before anything moves forward.

In practice that means rules are identified and documented before translation starts, so they are not lost when the code changes shape. The playground above shows one example: four account-validation rules from a VB6 form carried into a C# service, with string-built SQL replaced by parameterized queries along the way.

How is my source code handled?

Before you provide any access, our team walks you through the code-sharing process and discusses your confidentiality requirements. Nothing is requested at the assessment-request stage.

During the engagement you keep ownership of your application and its source code. At the end you receive the full modernized source, and you know how your original code is handled once the engagement closes.

If your organization has specific requirements, such as an approved transfer method, restricted environments, or a review by your security team, raise them in the first conversation so they can shape the plan rather than delay it.

Which platforms can you help modernize?

Common source technologies include VB6, VB.NET, WinForms, ASP.NET WebForms, PowerBuilder, Microsoft Access, Delphi, and Clarion. The usual target is C# on .NET, with Blazor for the user interface. Azure is a common destination when cloud hosting is part of the goal.

The right route depends on the application, not just the language. Questions we look at early include:

  • Third-party controls and COM or ActiveX dependencies, and whether they have modern equivalents.
  • Where data access lives: in forms, in shared modules, or in stored procedures.
  • Reports, printing, and integrations with other systems.
  • Whether a phased path makes sense. One customer moved from VB6 through WinForms toward Blazor, so the team could adopt C# and .NET in steps.

If your technology is not listed, ask anyway. The assessment is the point where supported routes and deliverables are confirmed for your specific application.

How is the investment determined?

The proposal is shaped by four things: the size and structure of the application, the target platform, its dependencies, and the deliverables you need. A self-contained desktop application and a portfolio with shared databases and integrations are scoped very differently.

The assessment is where that scope becomes concrete. It produces an application inventory, a dependency map, the business rules found, and an estimate, so the proposal is based on your code rather than on assumptions about it.

Work is typically structured in milestones, so you can see progress, understand what remains, and decide at each point before committing further.

What happens after the assessment?

You review the findings with our engineers: the inventory, dependencies, business rules, and estimate. The review covers what the code shows, where the risks are, and which approach fits your goals.

From there you decide the next step. Typical options are a scoped proof on one of your real modules, a full engagement, or a pause while you take the findings to your stakeholders. We explain the proposed work and its deliverables before you commit to anything further.

The assessment findings are yours whether or not you continue.

What do we receive at the end of an engagement?

Deliverables are agreed up front and depend on the engagement, but they are built around three things: the modernized application and its full source code; documentation of the business rules and the target architecture; and the results of validation against the agreed requirements, including a clear record of anything that remains.

The goal is a codebase your own team can maintain. The modern code follows current .NET conventions, such as dependency injection, async data access, and services separated from the UI, so it can be extended and tested after handoff.

Let’s look at your application.

Start with a free assessment and receive a practical starting point for your modernization decision:

  • Application inventory
  • Dependency map
  • Business rules found
  • Estimate

These findings are yours whether or not you continue.