Meet Pilot: A macOS Agent That Handles Your Repetitive Desktop Work

Some work on a Mac never really becomes a skill. Renaming a folder full of screenshots. Pulling three numbers out of a PDF into a spreadsheet. Exporting the same report, attaching it to the same email, sending it to the same person every Friday. You already know how to do it — that's the problem. The knowing is done, and what's left is the clicking, and the clicking doesn't get faster no matter how many times you repeat it.

Pilot is a macOS agent built for exactly that residue. It works your Mac the way you do: opening apps, clicking buttons, typing into fields, reading what's on screen, and moving to the next step. It's aimed at power users, developers, and technical creators who already lean on scripts, Raycast, Shortcuts, or AppleScript and have hit the edges of what those tools can reach.

What Pilot actually does

The short version: Pilot is an LLM that actually uses your Mac. You describe a task in plain language, and the agent carries it out across your real applications — the file system, native apps, and Shortcuts — instead of just suggesting what you might do.

That distinction matters. Most assistants are good at the suggesting part. Ask one how to batch-rename files or move data between two apps, and it'll hand you accurate steps. But the steps still land back on you. Pilot closes that gap: it executes the steps on the surface where the work lives. It can see a window, decide where to click, fill in a form, check the result, and keep going until the task is done.

Crucially, it isn't limited to apps that ship an automation API. Because Pilot operates the desktop directly — reading the interface and acting on it — it reaches software that was never designed to be scripted. The legacy app with no AppleScript dictionary, the web tool with no public API, the internal dashboard nobody will ever build an integration for: those are exactly the places where manual clicking piles up, and exactly where Pilot is meant to help.

How is Pilot different from Shortcuts or AppleScript?

Shortcuts and AppleScript automate apps that expose hooks for it, following a fixed script you write in advance. Pilot is an agent: you give it a goal in plain language, and it figures out the steps at runtime, adapts when a window looks different than expected, and can drive apps that have no scripting interface at all — because it operates the interface itself.

This is the core reason people reach for an agent instead of a macro. A Shortcut breaks the moment a button moves or a dialog you didn't anticipate appears. An agent can look at what's actually on screen, notice the change, and adjust — the same way you would if you were doing it by hand. You trade some of the determinism of a hard-coded script for the ability to handle the messy, slightly-different-every-time tasks that scripts were never good at.

Built to be trusted, not just turned loose

Handing software the ability to click and type anywhere on your machine is not a small thing, and Pilot treats it that way. An agent that can do your repetitive work can, in principle, do anything — so the design question isn't only "can it act?" but "can you trust it to?"

That's where most of the engineering goes. Pilot is built around a permission model that scopes what the agent can touch, safety boundaries that keep it from wandering past the task you gave it, and observability so you can see what it did and why. You're not staring at a black box that occasionally moves your cursor; you get a legible trail of the actions it took. For a tool whose whole job is to operate your computer on your behalf, that visibility is the feature that makes the rest usable.

It's also why Pilot is open. The code, the issue tracker, and the roadmap are all public on GitHub — which means the permission and safety model isn't something you take on faith. You can read exactly how the agent decides what it's allowed to do, file an issue when something feels off, and watch the guardrails evolve in the open.

Where Pilot fits in a real workflow

The best tasks for Pilot are the ones that are tedious but not delicate — work with clear steps and a clear definition of done, where the cost of doing it by hand is mostly just your time and attention.

A few concrete shapes that fit well: pulling fields out of a stack of invoices and dropping them into Numbers, then saving the file where it belongs. Cleaning up a photo library — batch-renaming, tagging, sorting into albums. Running the same multi-app export-and-send sequence on a schedule. Moving data between two tools that have no integration between them, where today you copy-paste one record at a time. None of these are hard. All of them quietly eat hours.

And because Pilot composes with what you already use, it doesn't ask you to abandon your existing automation. The Shortcut you've trusted for two years can stay exactly as it is; Pilot is for the parts your scripts could never quite reach. In practice, most people don't replace their automation stack — they extend it, handing the brittle, interface-dependent steps to the agent and keeping the deterministic ones in scripts.

What Pilot is not good for, at least today, is anything irreversible or high-stakes where a wrong click costs more than the time it saves: moving money, sending messages you can't unsend, deleting things you can't recover. The permission model is there to keep the agent boxed into the safe, repetitive middle of your workflow — and you should keep it there on purpose. Used that way, the payoff compounds: every task you hand off is one you never have to think about again.

Getting started

Pilot is an open project, so the fastest way to understand it is to look at it. The repository walks through setup, the permission model, and the kinds of tasks the agent handles today — and the roadmap is public, so you can see where it's headed and weigh in.

If you've ever finished a stretch of clicking and thought the computer should have done that, Pilot is built on the same instinct.

Pilot is an open macOS agent — code, issues, and roadmap on GitHub: https://github.com/ahn283/pilot-ai