How to Set Up and Customize Your Computer With ChatGPT and Remote Desktop Commander

Apollo showed as connected, but ChatGPT couldn’t get a basic command to run on it. After I installed Kubuntu, we used that same remote tool to configure the laptop through a conversation and verify each change on the machine itself.

Apollo Needed a Job, Not a Pile of Software

Apollo is my Lenovo ThinkPad E560, with an Intel i7-6500U processor, 16 GB of memory, and a 500 GB Crucial MX500 SSD. It was running Windows 11 when this started. My Windows desktop, Rocky, was staying my primary computer, so the laptop did not need to duplicate everything Rocky did.

I wanted a useful second machine for browser-based work, writing, and remote administration. I also wanted to try Kubuntu, a Linux distribution that uses the KDE Plasma desktop. I was not moving my software projects into a local development environment. That might come later.

That distinction became important when the conversation with ChatGPT started heading toward development tools. Installing tools was not permission to redesign my workflow. I corrected the assumption, and we kept the setup focused on how I actually use my computers.

I have written about how I build software with AI. This was a different application of that working relationship. Instead of directing changes to an application, I was directing changes to the computer in front of me.

What the Remote Connection Actually Adds

Without a connection to your computer, ChatGPT can explain a setting or suggest a command. You still have to run it, copy the result back, and make sure the next recommendation fits what happened.

Remote Desktop Commander lets ChatGPT do some of that work instead of just describing it. Once the computer is paired and access is authorized, it can inspect files, run commands, check processes, and make permitted changes. That’s the connection I used on Apollo.

This is not the same as giving ChatGPT an unrestricted graphical remote-control session. Our work primarily used filesystem and terminal access. That was enough to inspect hardware, configure services, adjust desktop settings, and verify the results, while I handled physical installation steps and judged what the finished desktop felt like.

The commands run on the real computer under the account running the agent. Treat that access accordingly. A prompt saying “be careful” is useful direction, not an operating-system security boundary. Its own security guidance distinguishes its guardrails from a sandbox.

Start on a machine you own or are authorized to administer. Use a normal user account, preserve anything important, and review the provider’s permissions and data-handling information. Remote requests and results pass through connected services; terminal output should not be assumed to stay private to the laptop.

Connect One Computer and Prove It Responds

There are two connections to make: the agent on the computer and the connection in ChatGPT. Remote Desktop Commander’s setup guide pairs the computer first so it is ready when you connect the assistant. Here is the practical sequence, with the provider’s instructions checked in October 2026.

1. Check Node.js on the computer

Before pairing anything, open PowerShell on Windows or Konsole on Kubuntu. Check that Node.js is available:

node --version

If it is missing, use the official Node.js installation instructions for your operating system. Choose a currently supported LTS release that meets the agent’s requirements. Reopen the terminal and check again.

2. Pair the computer with Remote Desktop Commander

On the computer you want ChatGPT to reach, run the command in the official remote setup guide:

npx @wonderwhy-er/desktop-commander@latest remote

Approve installation if prompted. The agent opens a verification page and shows a pairing code in the terminal. Sign in and confirm that the codes match before approving the device. If they do not match, stop.

On Apollo’s original Windows installation, PowerShell blocked the npx.ps1 wrapper. We used the Windows command wrapper instead:

npx.cmd @wonderwhy-er/desktop-commander@latest remote

That got around PowerShell’s wrapper restriction without lowering its execution policy. It was a separate issue from Apollo’s later connection problem, and it was no reason to weaken Windows security settings.

Keep the terminal open while you first test the connection. Closing it stops the foreground agent unless you later set up a managed background service.

3. Connect ChatGPT to the paired computer

Once the terminal says the device is ready, add Remote Desktop Commander in ChatGPT. Find it in the plugin directory, review its permissions, and authorize the same account you used to pair the computer. OpenAI’s plugin instructions explain the current ChatGPT setup screens.

Remote Desktop Commander also offers a Connect an AI assistant option on its dashboard. Where manual MCP configuration is supported, the provider documents the server address https://mcp.desktopcommander.app/mcp. You may not need to enter that URL if ChatGPT offers the plugin directly. Availability depends on your plan and workspace.

Now both sides should be connected. That is still not proof they can exchange commands, so the first assignment should be a harmless inspection, not a change to the computer.

4. Ask for a real read-only test

Before asking for any changes, give ChatGPT a narrow assignment. Replace the machine name in this example with yours:

Use Remote Desktop Commander to inspect Apollo only. Confirm the device, hostname, operating system, and user account. Run a fresh connectivity check and a harmless command on that machine. Do not modify files or settings, and do not inspect passwords, private keys, or unrelated personal files. Tell me what actually responded.

I had multiple machines connected. Naming the target was not housekeeping. A valid command on the wrong computer would still be the wrong action.

“Online” Was Not the Same as Working

