Wing Pro 12.1 Autonomous Development of Major IDE Feature: Adding AI Agent Virtualization

Also available: More Demos | AI Agent Features | Wing Tips
Nov 14, 2026
This is a preliminary report on work in progress that will be updated when completed and ready for release.

Over nine days, the autonomous Tasks Manager in Wing Pro added a major new feature to Wing itself, allowing the IDE to run AI agents in virtual machines, containers and other hosts, either configured by the user according to their security requirements, or built by Wing as needed. This was used to add new Safer and Safest security modes that keep agent work off the user's computer until it is reviewed and accepted.

The Tasks Manager planned and ran the work on five Wing instances across macOS, Linux, and Windows. Two of these kept the current release, Wing 12.1, up to date with fixes for bugs that were found along the way. A Wingware developer (the "user" in the charts below) defined the problem and decided the design, scope, priorities, and user interface.

The implementation, which will be part of Wing 12.2, was completed and works. However, further security review and testing is still in progress, before it will be considered ready for release.

At a Glance

  • Claude Code with Claude Opus 5.5, running in development builds of Wing Pro
  • Nine days: November 5 to 13, 2026. Agents ran over 139 hours, or 269 task-hours taking concurrency into account. The user was at the computer for about 52 of these hours.
  • 1,266 tasks; 790 commits for the new feature, and 59 bug fixes committed to Wing 12.1
  • Five Wing instances, which passed work to each other 172 times
  • About 210,000 lines of code, tests and documentation, half of them tests

The Task

The run began with a research request. Many people who try autonomous development have no VM software, so the request asked whether Wing could "automate setup of a safe environment for running AI agents." It expected that several VM and container technologies would be needed, and asked the agent to survey them and propose an approach.

Over about 30 follow-ups that evening and the next morning, the user and the research agent worked out the design. The user rejected sandboxing in favor of real VMs and containers, required support for Windows, macOS and Linux, and decided how work should flow from the agents back to the user's repository. The design has three safety levels that can be chosen for each Wing Pro project:

  • Standard runs agents on the same system as the IDE, as in Wing 12.1.
  • Safer runs agents only on peers (headless Wing instances) in VMs and containers that Wing builds, or on preconfigured hosts the user provides. Their work reaches the user's computer only when the user accepts it.
  • Safest runs peers only on VMs, containers, and hosts that the user configures according to their security requirements. The user's own working copy may optionally be moved to a secured host, so the user edits, debugs and reviews only on that secure host and never directly on their own computer.

To build this, the agents had to connect to the user's VMs and hosts, create and provision machines with each VM and container product, install and run a headless Wing on them, build a hub for the peers to share, move work between the peers and the user, and write the documentation.

What Was Built

The chart below gives the effort for each feature in tasks, commits, net lines of code, output tokens, agent hours, and days worked:

Tasks, commits, lines, tokens, agent hours and days per feature, grouped into Virtualization, SVN/P4 shadow, Other and Bug fixes for 12.1

Shown above: Effort per feature. Click to enlarge.

Peers can run on 10 different kinds of hosts including: (a) the user's existing Windows, Linux and macOS hosts, containers, or VMs, (b) VMs Wing builds on the fly with Parallels, VMware, Lima, Lume, or Hyper-V, (c) VMs made from copies of preconfigured Parallels or VMware VMs provided by the user, (d) containers made with Docker and Podman, or (e) a disposable Windows VM made with Windows Sandbox. Most of these options were live tested by the agents. Support for Amazon EC2 was partially implemented, but left for completion in a separate run that can monitor the associated cloud service costs:

Agent hours and tasks for each kind of VM, container and host, split between new machines Wing creates and existing ones

Shown above: Effort per kind of machine. Click to enlarge.

Of the 210,000 lines added in all, about half are tests. 176,000 lines are for the virtualization feature itself. The other 34,000 lines were for the related Subversion/Perforce shadow repository feature, the new By Status view, and general improvements made along the way. On top of that, 12,000 lines of code were added for bug fixes made in the Wing 12.1 branch:

Net lines added for Virtualization, SVN/P4 shadow, Other and Bug fixes for 12.1

