Open-Source Modernization with AI — How We Resolved 702 Issues in mRemoteNG

At Geseidl, we believe excellence isn't just about the services we invoice — it's also about what we give back to the community. For over 22 years we've built tools that help us and our clients. Some of them deserve to be shared with the world.

That's why we invest in open source. Not for marketing, not for visibility — but because a better tool, used by more people, makes the world a little better. This is the makeitcount philosophy: make every contribution count.

mRemoteNG is the perfect example. A piece of software we use daily to manage our clients' infrastructure — over 50 servers, hundreds of connections. When we saw the project stagnating with 843 unresolved issues and zero prospects for updates, we decided to act.

The result? We resolved 702 out of 843 issues, grew the test suite from 2,179 to 6,175, and reduced the cost to $1.49 per commit — using an AI orchestrator we built ourselves. Everything is public, verifiable, documented.

This is the complete case study, by the Geseidl IT Solutions team. Source code: github.com/robertpopa22/mRemoteNG. Not theory — but verifiable results, public code, and lessons learned from real mistakes.

What is mRemoteNG?

mRemoteNG (multi-Remote Next Generation) is an open-source remote connection manager for Windows. It supports 16 protocols — RDP, VNC, SSH, Telnet, HTTP/S, ICA, and others — all within a single tabbed interface. It is used by system administrators, DevOps engineers, and IT teams worldwide to manage hundreds or thousands of simultaneous connections.

The project was created in 2008 as a fork of mRemote and accumulated a significant user base over the years — over 12,000 stars on GitHub before the repository reorganization. But, like many mature open-source projects, it entered a period of stagnation.

The problem: a legacy codebase adrift

When we took over the project, the situation was critical. The codebase was built on .NET Framework with Windows Forms and COM references (MSTSCLib for RDP ActiveX). The architecture relied on mutable singletons and tight coupling between components. 843 issues sat unresolved on GitHub, some years old.

Nobody had the time or resources to fix them. The volunteer team was insufficient, and the codebase complexity discouraged new contributors. Every fix risked introducing regressions in other parts of the application.

The challenge — from 843 issues to zero

Our objective was ambitious but clear: complete modernization of the project from .NET Framework to .NET 10, elimination of all static analysis warnings, resolution of accumulated issues, and passing the SonarCloud Quality Gate with A/A/A ratings.

Why it was difficult

It was not just about rewriting code. mRemoteNG had characteristics that made modernization extremely challenging:

• COM references — MSTSCLib for RDP ActiveX, components that cannot be simply replaced
• Mutable singletons — global state shared across dozens of classes, impossible to test in isolation
• Windows Forms with native interop — UI tightly coupled with business logic
• 16 different protocols — each with its own implementation, dependencies, and edge cases
• Zero architectural documentation — only source code and GitHub issues

A single developer would have needed months. A traditional team — weeks. We chose a different approach.

The solution — an AI orchestrator with 3 agents

We built an orchestration system that coordinates three AI agents, each with a specific role in the issue resolution pipeline. This is not a chatbot writing code — it is a production system with automated verification, rollback, and monitoring.

The 3 agents

Each AI agent was chosen for its strengths. Their combination covers the full complexity spectrum:

• Codex Spark (OpenAI) — the rapid triage and simple fix agent. Excellent at single-file tasks: renaming, namespace updates, static analysis fixes. Success rate: 86% in the February 27 session, 87 of 104 issues resolved on first attempt
• Claude Sonnet/Opus (Anthropic) — the agent for complex, multi-file fixes and final review. Understands broad context, can analyze cross-class dependencies, and performs safe refactoring on interconnected components. Also used as final reviewer for PRs
• Gemini Pro (Google) — the bulk transformation agent. Ideal for applying the same pattern across dozens of files: eliminating CS8618 warnings (nullable), updating deprecated APIs. Fixed 466 of 852 CS8618 warnings in a single session

The resolution pipeline

Each issue goes through a rigorous pipeline where quality is verified by deterministic tools, not AI:

1. Sync — imports issues from GitHub, classifies by labels and complexity
2. Triage — the agent analyzes the issue, estimates effort, and proposes a resolution strategy
3. Implement — the agent writes the code. If the first agent fails, the next one takes over (Codex → Gemini → Claude, in cascade)
4. Verify — full build + run all 6,175 tests. ZERO AI involvement — only MSBuild and dotnet test
5. Atomic commit — if all tests pass, the change is committed with a reference to the original issue

The crucial element is step 4: verification. AI does not decide whether the code is correct — the build and tests decide. If tests fail, the implementation is automatically rejected and retried with another agent or escalated to human review.

Self-healing supervisor — 800 lines of Python

The initial orchestrator had a problem: it would stall. AI agents could enter loops, generate corrupted files, or exhaust token contexts. We built a supervisor that monitors the orchestrator and automatically handles 12 distinct failure modes.

