Hermes Agent and AgentBridge: target-side limits for a home AI agent
Running Hermes Agent on a Mac mini behind AgentBridge, a broker that sends verb tokens instead of commands so each target machine enforces its own allow-list, and using it to build a synced Final Cut multicam project from one prompt.
I run an always-on AI agent at home and wanted it to check on my servers and handle video prep jobs, without giving it shell access to anything. Every guardrail I found for agents enforces its rules on the agent's side, so a prompt injection or a stolen key gets past it. I wrote AgentBridge, a small broker that sends the target machine a verb token instead of a command, and each target enforces its own list of allowed verbs. The first real job it runs builds a synced multicam project in Final Cut Pro from one prompt sent from my phone.

Why the limit has to be on the target
In September, Inc. columnist Jason Aten reported that Meta's new agent, Muse, read his Mac's Messages database after he had declined to give it access, synced up to at least row 187,462, and then told him it only saw notification previews (Decrypt, AppleInsider). A Meta executive later called the agent's explanation "on us." The reporting traces back to Aten's account, and the row number is not a message count.
What matters for this post is where the refusal lived: in a setting controlled by the agent's own software. When that software got it wrong, nothing else stood in the way. The lock was on the wrong side of the door. That's the design I wanted to avoid.

Hermes Agent
Hermes Agent is an open-source agent from Nous Research (source). I'm currently running version 0.21.3 on my headless M1 Mac mini with 16 GB of RAM. That lets it run tasks in Final Cut Pro now, and Jellyfin maintenance in the future. The main model is GPT-5.6 through a ChatGPT subscription, and smaller side tasks go to cheaper models.
Hermes has its own safeguards, and I use them: it asks before running commands, refuses a list of dangerous ones, and can only write inside one work folder. All of those are enforced by Hermes on the Mac mini.

Reaching it from my iPhone
I run the Hermes web UI on the Mac mini and use it from my iPhone through Hermex (source), a native iPhone app for Hermes Agent. The phone reaches the Mac mini over Tailscale, a private network between my own devices, so the web UI is never open to the internet, and it has its own password on top of that. When Hermes wants to run a command, Hermex shows the full command and lets me allow it once, for the session or always, or deny it. The approval step works from anywhere I have signal.
Pre-existing projects
Before writing anything, I looked for an existing tool. There are policy proxies, approval layers and phone clients with confirmation prompts, and every one I found works the same way: the agent's side decides what's allowed, then sends a real command to the target. If the model is manipulated by a poisoned web page or log line, or the agent machine's SSH key is stolen, the target runs whatever it receives.
AgentBridge
AgentBridge is a Swift program that runs on the Mac mini as a background service bound to localhost, and Hermes talks to it as an MCP server. It never sends commands. It sends a verb token: a short name for an action, such as uptime or disk.
It works like ordering from a menu by number. You say "number 4," and the kitchen decides what number 4 means. You can't add "and also hand me the keys to the register," because the kitchen only knows the menu.
Without that, an agent checking a server sends a real shell command over SSH, and the server runs whatever text arrives. If the agent is tricked into sending uptime; rm -rf /, or someone steals its SSH key, the server runs that too.
On each target machine, the SSH key the broker uses is restricted in authorized_keys to a single dispatcher program, with no shell and no port forwarding. The dispatcher looks the token up in a list kept on the target. If the token is on the list, it runs the command that token stands for. If not, it exits with code 126 and logs the attempt.
| Token sent | What the target does |
|---|---|
disk |
Runs the fixed disk-space command listed next to it |
docker.logs:ntfy |
Returns that container's recent logs |
disk; touch /tmp/x |
Refused, exit 126, logged |
docker.restart:ntfy |
Refused: in the catalog, not enabled on this target |

- The list lives on the target, so breaking into the agent or the broker gets an attacker nothing new.
- Each target has its own list. Currently every target is on the read-only tier: 13 verbs on one machine and 19 on another, covering uptime, disk space, container lists and logs.
- Each target keeps an audit log of every allowed verb and every refusal.
Testing it
I tested the targets directly with the broker's private key, bypassing the agent and the broker entirely.

