DEV Community

I Gave an AI Agent Access to My Windows PC. Then I Had to Learn Not to Trust It

I was working with an AI agent in a browser when I ran into a simple problem: it could write a command, but it couldn't run that command on my computer. It could suggest a file change, but it couldn't open the file and make the edit. It could tell me how to build a project, but I still had to do the building myself.

I started with a small MCP server for my own use. At first, it let an agent run commands and work with files on a VPS. Then I wanted the same thing on my home Windows PC. That changed the question from β€œhow do I give a model access to files?” to something less comfortable: how do I let an AI work on my PC without pretending it will always make the right decisions?

That's how ZeroIDE MCP started: an open-source MCP server with a Windows tray app. In this article, I'll explain how it works, how an agent connects to it, and which limitations I think are important to make clear upfront.

The short version: ZeroIDE MCP runs on Windows 10/11 x64 and is off by default. It gives compatible AI clients tools for working with files and PowerShell. File reads are generally allowed by default, while file changes and commands require approval. It is not a sandbox: approved commands run with your Windows user's permissions.

Why give an AI access to my PC?

Suppose I have a project on my home computer and I'm talking to an agent in a browser. I want it to find a configuration error, suggest a fix, and check the result. Without access to the machine, the process often looks like this:

  • I find the relevant file.
  • I copy its contents into the chat.
  • I get a proposed fix.
  • I paste the change back into the file.
  • I run a check.
  • I copy the error back into the chat.
  • Repeat.

That's fine for one small task. For a series of changes, it gets tedious. I wanted the agent to be able to find and read files, propose a change, wait for my approval, and then check the result. Not just tell me what to do, but help do it.

This isn't a new category of problem. Local agents can already work with computers. But I wanted to connect both local agents and compatible cloud-based chats to my Windows machine - and, when needed, connect several of my own computers to one agent.

Where MCP comes in

MCP, or Model Context Protocol, lets AI clients connect to external tools. With ZeroIDE MCP, the flow looks roughly like this:

AI client
|
MCP request
v
ZeroIDE MCP on the Windows PC
|
+-- access check
+-- permission and risk checks
+-- owner approval, if required
v
File operation or command execution
|
v
Result returned to the client

The server and tray app run on the PC itself. The agent can be on the same computer, on another computer, or in a cloud-based chat. The connection method depends on the setup.

The project currently exposes 19 MCP tools, including:

  • Reading, searching, writing, and editing files.
  • Copying, moving, and deleting files.
  • Running PowerShell commands, including background jobs, and retrieving their output.
  • Taking screenshots and reading images.
  • Getting system information.
  • Sending messages to the owner and recording task status and logs.

The server is built with Node.js, the tray app with C# and Windows Forms, and the installer and some connection helpers with PowerShell. The code is open source under the MIT-0 license. But to me, the number of tools is less interesting than what happens before they run.

The server is off by default

I didn't want installing the application to mean that an agent had permanent access to the computer. ZeroIDE MCP is controlled from the tray and is off by default. When I need access, I turn it on. When I'm done, I turn it off. Exiting the tray app also closes access through the app.

The server itself listens on 127.0.0.1. That's enough for a client on the same PC. For access from elsewhere, a connection has to be set up separately - more on that below.

This doesn't automatically make the whole system secure. But it gives access a visible boundary that the owner can control.

Approval isn't one button for everything

In early versions, I found that having an β€œAllow” button wasn't enough. It also matters whether you understand what you're allowing.

By default, file reads, searches, and some other operations can run without an individual confirmation. File writes and edits, file operations, and commands wait for the owner's decision in the tray. Reading images and taking screenshots also require approval by default.

That's an important distinction: not every read requires confirmation. If an agent has read access, it can read files available to it, and the results can be sent to the AI service you're using. The scope of that access matters.

Tool permissions can be changed in settings. I sometimes use a more trusting profile myself. But that's a risk I choose to take, not a recommendation for everyone else.

Risk cards

In version 0.5.0, I added risk assessment for commands and file changes. A call can be rated from low to critical. The rules look for patterns such as recursive deletion, weakening Windows protections, downloading and running code, or accessing ZeroIDE's own internal files. For file edits, the approval card can show a diff to make the proposed change easier to inspect.

With the protective rules enabled, a critical call defaults to denial and can only be approved once. But it's important not to confuse a useful warning with a guarantee: Risk assessment is a set of rules, not proof that a command is safe. A harmful action the rules don't recognize may receive a low rating. You still need to read the request before approving it.

What if the agent damages a file anyway?

Version 0.5.0 added a history of changes made through ZeroIDE's file tools. When an agent changes, overwrites, or deletes a file through the relevant tools, the previous version can be kept in the history. The Settings β†’ Changes section lets the owner inspect changes, compare versions, and undo an action. History is kept for 30 days by default.