Apollo’s Windows connection repeatedly showed as online while remote commands failed. Its terminal said it was connected. The device appeared in the list. But a fresh ping and a simple hostname request did not return usable results.

We spent too long repeating checks and restarts without establishing the cause. Eventually I moved on. Rocky and the server still responded, so the problem was not evidence that every Remote Desktop Commander connection was broken.

After I installed Kubuntu and paired Apollo again, remote commands worked. That is what we observed. It does not prove that Windows was the cause, that Linux repaired a particular bug, or that everyone will have the same experience.

A device showing up in the list proves it registered, not that ChatGPT can actually work on it. Check the agent, account, and machine. Send a harmless command and read the result. If it fails, work from the error you got instead of restarting things at random.

I Still Had to Install the Operating System

ChatGPT helped with the installation, but it did not remotely perform every part of it. That boundary deserves to be clear before anyone erases a drive.

I downloaded the Kubuntu installation image on Rocky. Using Remote Desktop Commander, ChatGPT located it and calculated its SHA-256 checksum, which matched the value published by Kubuntu’s download service. A checksum comparison checks the file against that published reference; the reference itself still needs to come from a trusted source.

I used Rufus on the Windows desktop to create the bootable USB. Then I moved the USB to Apollo, opened its boot menu, and worked through the installer myself. I chose to replace Windows rather than spend time in the live trial environment.

My choice is not a shortcut everyone should copy. Before replacing an operating system, back up the files you need, retain recovery information, and verify the installation target by model and capacity. The USB-writing step erases the selected USB device; the operating-system installer can erase the internal drive. Those are separate destructive decisions.

Keep a second device or printed instructions available during installation. The old agent cannot keep managing a machine after the operating system running it has been replaced. Once Kubuntu was installed, updated, and connected to the network, I installed the prerequisites and paired the new Linux environment.

You can use the same division of work for a Windows installation: AI-assisted preparation and explanation, human control of boot and installation decisions, then a fresh authorized connection for post-install setup. This article is not a universal partitioning recipe.

Inspect Before You Start Optimizing

Once Apollo responded, ChatGPT could read its actual hardware and configuration instead of continuing from assumptions. We checked the processor, available memory, storage, graphics, network, battery information, and system logs.

That did not require turning every finding into a repair project. The laptop had enough memory and storage for the job I had given it. Its SSD report was reassuring. A background service existing was not automatically evidence that it needed to be removed.

We installed some useful command-line tools, including PHP and Composer, but I made the workflow boundary explicit: I was not developing my projects locally. No repositories, databases, containers, or local development servers needed to appear simply because the tools were available.

Start with the symptom you want to change. “Menus feel slow because they animate” is a different problem from “the processor is saturated” or “the disk is producing errors.” Ask the assistant to establish which situation exists before it recommends an optimization.

Make Each Change Small Enough to Judge

Once the basic connection worked, my requests became ordinary descriptions of what I wanted. I needed SSH access to my server. I wanted performance rather than battery-saving behavior. I disliked the animations. I wanted a familiar dark desktop without undoing the configuration we had built.

A useful instruction for that stage is:

On this computer only, propose the smallest change that achieves my request. Identify the current setting, what you will alter, what must stay unchanged, and how to reverse it. Wait for approval before making the change. Afterward, read the setting back and test its behavior. If permissions or physical interaction block you, explain the exact step I need to perform.

Server access without passing secrets through the chat

For SSH, I generated a dedicated encrypted key on Apollo and entered its passphrase locally. ChatGPT transferred the public key to the server, preserved existing authorized keys, and checked the server’s identity. The private key stayed on the laptop.

The first automated check established that the server accepted Apollo’s public key. It did not complete an authenticated session because the private key still needed unlocking. I performed that login myself. Only then did we have evidence that the complete path worked.

Later, we used KDE Wallet and the existing SSH authentication agent so I would not have to enter the key passphrase for every connection. That kept the key encrypted on disk while making it available during my session. I restarted the laptop and tested the login again.

Performance preferences without pretending they are universal

We selected Apollo’s available Performance profile and checked the resulting settings. Thermal safeguards and hardware acceleration stayed enabled. We did not run a benchmark proving that the computer had become a particular percentage faster.

I also asked to disable sleep, including lid-close sleep. That was my preference, not a general recommendation for laptops. A computer that keeps running with the lid closed can drain its battery or build heat in a bag. Those consequences do not disappear because an AI changed the settings.

Some system-level commands were blocked through the remote connection or required local administrator authentication. I ran the necessary commands in Konsole, and ChatGPT verified the resulting configuration. We did not loosen the tool’s restrictions or hand it unrestricted administrative access to avoid that boundary.

A familiar desktop without another transformation package

Plasma looked busier than I wanted. We disabled decorative effects and set animation timing to instant while preserving accelerated rendering. Then I asked for a Windows 10-inspired dark appearance.