| Attempt | Result |
|---|---|
A valid verb with a second command appended (report.publish;id) |
Denied, exit 126 |
Command substitution ($(touch /tmp/PWNED)) |
Denied, nothing created |
An interactive shell (sh -i) |
Denied |
A restart verb that exists in the catalog but isn't enabled (docker.restart:ntfy) |
Denied, service kept running |
uptime, disk, docker.ps |
Allowed |
At the time of writing, that target's log has 47 entries, 15 of them refusals, all from tests. So far, nobody but me has knocked.
Publishing reports
The first write permission I enabled lets Hermes publish a research report as a web page on my local network. It's an opt-in verb with its own gate. The token is still just the word report.publish. The page arrives as data on standard input, never as a path, and the gate builds the file path itself from a strict name. Requests with unexpected fields are refused.


The storage side follows the same rule. The account the Mac mini uses to read footage from the NAS can see one share, read-only.

Final Cut multicam from one prompt
I shoot two-camera interviews on Canon XF105s, sometimes with a separate audio recorder. Before editing starts, the cards have to be copied and checked, the cameras synced, the best audio chosen, a multicam clip built and a transcript made. That used to be a pile of manual steps. It's now a single job I can start from my phone.

The language model's only job is to find the footage and fill in the arguments. Everything after that is one deterministic Python script:
- Ingest. Copy the camera cards and verify every file by size and SHA-1.
- Sync. Place clips by timecode, then measure each camera's clock error by cross-correlating the audio within ±45 seconds.
- Build. Generate FCPXML with one multicam clip per continuous take, the recorder or the loudest camera as the dialogue angle, and the other camera audio at -96 dB.
- Import. Load it into Final Cut Pro through SpliceKit, a bridge for controlling Final Cut from outside.
- Transcribe. Run a local Parakeet speech model and write SRT, text and word timings.
No footage or audio leaves the Mac mini. The script is reached through the same verb system, and its gate validates every argument and allows only a short list of source folders.
The first full run worked end to end on September 26 from a prompt sent over cellular. The report from a four-take interview test:

| Takes | 4 |
| Camera clock offset measured | 14.06 s |
| Take 1 length | 150.7 s |
| Take 1 transcript | 375 words |
| Flags | Camera B nearly silent (-66 dB); no recorder audio overlapped |
What went wrong
- A recorder that matched nothing. On an older shoot, the audio recorder's files matched none of the camera clips, and forcing a match produced a confident wrong sync. A recorder is now used only when its match clearly beats the next candidate (a ratio of 2.5 or more), and is otherwise left out and flagged.
- A near-silent camera. One XF105's microphone recorded at -66 dB. The script now uses the loudest channel and camera for dialogue and flags silent ones.
- Long jobs. Hermes abandons any tool call after 300 seconds, so the prep job runs in the background and is polled.
- Model choice for the worker. Kimi K3 failed multi-step tool calls on NVIDIA's endpoint. GLM-5.3 passed 10 of 10 trial runs and Nemotron 3 Ultra 4 of 5, so GLM-5.3 runs the job. It's slow, with minutes between steps, but it finishes.
Verdict: Hermes Agent
Hermes is the most capable always-on agent I've tested, and its approval prompts are clear. It uses a lot of tokens, some of its setup commands are interactive and don't script well, and the 300-second limit on tool calls means long jobs need a background-and-poll design.
Verdict: target-side enforcement
Putting the allow-list on each target is more setup than a central policy layer, since every machine needs its own dispatcher. In return, what the agent can do no longer depends on the agent behaving. It can request anything, and the answer comes from a list it can't reach.
Next
Enabling the first restart verbs, with rate limits enforced on the target, and testing what happens when a log the agent reads contains instructions.
Credits
- Hermes Agent by Nous Research. The Hermes Agent logo on the link card is theirs, from the project's documentation.
- Hermex by Uzair Ansar, the iPhone app
- SpliceKit by Elliott Tate, for the Final Cut bridge and local transcription
- Logo marks from Simple Icons. The logos belong to their owners.