But it is not a full backup of the computer:

  • Undo covers changes made through write_file, edit_file, and file_ops.
  • ZeroIDE's history does not record changes made through run_command.
  • For files larger than 25 MB, the event is recorded without a copy of the file contents.
  • The history contains older versions of files, so it needs the same care as the original data.

If an agent makes a bad edit to a small config file through a file tool, history may help. If I approve a PowerShell command that changes something else, I can't rely on the Undo button. Important data still needs regular backups.

What about ZeroIDE's own tokens and settings?

Another question came up: if the agent can read and change files, what stops it from reaching the application's settings or tokens? In 0.5.0, the file tools gained protection for ZeroIDE's own files. For example, those tools should refuse to expose ZeroIDE credentials or let an agent modify its permission settings, history, and logs.

But there's a boundary here too: run_command runs with the Windows user's permissions. File-tool self-protection and risk warnings are guardrails, not an isolated execution environment.

Clients can connect using OAuth with owner approval or named tokens. A token can have an access level, an expiration date, a request limit, and a folder restriction for supported operations; it can also be revoked.

Another change after a security review was fail-closed authentication. If credentials aren't configured or the token file can't be read, the server shouldn't open up without authentication: requests are rejected instead. An early version had the opposite bug: a problem reading the token file could disable authentication. I found it after asking a separate agent to look at the project from an attacker's perspective. It was a useful lesson for me: an agent saying β€œdone, everything works” is not a security review.

How does a cloud chat reach a local server?

If the AI client runs on the same PC, it can use a local connection. A web-based client needs an HTTPS address it can reach. One option is ngrok: the user signs in to their own account, enters the key in the application window on their PC, approves the connection, and then connects the AI client. An ngrok key is not an MCP token. Neither should be sent in a chat with an agent.

Other scenarios can use Cloudflare Tunnel with your own domain, your own SSH server, or a private network between your computers, such as Tailscale. The project doesn't run a shared gateway: users choose their own connection method and use their own accounts and addresses.

I don't want to imply that every option is equally well tested. The repository lists scenarios that still need more testing, including different clients, recovery after failures, and some remote-access configurations. One principle in the project's setup guide is worth calling out: a successful local server check is not the same thing as a successful real-client connection. Setup isn't confirmed until the chosen client has authenticated and can see the tools.

One agent, several computers

One scenario I find especially interesting is installing ZeroIDE MCP on multiple Windows machines and adding each one to a compatible AI client as a separate server. An agent could, for example, work on a project on one PC and check the result on another. Each machine keeps its own access settings, tokens, approvals, and audit log.

This isn't a distributed build system, and it doesn't guarantee that every agent will parallelize work perfectly. It's a way to give one agent tools on several of your own machines and see what tasks become possible.

How to try it

The simplest route is the setup wizard:

  1. Open the releases page and download zeroide-mcp.zip - not one of the Source code archives.
  2. Extract the archive and run ZeroIDE-MCP.exe.
  3. Choose guided manual installation or installation with the help of a local AI agent.
  4. Choose your client and follow the connection wizard.
  5. Turn MCP on in the tray only when you're ready to give the client access.

Installation requires Windows 10 or 11 x64, PowerShell 5.1 or later, and internet access to download Node.js. The main installation does not require administrator rights. Additional networking tools may have their own requirements.

The application is not digitally signed yet, so Windows SmartScreen may show a warning. The release includes a SHA-256 hash for checking the archive. However, matching a hash downloaded from the same source does not replace a digital signature or an independent check of provenance.

You can also visit the project website to try an interactive demonstration and watch setup videos before installing anything. If you do try it, I'd start with a separate test folder and a task where data loss wouldn't matter. For example, ask the agent to find text in a few test files, then propose a small edit and carefully inspect the approval request.

What isn't finished

ZeroIDE MCP is an early project, and I don't want to present it as a complete solution for everyone:

  • It currently supports Windows 10/11 x64 only.
  • Not all AI clients and first-time setup scenarios have been tested.
  • The application is not signed.
  • The tray app targets .NET 8. Microsoft support ended in November 2026; a move to a newer version is planned.
  • Risk assessment doesn't recognize every dangerous command.
  • Undo doesn't cover changes made through PowerShell.
  • This isn't a sandbox. Operations run with your Windows user's permissions.

The repository has automated tests that run in CI, including checks for authentication, permissions, history, and connections. They help catch regressions, but they don't prove the absence of vulnerabilities or replace testing on different real machines.

What's next

I built ZeroIDE MCP primarily for my own tasks. Now I'm curious whether it is useful to anyone else - and, if so, for what. If you try it, I'd appreciate honest feedback:

  • Where did installation or connection become confusing?
  • What restriction or warning was missing?
  • Would you trust a tool like this with access to your files? Why or why not?
  • What real tasks would you want a cloud-based agent to perform on your PC?

Code and issues: github.com/Danywalery/ZeroIDE-MCP

Demo and website: danywalery.github.io/zeroide-mcp-site

Read on DEV Community ↗ ← Back to News

Comments

No comments yet. Start the discussion.