Using existing KDE components, we created a solid 44-pixel taskbar, a traditional application menu, dark colors, and a blue accent. My wallpaper and pinned applications stayed. Later, I chose an Apollo launcher symbol and asked to move less-used tray icons behind an expand arrow.

That last change hid icons, not the services behind them. File synchronization could keep working without its indicator taking up permanent taskbar space. The computer became more comfortable to use without replacing the desktop environment, downloading a transformation pack, or restoring the animations I had just removed.

Check the Running Result, Then Check It Again

We learned that a command finishing without an error wasn’t proof the setting worked. One change could be saved in a file while the desktop kept doing what it did before. Sometimes we had to reload the desktop and check again.

For the visual changes, ChatGPT checked both saved configuration and the effects actually loaded by the window manager. For power settings, it checked the selected profile and relevant runtime values. For SSH, I tested an actual login rather than accepting a public-key acknowledgment as the finish line.

Reboots answered a different question: would the change survive a new session? We tested key loading, Num Lock behavior, remote startup, and the power configuration after restarting. A saved setting and a setting that survives normal use are related, but they are not interchangeable evidence.

I supplied the checks that mattered at the screen. Did the menu feel right? Was the Start button where I expected? Were the icons still cluttering the taskbar? The assistant could inspect configuration, but I was the person who had to use it.

At the end of each change, ask what changed, what passed, what wasn’t tested, and what might still be wrong. If something fails, fix that before piling on another change.

Decide Whether Remote Access Should Stay Available

Initially, Remote Desktop Commander depended on an open terminal. I wanted it to start when I logged in and recover if its process exited, so I explicitly approved a persistent setup.

We configured a systemd user service on Apollo, running under my normal account with a known-working installation. Its restart policy used a 15-second delay. We tested recovery by stopping the managed process, checked that it returned, and then verified automatic startup after a reboot and login.

A restart policy is not a guarantee against every connection failure. It can recover an exited process without detecting a process that is still running but unresponsive. It also cannot supply a missing internet connection. The systemd service documentation distinguishes restart behavior from watchdog behavior.

Persistent access also changes how you disconnect. Closing a terminal no longer stops an agent managed by a background service. Our particular user service can be stopped with:

systemctl --user stop desktop-commander-remote.service

That name belongs to the service we created, not every Remote Desktop Commander installation. Stopping it does not remove its future startup configuration.

The agent’s documentation also distinguishes stopping the process, deleting saved local credentials, revoking a device, and disconnecting an AI client. For revocation, use the device controls in the Remote Desktop Commander dashboard. Know your exit path before enabling unattended startup.

You Can Use This Method and Keep Windows

You don’t need Linux for this. Rocky, my Windows desktop, stayed on Windows while we worked on Apollo. Remote Desktop Commander worked there. We used it to inspect Windows system logs showing disk errors and storage-controller resets, then, after I approved a separate change, to make Windows Update notify me before downloading and installing updates.

That update behavior was my decision about uptime, not a default I’d recommend for every Windows computer. The commands also change with the operating system. PowerShell is not Bash, and a Linux systemd service is not a Windows startup task. Ask the assistant to inspect the installed version and supported controls rather than blindly copying Linux commands.

On a Windows computer, a sensible first job could be investigating startup activity or adjusting visual effects. Start with a boundary such as:

Inspect this Windows computer for the slowdown I describe. Report the evidence before proposing changes. Preserve my files, applications, remote access, security software, firewall, and update protections. Do not run a debloat script or disable services broadly. Explain the smallest justified change and how we will test it.

The Linux setup described here was completed and tested on Apollo. It is not evidence that every equivalent Windows configuration has been tested. Your machine still needs its own inspection, authorization, and verification.

Leave Yourself a Computer, Not an Endless Setup Project

By the end, Apollo had become a usable second computer with the appearance and behavior I wanted. That was enough. I did not need to keep installing things because ChatGPT could suggest another tool.

Before ending a substantial setup session, ask for a short record of the machine, changes, affected configuration paths, verification results, and how to reverse the important parts. Keep credentials out of that record. My interest in leaving useful context for later work applies here too: a future session should start by checking a truthful record, not guessing what an old conversation accomplished.

For someone trying this, I would begin with one reversible task on one clearly identified machine. Read its current state, approve a specific change, verify the running result, and use it yourself before moving on.

ChatGPT and Remote Desktop Commander reduced how much configuration I had to perform by hand. They did not remove my responsibility to understand the consequences or decide when the work was finished. The result was not a demonstration running in somebody else’s environment. It was the laptop I could close the conversation and keep using.

New Here?

Start Here: Why I Build This Way

Sources:

The Apollo and Rocky results above come from my own setup and testing. These references document the tools, installation steps, and security behavior.