Shown above: Net lines added, by development focus. Click to enlarge.

Beyond the unit tests, the Tasks Manager also ran 70 regression sweeps and 101 live checks on real VMs, containers and hosts. The live checks found bugs that the unit tests had missed, each then fixed by running additional agent-specified tasks. Altogether, agents filed 219 new tasks for problems they found outside their assigned work.

The charts also show three groups of related but separate work:

  • SVN/P4 shadow (November 7) lets agents work in Subversion and Perforce working copies. Autonomous peers rely on the capabilities of distributed version control systems, so for users with Subversion or Perforce, Wing keeps a shadow git repository until work is reviewed and accepted.
  • Other general work arose along the way, mostly fixes and improvements to the Tasks tool and Tasks Manager prompted by the user's experience with them, and fixes for slowdowns in the IDE. It included a new By Status view on the Plan tab of the Tasks tool (November 13), which helps to manage issues blocking the scheduling of draft tasks.
  • Bug fixes for 12.1 were fixes for bugs found during the work that also affected the source code for the current release of Wing. Another Wing instance peer made those fixes at the request of the lead Tasks Manager, which (after one user request) identified and orchestrated such fixes on its own for the remainder of the run.

Who Did the Work

Over nine days, the user typed 244 prompts totalling about 15,500 words. The agents wrote 1,282 prompts that included about 191,000 words. Nearly all of the agent-written tasks were filed by the Tasks Manager from user-initiated plans and follow-ups, or by workers reporting problems. The Tasks Manager also logged more than 4,300 decisions, such as filing, queueing and readying tasks, and sending them to other Wing instances:

Prompts and words written by the user, by agents, and by Wing, and the Tasks Manager's decisions by kind

Shown above: Who wrote the prompts, and what the Tasks Manager did. Click to enlarge.

The user stated the problem, shaped the design, set scope and priorities, and judged the user interface and documentation. The user also answered 29 of the 46 questions asked by worker agents. The Tasks Manager answered the other 17 on its own, based on its accumulated knowledge of the feature being developed, and its understanding of the user's workflow.

Multiple Wing Instances

Five Wing instances took part in this work. The lead instance, on the user's Mac, ran the Tasks Manager and most worker agents. Instances in Linux and Windows VMs ran tests and made platform-specific changes. A second instance on the Mac and another in the Windows VM maintained Wing 12.1, each with its own independent Tasks Manager:

Tasks, output tokens and agent hours per Wing instance, and a table of how many tasks each sent to each other

Shown above: The Wing instances, and the work they sent each other. Click to enlarge.

Tasks Managers made all 172 peer-to-peer hand-offs, to run tests or do platform-specific development. When the lead found a bug that also affected Wing 12.1, its Tasks Manager handed those off to the instance on the Mac responsible for maintaining Wing 12.1. Its own Tasks Manager ran a worker to make the bug fix, committed it, and reported back. This happened 66 times and produced 59 commits to Wing version 12.1.

How the Run Went

The chart below shows how many tasks were running in each 10-minute period over nine days. The bands beneath it indicate when the user was at the computer, when the Mac was asleep, and the points at which the user submitted a prompt or answer to a question:

Tasks running at once over nine days, coloured by area of work, with bands for user presence, the Mac asleep, and user prompts

Shown above: Tasks running at once, and when the user was there. Click to enlarge.

The first few days of work built the core: The hub, Wing-controlled peers, the safety levels, and the first kinds of virtualized hosts. The user then led three phases running through all the planned virtualization options: working with an existing host, using a VM that Wing builds in Parallels, and then for the remaining kinds of host. Each run-through exposed bugs, which became new tasks. The Tasks Manager ran up to 16 tasks concurrently, averaging 3.3 at a time, when any were running.

Much of the work ran unattended, including overnight stretches of up to 12 hours. Agents worked for about 84 hours while nobody was at the computer:

Per day, hours with agents working, agent task-hours, hours the user was at the computer, and hours agents worked while the user was away

Shown above: Agent time and user time, per day. Click to enlarge.

The Result

