Every Agent Against the Same Legacy Repo

When a development team inherits a massive codebase built on outdated frameworks, the initial instinct is often a total rewrite. However, modern engineering demands a more surgical approach. Testing every agent against the same legacy repo provides a clear look at how different autonomous tools handle technical debt, undocumented logic, and spaghetti code. By observing how various AI models interact with the same complex file structures, developers can identify which specialized tool is best suited for specific refactoring tasks.

The Challenge of Legacy Code Analysis

Legacy repositories often suffer from a lack of type safety, missing documentation, and deeply nested dependencies. Traditional IDE searches can only go so far when the logic is obscured by years of hotfixes. AI coding agents change this dynamic by indexing the context of the entire project to suggest architectural improvements. When you run multiple agents against the same codebase, you begin to see distinct patterns in how they navigate these challenges.

Some agents excel at tracing execution flows across multiple files, while others are more effective at writing unit tests for functions that lack clear inputs and outputs. The goal of this experiment is to determine how to leverage these strengths without losing track of the overall system state.

Comparing Agent Architectures

Not all coding agents are built with the same philosophy. Some are designed to be concise command line utilities, while others attempt to act as full collaborators that can edit files directly.

• Claude Code: Known for its nuanced understanding of complex instructions and ability to reason through multi step architectural changes.
• Codex CLI: Often focuses on rapid generation of boilerplate and specific function completions based on local context.
• OpenCode: A flexible alternative that allows for significant customization in how the agent interacts with the filesystem.

These tools differ in approach when it comes to state management. A tool that excels at writing a single Python script might struggle when asked to refactor a monolithic Java application with circular dependencies. Using a dedicated canvas to organize these agents allows a developer to see these differences in real time.

Running Agents Side by Side

The traditional way to test agents is to run them sequentially in a standard terminal. This makes it difficult to compare their outputs directly. A better method involves a multi panel workspace where each agent operates in its own isolated environment but remains visible to the developer.

By placing terminals side by side, you can issue the same prompt to three different agents. For example, asking all three to find a memory leak in a legacy Express.js middleware will yield three different strategies. One might suggest a library update, another might find a specific unclosed database connection, and the third might offer a complete rewrite of the logic.

Managing the Workspace

When you are deep in a legacy migration, the amount of open information can become overwhelming. You might have one agent running a heavy migration script, another generating documentation, and a third running a test suite. A local-first approach ensures that even if you are processing large amounts of sensitive proprietary code, the data stays on your machine.

Deska provides an environment where these coding agents can be managed as individual panels. You can zoom out to see the entire landscape of your refactoring project or zoom in on a specific agent thread. If you need to step away from your desk, the mobile app allows you to monitor the progress of long running scripts via a secure relay without exposing your local ports to the internet.

The Role of the Human Developer

Despite the power of these agents, the developer remains the orchestrator. Agents can hallucinate or suggest patterns that are technically correct but incompatible with the specific business logic of a legacy system. This is where Ask Deska becomes useful. It acts as a meta assistant that can drive the workspace itself, opening new panels or checking the status of existing sessions when the user provides voice or chat commands.

1. Define the scope of the refactor.
2. Initialize multiple agent threads for comparison.
3. Review the proposed changes in a built-in code editor.
4. Execute tests in a side panel to verify the agent's work.
5. Save findings in a persistent notes panel for the rest of the team.

FAQ

How to run multiple AI agents at once?

Using a workspace that supports multiple terminal panels is the most effective way. You can trigger different agents like Claude Code and OpenCode in adjacent panels to compare their logic and file editing capabilities on the same repository.

Are AI agents safe for private legacy code?

Safety depends on the tool and the underlying model. A local-first workspace keeps your actual files and session data on your hardware. If you use a BYOK model, your API provider processes the prompts, but the integration remains on your machine.

Can I monitor AI coding tasks from mobile?

Yes, some advanced workspaces offer a secure relay. This allows you to check the output of a long running agent or a build process from your phone without needing to configure complex firewall rules or expose your local environment.

Get Started with Deska

If you are ready to experiment with every agent against your own legacy repo, you can download Deska for free. It provides the infinite canvas and the panel system necessary to run Claude Code, Codex CLI, and OpenCode in parallel. Whether you are on Mac, Windows, or Linux, you can start organizing your workspaces and taking control of your technical debt today.