Deploy Your Agent and Sync Your Brain
Everything so far has run on your laptop. Close the lid and the agent stops existing. Today it moves to a machine that does not close, and the notes and skills stay identical on both.
You need a working agent and a vault from Module 1. Local commands are macOS; the server is Ubuntu. Bring a payment method if you want to create the server live.
The ideas that carry the session
Measure before you design the sync
A 16 GB vault whose markdown is 4.7 MB does not have a 16 GB problem. Every heavyweight option people reach for first, block storage, object storage, a file sync daemon, exists to solve a problem this vault does not have.
The ignore list comes before the first commit
Git tracks a file from the moment it is committed. Commit 15 GB of video, add the rule afterwards, and the video is still in the object store, in every clone, forever. Undoing it means rewriting history.
Skills belong in the repository
A skill in the repo wins over the global profile, the autonomous curator will not rewrite it, and a poisoned skill arriving on a git pull gets quarantined rather than loaded. Write once, and both machines have it.
Hardening has an order
Confirm a second SSH session as the new user before you lock root out. Locking yourself out of a server is memorable and costs ten minutes. The order is the lesson, not the commands.
Nothing is listening
No web server, no dashboard, no published port. The reason this is safe is that the only open door is SSH from your own address. A server with one door is a server you can reason about.
Write lanes beat conflict resolution
Give each machine a lane and write it into a context file both agents read. Nothing enforces it. It is a convention plus one paragraph, and it turns a weekly merge conflict into a rare one.
A job with no reasoning in it should not cost tokens
The push script stages, commits and pushes. None of that needs a model. Using the agent would spend tokens, add latency, and make the sync depend on the gateway being healthy.
Sync the notes, never the state
Two agents share a folder, not a mind. Sessions, memory and the state database stay on the machine that made them. Two writers pointed at one home compound each other into state neither of them authored.
The SSH backend moves commands, not content
Hermes can run the laptop agent's commands on the droplet directly, over the same hardened connection from the hardening step, instead of on the laptop. It does not sync the vault: that still moves by git, on purpose, so nothing writes to the same folder from two places at once.
The 60-minute session
Part one turns the vault into a repository. Part two builds the server. The last seven minutes are protected for the sync loop, because a note written on the server and read on the laptop is the deliverable.
Open with the payoff
Obsidian and a server terminal side by side. Brief the server, and the note appears on the laptop without touching it. Then the cost, said out loud, because it recurs.
Measure your own vault
Four commands on your own notes. The host vault is 16 GB and the markdown inside it is 4.7 MB. Nobody designs a sync before knowing that ratio.
Git, in the order that matters
The ignore list is written before the first commit, because git tracks a file from the moment it is committed and no amount of ignoring afterwards removes it.
Skills move into the repo
Your own skills into .hermes/skills/, then hermes skills trust, then /skills proves they loaded as project skills. Precedence, and why the curator never touches them.
Create and harden the Droplet
A non root user, a cloud firewall, and a second SSH session confirmed before root is locked out. UFW, fail2ban, unattended upgrades. The order is what stops you locking yourself out.
Hermes in Docker
No published port, and a write sandbox extended to reach the vault. The three config settings that are wrong by default for a box nobody is watching.
Clone the brain, trust the repo
A credential scoped to one repository with a mandatory expiry, created on camera. Then the confirmation brief, written to surface the write error rather than route around it.
Close the loop
Write lanes so conflicts are prevented rather than resolved, a push script on a plain crontab, and the proof: a note written on the server, read in Obsidian on the laptop.
The build, step by step
Every command and every copy-pasteable brief is in the student guide.
What it costs
- A Droplet, 1 vCPU, 1 GB, 25 GB SSD
- About 6 USD a month
- Weekly backups, optional
- About 1.20 USD a month
- A private GitHub repository
- Free
This is the first recurring cost in the course. It keeps billing after the session ends, so the last segment shows how to destroy the server, and the homework includes setting a billing alert.
The honest part
You now have two agents, and they do not share a mind. They share a folder. Sessions and memory stay on the machine that made them, and that is deliberate: two agents pointed at one home compound each other's entries into state neither of them authored. Sync the notes. Never sync the state, the session history, or the environment file.
Knowledge check
Five quick questions to check your understanding, then four to answer in your own words for peer review.
1.Why must .gitignore be written before the first commit and not after?
2.Your vault is 16 GB and the markdown in it is 4.7 MB. What does that tell you?
3.Where does Hermes look for project skills?
4.You mount your vault at /opt/brain in the official Hermes Docker image and the agent cannot write notes. Why?
5.Which of these should never be synced between your laptop and your server?
Explain in your own words
Answer these in your own words. Explaining a concept is the best test that you understand it. You can check your results now; sign in when you save to keep them in your account.
Where this sits in the course
Each module is a standalone hands-on session, though the later ones build on what the earlier ones left running.
Join us live
Register on Luma to get the student guide and the livestream link. Read the guide before you arrive; the session moves at the speed of someone who already has the accounts open.