Wing can now run AI agents in VMs, containers, and hosts on macOS, Windows, and Linux. These may be configured by the user or built on the fly by Wing, with a choice of three safety levels and documentation for each kind of virtualized machine.

The feature currently includes support for Parallels, VMware, Lima, Lume, Hyper-V, Docker, Podman, and Windows Sandbox (a disposable Windows VM). Partial support for Amazon EC2 was also implemented.

The bug fixes made along the way for preexisting features are on both the 12.1 maintenance branch and the virtualization development branch.

This work represents the initial working version of these features. More work is planned before the feature is released, including hardening of the Safer and Safest levels, live testing some of the virtualized machine types more thoroughly (mostly on currently unavailable architectures), and completing support for EC2 hosts.

Cost of Development

The agents and Tasks Managers made about 72,000 tool calls. They sent Claude about 8.6 billion tokens of input, 8.5 billion of them counting as reading from Claude's prompt cache. 33 million tokens of output were received. The run used nine days of a $200-a-month Claude subscription and never ran into token limits. Based on its share of that subscription, approximate cost was around $60.

A comparison of the 210,000 lines written for this feature to code written manually prior to our adoption of agentic development suggests that this feature would have taken us 3-6 years to develop manually. The run wrote about as many unit tests as we hand-coded between 2007 and 2025.

This is an astonishing productivity gain.

Based on our prior experience working on other tasks with this system, we do expect another week or two of work before this feature is ready to be released for beta testing. The automatically generated documentation will need review and improvement, extended real use by a human will uncover some UI issues, and further review is needed for security, first-time user experience, performance, and analysis of missing end cases.

Even so, we are comparing perhaps a month of development time to a years-long effort if done manually. We already know that code quality and coverage of end cases is considerably better than when we developed code manually. Our ability to test, fix, and further refine what problems remain is also far beyond our pre-agentic capabilities.

Notes

In the course of this development process, Wing ran smoothly from the same development sources being worked on, and restarted often to take advantage of new features added and fixes made. Over about 38 restarts, only one regression caused temporary problems that needed to be fixed for work to continue; the agent's unit tests and its live testing capabilities were sufficient to keep current sources working smoothly during the rest of the process. This outcome may also in part depend on the very high implementation accuracy we've experienced with Claude Code using the Opus 5.5 model.

Although we ran from current sources, none of the development used the new virtualization features itself. Instead, we hand-configured peers on our pre-existing development VMs, as also supported in Wing 12.1, and used a separate branch to isolate the changes during development. As a result, the user had to manually push/pull changes between peers, as needed for development to progress. This occurred 7 times at the request of the Tasks Manager, and another 5 times at the user's own initiative. Manually flowing changes will no longer be necessary when the new virtualization features are rolled out, because they entirely decouple the flow of changes among peers from the master revision control repository.

Work was performed in two different physical locations and no problems arose as a result of closing the laptop mid-task and moving to another network.

Due to the volume of code produced, no detailed review of source code was made. Comparison to older hand-written code showed the auto-generated code to be comparable in style and density. As a result, user review focused instead on reading task and decision summaries, requesting additional review for security, performance, and other metrics, and through extensive agent-driven live testing. The lead Tasks Manager agent paid considerable attention to quality control on its own, as a result of the guidance it is given by Wing Pro's autonomous development system harness.

Future articles will describe the internals of the system in more detail.

Wing's source code is not public, so there is no repository or further details to view. The data in this report comes from Wing's detailed records of task results and Tasks Manager decisions, agent transcripts, and the commits that were made.

Try it Yourself

To run work like this, you need Wing Pro 12.1 or later and an AI agent such as Claude Code, on an account that supports sustained use. Getting Started with Autonomous Development explains the setup, and AI Agent-Assisted Development in Wing's documentation covers the autonomous Tasks Manager and describes configuring peers manually.

The VM and container support described here will be part of Wing Pro 12.2, which is not yet available. Until then, we recommend running Wing (and thus your AI agents) in a reasonably secured VM, or at least being mindful about potential agent access to sensitive data or the keys to your server infrastructure. Claude Code with Opus 5.5 has been extremely well behaved for us. Other models and agents vary in the level to which they have implemented AI safety.