Set up my AI agent

Set up Hermes Agent on this computer for me, the way @byamaad runs his. Hermes is the free, open source agent from Nous Research (github.com/NousResearch/hermes-agent, docs at hermes-agent.nousresearch.com/docs). Do every step yourself in the terminal. Only stop when a step needs me in a browser, and tell me exactly what to click.

BEFORE YOU START
1. Check my computer. macOS needs Apple Silicon (Intel Macs aren't supported). Linux is fine. On Windows, stop and tell me to set up WSL2 first. Check that git and curl work.
2. If `hermes` already exists or ~/.hermes already exists, stop and ask me before changing anything.
3. Ask me which subscriptions I have: Claude Pro or Max, ChatGPT Plus or Pro, or both. Wait for my answer.

STEP 1: INSTALL
Run: curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash -s -- --non-interactive --skip-computer-use
Then make sure `hermes --version` works (the launcher is in ~/.local/bin; use the full path ~/.local/bin/hermes if PATH isn't updated yet).

STEP 2: THE BRAIN (my subscription, no API key)
If I have Claude:
- Make sure the `claude` command (Claude Code) is installed and logged in: `claude auth status`. If it isn't, install it with `npm install -g @anthropic-ai/claude-code` and have me run `claude auth login`.
- Make sure ANTHROPIC_API_KEY is not set in my shell, because the subscription plugin refuses to run with it.
- hermes plugins install claude-subscription-directsdk
- hermes plugins enable claude-subscription-directsdk-experimental
- hermes config set model.provider claude-subscription-directsdk-experimental
- hermes config set model.default opus   (use sonnet if I'm on Claude Pro)
If I have ChatGPT:
- Have me run `hermes auth add openai-codex` in my own terminal. It shows a link and a code. Wait until I say it's done.
- If I only have ChatGPT: hermes config set model.provider openai-codex, and hermes config set model.default gpt-6-sol

STEP 3: WORKER LANES
- hermes plugins install advanced-delegation
- hermes plugins enable advanced-delegation
- hermes config set delegation.backend model_map
- Set delegation.backends.model_map.options with `hermes config set` to these four lanes, and set delegation.backends.model_map.default to standard:
  fast: "Cheap and quick: reading files, summaries, lookups, bulk checks." Claude: haiku, reasoning_effort low.
  standard: "Research, writing, scripts, and builds from a clear spec." Claude: sonnet, reasoning_effort medium.
  code: "Writing, fixing and reviewing code." With ChatGPT: provider openai-codex, model gpt-6-sol, reasoning_effort high. Claude only: sonnet, high.
  deep: "Planning, strategy, reviewing work and hard calls." Claude: opus, reasoning_effort high.
  Claude lanes use provider claude-subscription-directsdk-experimental. If I only have ChatGPT, use openai-codex for every lane: gpt-6-luna for fast, gpt-6-sol for the rest.
- Check it with: hermes delegation config --show

STEP 4: HOW IT WORKS (SOUL.md)
Replace ~/.hermes/SOUL.md with exactly this:

# Who you are

You're my one main agent. I talk to you, and you decide who does the work. Talk to me like a person: short answers, lead with the answer, no filler.

## Who does the work

You have worker lanes (delegate_task, pick the `option`):
- fast: reading files, summaries, lookups, bulk checks
- standard: research, writing, scripts, builds from a clear spec
- code: writing, fixing and reviewing code
- deep: planning, strategy, reviewing work, hard calls

Keep the thinking and the final call yourself. Run parts that don't depend on each other in parallel. Do small things yourself instead of handing them off.

## Every worker gets a real brief

Workers start knowing nothing. They can't see this chat. Before you hand off a job, write a full brief: the goal, the exact files and paths, what done looks like, a length cap, and the file to write the result to. Never send a one-line task. Check what comes back before you tell me it's done.

## The brain folder

My brain folder is ~/Brain. Read ~/Brain/README.md before any job about me, my work or my projects, plus the project's own file in ~/Brain/projects/ if there is one. When I make a decision, add it to ~/Brain/decisions.md with the date and why. Drop loose notes in ~/Brain/inbox/.

## Memory

When I correct you or tell you how I like something done, save it. When we do the same workflow twice, save it as a skill.

## Ask first

Never spend money, buy anything, send an email or message, post anything, deploy, or change anything live without showing me exactly what and getting a yes. If the approval gate stops something, don't look for another way around it. Reading and researching is always fine.

STEP 5: THE BRAIN FOLDER
Create ~/Brain with projects/, inbox/, a decisions.md ("# Decisions" then "Newest first. Date, the decision, and why.") and a README.md. Ask me four questions and write my answers into README.md under "# About me": my name, what I do, what I'm working on right now, and how I like answers.

STEP 6: MEMORY
Hermes' built-in memory is on by default, so leave it on. Then ask me if I also want Honcho (deeper memory across sessions, needs a Honcho account). If yes: hermes plugins install honcho, then have me run `hermes memory setup honcho` myself and pick the browser sign-in.

STEP 7: THE APPROVAL GATE
1. Create ~/.hermes/agent-hooks/approval-gate.py with exactly this, then chmod +x it:

#!/usr/bin/env python3
# Approval gate: asks you before anything that can spend money, send, publish, delete or deploy.
import json, re, sys

p = json.load(sys.stdin)
tool = (p.get("tool_name") or "").lower()
text = json.dumps(p.get("tool_input") or {}).lower()

RISKY_CMD = r"(git\s+push|npm\s+publish|--prod\b|\bdeploy|rm\s+-rf|\bsudo\b|checkout|purchase|\bbuy\b|payment|stripe|sendmail|curl\b[^|]*-x\s*(post|put|patch|delete))"
RISKY_TOOL = r"(create|update|delete|remove|send|post|publish|pay|charge|order|purchase|refund|transfer|upload|deploy)"

hit = None
if tool in ("terminal", "execute_code"):
    m = re.search(RISKY_CMD, text)
    hit = m.group(0) if m else None
elif tool.startswith("mcp"):
    hit = tool if re.search(RISKY_TOOL, tool) else None

if hit:
    print(json.dumps({"action": "approve",
                      "message": f"Approval gate: '{hit}' can spend money, send, publish or change something live. Allow it?",
                      "rule_key": f"gate:{tool}:{hit}"}))
else:
    print("{}")

2. Register it, using the full absolute path of the script (expand ~ to my real home folder):
hermes config set hooks.pre_tool_call "[{matcher: '^(terminal|execute_code|mcp_.*)$', command: '<FULL PATH TO approval-gate.py>', timeout: 10, fail_closed: true}]"
3. Approve it so it also runs in the desktop app and in scheduled jobs: write ~/.hermes/shell-hooks-allowlist.json as {"approvals":[{"event":"pre_tool_call","command":"<the exact same full path>"}]} (merge into the file if it already exists).
4. Check it: hermes hooks doctor (it should say the hook is allowlisted and healthy).

STEP 8: TEST IT
1. hermes doctor
2. Make a junk folder ~/hermes-gate-test with one empty file in it. Then run:
hermes chat -q "Three checks, one line each. 1) What model are you running on? 2) Use delegate_task with option fast to have a worker read ~/Brain/README.md and tell me its first heading. 3) Run: rm -rf ~/hermes-gate-test"
It passes if it names the model, the fast worker reads the heading, and the approval gate stops the rm -rf so the folder is still there. Then delete ~/hermes-gate-test yourself.
3. If anything fails, fix it, and tell me what was wrong.

WHEN YOU'RE DONE
Give me a short summary: what's installed, which model is the brain, the four lanes, where the brain folder is, and whether the gate passed the test. Then tell me to open a new terminal and type `hermes` to start talking to it. Don't print any tokens, passwords or keys.