The supervisor detects: agent timeouts (kill + retry with different agent), infinite loops (abort after 3 attempts), merge conflicts (automatic rollback), API rate errors (exponential backoff), and other scenarios. Everything logged, everything auditable.

Evolution through 4 generations

The system did not work perfectly from day one. It evolved through 4 generations, each built on the lessons from the previous generation's failures:

• Generation 1 — Brute force: single agent, one attempt per issue. 26 issues/sprint, lots of manual work. Costly and slow, but validated the concept
• Generation 2 — Multi-agent: 3 agents with cascade. The "double-pay" problem emerged — when one agent fails and the next takes over, you pay twice. We optimized routing to send directly to the right agent
• Generation 3 — The 31-hour disaster: we let the orchestrator run unsupervised overnight. It created 201 phantom tests (tests that passed but tested nothing real), modified configuration files, and corrupted the repo state. We spent an entire day cleaning up. The lesson: unsupervised AI = real danger
• Generation 4 — Self-healing supervisor: the 800-line supervisor, with 12 failure modes handled automatically. Regression rate: 1.2%. Cost stabilized at $1.49 per commit

Verifiable results

We do not present estimates or projections — but measured results, verifiable by anyone on the public repository. Every number below can be confirmed from commit history, the SonarCloud dashboard, or GitHub issues.

Issues resolved

702 out of 843 issues resolved — a rate of 83.3%. The remaining 141 are either feature requests requiring product decisions or issues specific to hardware configurations we cannot reproduce.

Code quality

• 5,247 static analysis warnings completely eliminated — from 5,247 to 0
• SonarCloud Quality Gate: PASSED with A/A/A rating (reliability, security, maintainability)
• Tests: from 2,179 to 6,175, all green, 0 failures
• VirusTotal: 0 out of 75 detections — including resolution of a BitDefender false positive that blocked installation

Cost efficiency

• Cost per commit: $1.49 (stabilized, down from $4.02 on day one)
• Total project cost: approximately $320 over the entire modernization period
• Regression rate: 1.2% — only 7 out of 585 implementations introduced regressions

Record session — February 27

In the February 27 session, Codex alone resolved 89 out of 104 issues (86%). 87 were resolved on the first attempt, without human intervention. The 15 failures were escalated to Claude for complex fixes.

What we learned — 5 key lessons

The mRemoteNG modernization gave us valuable lessons about using AI in real software projects. These are not theoretical lessons — each came with a concrete cost.

1. Simplicity beats complexity

A single agent with good context solves more problems than three complicated agents. The February 27 session demonstrated this: Codex with a well-structured prompt and adequate context had a success rate of 86%. The complex multi-agent system from generation 2 managed only 71%. More agents means more failure points, more coordination, more cost.

2. Automated tests are necessary but NOT sufficient

Out of 585 implementations, 7 introduced regressions that passed ALL 6,175 tests. Tests verify specified behavior — but AI can modify unspecified behavior that was nonetheless important. We discovered regressions only during human review and manual testing.

3. AI adds unsolicited "features"

The most dangerous AI agent behavior is not making mistakes — it is "improving" code without being asked. We found cases where AI added extra logging, modified error messages, changed output formatting, or "optimized" algorithms that were working correctly. Every such unsolicited modification is a regression risk.

4. Output tokens = 97% of cost

We analyzed costs by category and discovered that output tokens represent 97% of total cost. Every verbose explanation the AI generates — long comments, detailed justifications of changes, context summaries — costs real money. We reduced cost per commit from $4.02 to $1.49 primarily by requesting concise responses and eliminating verbosity.

5. Human oversight remains essential

AI incorrectly triaged 38% of exclusion decisions — marking issues as "won't fix" or "not reproducible" when they were actual problems. Without human review of exclusion decisions, we would have missed important fixes. AI is an excellent execution tool, but strategic decisions must be validated by humans.

Upstream and community

All changes were submitted upstream via PR #3189 — 761 files changed, 64,263 lines inserted. It is one of the largest PRs in the project's history.

We published complete documentation: a scientific paper describing the methodology, detailed cost analysis, a catalog of 12 failure modes and remediation strategies. Everything is open-source and reproducible by anyone.

Our fork repository is available at github.com/robertpopa22/mRemoteNG. It includes the orchestrator code, agent configurations, and complete documentation.

What comes next

We continue to maintain the fork and contribute to the upstream project. The lessons learned here are applied across all our IT services projects — from legacy application modernization to CI/CD pipeline implementation.

The mRemoteNG modernization demonstrates what is possible when you combine technical expertise with responsibly used AI tools. Not magic — but disciplined engineering, with verification at every step.

Learn more about our team and philosophy on our about us page or explore our IT services.

Need professional IT services? The Geseidl Consulting Group team, CECCAR Prahova leader for 18 consecutive years, is ready to help. Discover our services or contact us for a free consultation.