Aro is a macOS menu-bar utility and command bar for people who live in Finder. It opens with Control + Space, reads your current folder and selected files, asks what you want in plain English, then plans and performs the task one step at a time.
Unlike a launcher, it isn't about opening apps. Unlike a macro tool, it doesn't make you build workflows first. Unlike a folder-rule utility, it isn't limited to preconfigured rules. Aro is built for the messy middle, the moment you're looking at files and think “I just want these renamed, converted, counted, sorted, zipped, or cleaned up.”
at a glance
the shape of it
- main job
- natural-language file work around Finder
- platform
- macOS (menu-bar + command bar)
- interface
- Spotlight-style floating command bar, Control + Space
- context
- Finder selection, front folder, visible items
- execution
- agent loop: plan one step, run or ask, observe, continue
- safety
- UI approvals + Rust preflight before every shell command
- providers
- DeepSeek, OpenAI, Gemini, Grok, local, custom
- license
- open-source · MIT
what it does
say it, see it happen
Aro handles local file tasks on macOS through natural language, on Finder-selected files or the visible items in the current folder. A few things people type:
rename this selected file to invoice-final.pdforganize this folder by file typeconvert the selected images to JPEGmake a zip of the selected fileshow many files are in this folder?compress these screenshotswhy i made it
the gap between finder and the terminal
Finder is where most Mac users understand their files visually. The terminal is where the useful operations actually become efficient. Those two worlds are separated by friction, Finder knows the files but not your intent; the terminal can do anything but makes you manage paths, quoting and edge cases by hand.
The rules I built around were simple: you shouldn't copy file paths, the AI shouldn't guess names, the generated command should never be hidden, risky actions should pause, safe actions should feel fast, and you should own your provider choice, including local models.
how it works
an agent loop, not a one-shot
The big shift from the first version: the old Aro asked the model for a single command. The new Aro asks it to behave like a step-by-step agent, issue one command, read the result, decide the next, ask for clarification, pause for approval, and provide undo where it can. Built with Tauri 2 + Rust for the native shell, Finder access and command execution, and React + TypeScript for the command bar.
summon
Control + Space opens a centered, calm command bar. No Dock icon, it behaves like Spotlight, not an app.
read finder
One AppleScript call (off the async runtime, with a timeout) returns selected files, the current directory, and visible items.
plan
A tight system prompt asks the model for exactly one JSON action, run, ask, or done, never inventing file paths.
predict
Rust classifies the command: safe, creates, modifies, deletes, network, system. That powers the inline risk label.
approve
Safe read-only steps can auto-run. Riskier steps pause with inline Run / Skip controls.
preflight
Before execution Rust refuses dangerous patterns, sudo, rm -rf /, piped remote scripts, and sanity-checks every mv.
execute
The command runs in the Finder working directory; stdout, stderr and exit code come back.
observe
A compact observation goes back to the model, which decides the next action. Repeat until it can say done.
core product
what makes it different
agentic multi-step
Runs one step, reads the result, decides what comes next, organize a folder, convert then zip, inspect before renaming.
finder awareness
Acts on your selection, current folder, and exact visible items. No copy-pasting paths.
asks, never guesses
If the target is ambiguous, Aro asks which file, preventing a whole class of wrong-file mistakes.
transparent transcript
Every step is visible: intent, exact command, risk label, output, undo where available.
bring-your-own provider
DeepSeek, OpenAI, Gemini, Grok, local or custom OpenAI-compatible endpoints. Not locked to one vendor.
local model support
Point at an OpenAI-compatible local server (Ollama, LM Studio) and keep file context on your own machine.
rust safety preflight
Model output is untrusted. A backend guardrail runs immediately before execution and can’t be bypassed.
undo for moves
Simple mv actions get a calculated reverse command and an Undo button in the transcript.
landscape
where aro wins
Many of these are broader and older. The point isn't that Aro is more mature, it's that Aro is better for one specific job: natural-language, Finder-aware, inspectable file actions with open provider choice.
Raycast Pro
from $8/moAro is narrower but Finder-file-specific: selected files, visible items, a command transcript, local preflight, and a core local/custom-model path.
Alfred Powerpack
£34 licenseAro needs no workflow built first, it starts from plain English and asks clarifying questions in the moment.
Keyboard Maestro
$36 one-timeAro plans from the live Finder state instead of asking you to assemble a macro for a one-off task.
Hazel
$42 licenseAro is interactive and contextual, no predefined folder rules; it acts on what’s in front of you right now.
Setapp
$9.99/mo bundleAro is one focused, inspectable, open-source agent instead of a paid bundle or a credit system.
reasoning
the decisions behind it
why the transcript matters
It isn’t decoration, it’s the trust mechanism. It shows what Aro thinks it’s doing, the exact command, whether the step is safe or risky, the result, and whether undo is available. AI tools usually fail by hiding too much; Aro exposes the operational layer.
why safety lives in rust
The model is not a trusted executor. UI warnings are too weak on their own, so the Rust preflight is the real boundary, it runs immediately before execution and can’t be bypassed by a model response. Planning, approval, preflight and execution are deliberately separate layers.
why provider choice matters
File-command planning isn’t always a premium-model task. Sometimes you want cheap and fast (DeepSeek), sometimes stronger reasoning (OpenAI), sometimes no tokens at all (a local model). Choice keeps Aro resilient, not locked to one API, price, or privacy posture.
why open source
An app that generates and runs shell commands needs trust. Open source lets people inspect the execution boundary, verify keys stay local, improve the preflight, and fork the behavior. For this category, transparency is part of the product.
honest limitations
- It still runs shell commands, review modifying actions.
- Side-effect prediction is keyword-based, not a full shell parser.
- Preflight is conservative but not a formal sandbox.
- Local models may ignore the JSON protocol more often.
- Complex pipelines are harder to classify.
- Unsigned builds trigger normal Gatekeeper warnings.
what's next
- +A real shell AST parser for safer analysis.
- +Dry-run previews for supported operations.
- +Signed and notarized builds.
- +Per-folder memory and task templates.
- +A visual “plan” mode before multi-step runs.
- +More reversible operations beyond simple mv.
“tell aro what you want to do with the files in front of you. it plans carefully, shows its work, asks when unsure, and runs only what passes local safety checks.”
More contextual than a chatbot, more direct than a macro builder, more interactive than folder rules, and more open than paid closed-source tools. The promise isn't “AI will control your Mac”, it's control you can see.