The described setup combines a local LLM on the host with VS Code and the Cline agent in a virtual machine, while routing the guest system’s external traffic through a SOCKS proxy. The practical point is simple: the model gets access to the main computer’s powerful hardware, while code and dependencies run separately. But the boundaries of this isolation depend on network rules and the VM’s own settings—a snapshot doesn’t turn it into a magically airtight container.

The approach is suggested for working with autonomous agents, checking third-party repositories, and running suspicious scripts. An agent can execute commands, install packages, and build a project; a command error or unexpected behavior from unknown code in the host OS creates unnecessary risk. So development tools, the terminal, browser, and compilers are placed in the guest system, while inference stays on the host.

Three parts of the setup

The desktop Strata runs on the host and provides an OpenAI-compatible API on a local interface. VS Code and the Cline extension are installed in the VM, which uses NAT networking. The third part is Proxifier on the host: it should send the hypervisor process’s external traffic through a SOCKS tunnel, but not route the local request to the model API through that same tunnel.

This separation lets the agent contact the model on the host without moving it into the virtual machine or trying to pass a GPU through to it. At the same time, builds, scripts, and dependencies run inside the guest OS. The author describes the option of reverting the VM to a snapshot after analysis, but that doesn’t replace checking network and system settings.

Port forwarding to the local API

The example uses Windows on the host and Strata on port 47831. First, check whether the models endpoint responds with the command curl.exe 127.0.0.1:47831/v1/models. From the JSON response, you need the exact value of the field id: it will be needed in the Cline configuration. If the port or model name differs in your environment, don’t mechanically copy these values from the example.

Since the local server usually listens only on 127.0.0.1, the VM can’t reach it directly through NAT. To forward the port, the author uses the system’s portproxy and a firewall rule, created from an administrator command prompt:

netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=47831 connectaddress=127.0.0.1 connectport=47831
netsh advfirewall firewall add rule name="Strata VM Bridge" dir=in action=allow protocol=TCP localport=47831

There’s an important detail here that’s easy to miss when copying the commands: listenaddress=0.0.0.0 means listening on all IPv4 interfaces, and the firewall rule shown doesn’t restrict the connection source to the VM’s address. So the claim that the API isn’t exposed to the local Wi-Fi network isn’t ensured by these commands alone. If the goal is to allow access only from the intended environment, separately check the binding and access rules in your own configuration before assuming the API is inaccessible to other devices on the network.

Exception for the local connection

There’s another trap in a setup with Proxifier. The VM’s request to the NAT gateway 10.0.2.2 passes through the hypervisor’s network translation, and port forwarding is handled by the system process svchost.exe. If you proxy all hypervisor traffic without exceptions, the request to the local API may go to the external SOCKS server instead of the host. The result: the connection hangs or drops.

The author suggests creating a Strata Local Bridge rule in Proxifier and placing it above the general hypervisor rule. In the Applications field, specify Any, since the system process handles the request. For Target Hosts, specify 10.0.2.2, 127.0.0.1, localhost and local ranges, and for Target Ports, only 47831. The rule’s action is Direct.

The port restriction is what matters: the exception is intended for the local bridge to the model API, not for bypassing SOCKS arbitrarily. External connections from the VM are still supposed to go through the proxy. The irony is that one extra or misplaced rule line can send a “local” request out to the external network—the proxy can’t guess what the administrator intended.

Configuring Cline in the VM

In the guest Windows with NAT networking, the host address is set to 10.0.2.2in the example. First, check from the VM that the endpoint is reachable with the command curl.exe 10.0.2.2:47831/v1/models. If JSON with a list of models is returned, the bridge to the API is working. If not, configuring Cline won’t help yet: first check port forwarding and the exception in Proxifier.

For Cline, choose the OpenAI Compatibleprovider, and set the Base URL to the gateway address with the path 10.0.2.2:47831/v1. In the API Key field, enter any non-empty value, for example local, and in Model ID, enter the exact identifier from the server response. The extension settings also recommend disabling Use different models for Plan and Act modes, so you don’t have to set separate configurations for planning and execution modes.

To reduce the channels of communication between guest and host, the author recommends disabling Shared Folders and two-way clipboard sharing. These are practical restrictions, not proof of complete isolation: they remove specific ways to transfer files and text, but by themselves don’t define every possible path for interaction between the systems.

What to check before getting started

After checking requests to the model and the VM’s external IP address, the recommendation is to export the Proxifier profile and make a clean snapshot of the guest system. The export saves the routing rules, while the snapshot provides an initial state you can return to after an experiment. This is a convenient basis for repeatable tests, but it’s no guarantee that every piece of malicious code will stay inside the VM.

There’s a separate condition concerning UDP: in the source, protecting the real IP address is also tied to blocking UDP traffic from the VM. So the fact that a check showed the SOCKS proxy’s IP shouldn’t be treated as universal confirmation for all protocols and scenarios. Enabling Auto-approve in Cline also means the agent can execute commands without manual confirmation; consider that option only alongside restrictions on the VM, proxy, and host access that have actually been verified.