A practical guide to giving AI agents scoped control over your existing Mac or Windows setup using Aerospace, Shortcuts, and PowerToys.
What does it mean to let an AI agent customize your desktop? #
It means giving an AI agent a defined, limited way to change specific settings on the computer you already use, window placement, app launch behavior, notification handling, without handing it your admin password or asking it to reinvent your operating system. You don’t need to install a new OS to do this. You need tools with readable config files, documented commands, and clear feedback, plus a habit of scoping requests down to something small and testable.
TL;DR #
- Agents work best on operating systems that expose settings as readable files and documented commands , rather than settings buried in interfaces built only for humans to click through.
- You don’t need Linux or a new OS to try this. Tools like Aerospace on Mac, Apple Shortcuts, and PowerToys Workspaces on Windows let an agent modify real behavior on your existing setup.
- Small, scoped requests work far better than vague ones. Asking an agent to move one app to one workspace and telling you which file it edited beats saying “make my desktop better.”
- Permission levels matter more than enthusiasm. Reading a config file, editing it, installing a package, and getting admin access are different levels of risk, and models tend to be overoptimistic about which one a task actually needs.
- A dedicated test folder or scoped share is safer than full disk access. Give an agent something real to work on without exposing files you depend on daily.
- Local control of an app and local processing of your data are separate questions. An agent running on your machine may still send your files or logs to a cloud model, so think about what you hand it.
- Third-party plugins and scripts carry their own trust question , separate from whatever base tool or OS you’re using, so check where they come from before installing.
Remy is new. The platform isn't. #
Remy is the latest expression of years of platform work. Not a hastily wrapped LLM.
Why does this matter now? #
Every desktop operating system ships with decisions baked in by people who designed it years before you sat down at it. Where notifications go, what launches at startup, what you’re even allowed to change, these were fixed choices, not preferences. Modifying them has always required understanding the system, finding the right setting, making the change, and checking it didn’t break something else. That’s real work, and most people reasonably don’t want to do it.
AI agents change the cost side of that equation. An agent can hunt down the relevant setting, propose the edit, and help you verify it worked. The Linux desktop project Omarchy, built by Ruby on Rails creator David Heinemeier Hansson (DHH), was designed specifically around this idea: point an agent at your OS and have it reconfigure things for you. Its most recent version, called Quattro, released August 14, brought its bar, launcher, and notification system into one programmable layer called QuickShell, along with a plugin system and tighter integration with coding agents.
But the interesting part isn’t “install this specific Linux desktop.” It’s the underlying pattern: operating systems that expose configuration as text files and documented commands let agents do useful work. Operating systems that hide settings behind opaque interfaces don’t. That pattern applies to Mac and Windows too, and you can use it without switching operating systems.
How do you scope a request an agent can actually complete? #
Start small. If you want your browser docked to the right side of the screen, your notes app on the left, and a specific app opening only on your second monitor, that’s a good first project, not a “make my computer better” request.
For the agent to do this reliably, three things need to exist:
- A place it can find the current setting, whether that’s a config file, a command line tool, or an app’s own settings interface.
- A way to apply the change that doesn’t require guessing at an interface it can’t see.
- A way to check whether the change worked.
When those three things are documented and accessible, an agent can execute the job. When they’re locked behind a UI with no scriptable equivalent, the same request turns into guesswork. This is why picking the right tool for the job on Mac or Windows matters as much as picking the right words for your prompt.
A useful test, borrowed from how these systems get evaluated: can the agent invoke a useful action, can it read what happened, and can it write the input. If a tool answers yes to all three, it’s a good candidate for agent-driven changes. If it answers no to any of them, you’re better off leaving that particular setting alone or finding a different tool that controls the same behavior.
What tools make Mac and Windows agent-friendly right now? #
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
On Mac, Aerospace is a window manager with a plain-text config file and documented commands. That gives an agent a specific file to read, a specific setting to edit, and a specific command to reload the configuration and show you the result. If window tiling and placement is a recurring annoyance, Aerospace gives an agent a contained place to work without touching anything else on your system.
Apple Shortcuts is an officially supported feature that can be run from the command line, including passing input into a shortcut. That turns any shortcut you’ve already built, say, one that prepares copies of selected files for a specific app, into an action an agent can call as a step in a larger task. You already know what goes in and what comes out, which makes it easy to check the agent’s work.
On Windows, PowerToys Workspaces lets you define and launch specific window layouts, arrangements of apps positioned and sized a certain way across your monitors. That’s the same kind of documented, invocable action that makes agent-driven changes practical: the agent doesn’t need to fight with window geometry from scratch, it can trigger a workspace you’ve already defined or help you build a new one.
The common thread: pick tools with config files an agent can read, commands it can run, and results you can verify. Skip tools where the only way in is a mouse click through a settings panel with no scriptable equivalent.
Is it safe to give an agent this kind of access? #
It depends entirely on what level of access you grant, and that’s worth being deliberate about. Reading a config file, editing it, installing a package, and getting admin access are four different risk levels, and an agent’s confidence about a task doesn’t tell you which level it actually needs. Models tend to be overoptimistic about the changes they propose.
Before letting an agent make a change, it’s worth asking which specific setting it plans to touch, and if it asks for admin access, asking why. A legitimate reason might exist, but the request should tie directly to the specific change, not be a shortcut to make everything easier for the agent in a way you didn’t sign up for.
Scoped test environments help. If you’re experimenting, point the agent at a dedicated folder with disposable files rather than your full home directory. That gives it something real to work with while limiting the blast radius if something goes wrong.
It’s also worth remembering that an agent running locally on your machine doesn’t mean the AI model itself is running locally. Many agent setups send data off to a hosted model in the cloud. If you ask an agent to inspect a log file or a document, think about whether that content is something you’re comfortable sending to an external service. Local control over an application and local processing of your data are two separate questions, and it’s easy to conflate them.
Installing someone else’s plugin or script adds another layer of trust entirely, separate from trusting the base tool or OS itself. Check where a plugin comes from, what it changes, and what access it requests before running it.
Is switching to an agent-first OS like Omarchy worth it? #
Remy doesn't write the code. It manages the agents who do. #
Remy runs the project. The specialists do the work. You work with the PM, not the implementers.
For most people, no, not as a daily driver replacing a Mac or Windows machine you depend on for work calls, critical software, or reliability you can’t afford to lose. Early adopters have reported real friction on newer agent-native Linux desktops: sleep issues, less reliable video call behavior, the kind of small papercuts that Mac and Windows have spent decades smoothing over. If something has to work every time, it belongs on an OS that’s already proven itself. But for developers curious about what agent-driven OS customization looks like, an old spare machine, the dead Mac Mini sitting in a drawer, is a low-risk way to experiment. Nothing critical depends on it, so you can let an agent make sweeping changes and learn from the results without real consequences.
For everyone else, the more practical path is applying the same scoped, tool-by-tool approach to the Mac or Windows setup you already have. You don’t need a new OS to start the conversation with an agent about how your desktop should work. You need the right tools and requests small enough to verify.
Frequently Asked Questions #
Do I need to install Linux to let an AI agent customize my desktop?
No. Tools like Aerospace, Apple Shortcuts, and PowerToys Workspaces let an agent modify real settings on a Mac or Windows machine you already use, without switching operating systems.
What’s the safest way to start letting an agent make changes?
Pick one small, specific task, like moving an app to a particular window position, ask the agent which file or setting it plans to change, keep a copy of the original setting, and confirm the agent can undo the change before you let it proceed further.
Why do some settings work well with agents and others don’t?
Settings that live in a readable config file with a documented command to apply them give an agent a clear way to act and verify results. Settings buried in a graphical interface with no scriptable equivalent are much harder for an agent to reliably operate.
Does running an agent locally mean my data stays local too?
Not necessarily. An agent running on your machine may still send content like logs or documents to a cloud-hosted model for processing. Local control of an application and local processing of your data are separate questions worth considering separately.
Is Omarchy worth trying if I mainly use a Mac or Windows PC?
It depends on your goals. Omarchy now offers Mac and Windows trials so you can explore agent-driven desktop customization without replacing your OS, and it’s a useful way to see what’s possible. For daily, mission-critical use, sticking with a proven Mac or Windows setup and applying the same agent-tooling approach there is generally the more reliable path.