A hands-on experiment in what changes when your dev assistant lives on your machine, runs continuously, and remembers your codebase.
The context-reconstruction tax
It's 9:14 on a Tuesday. My coffee is still too hot. I've opened a terminal and I'm trying to remember what I was doing on Friday. There are 47 unread messages in #payments, three new commits on main, two PRs waiting for review, and a Linear ticket I don't remember being assigned. Before I write a single line of code I'll spend twenty minutes reconstructing context that was, in some sense, perfectly available — just not in any one place.
Every developer pays this tax. AI tools were supposed to fix it, and in narrow ways they have: completion, ad-hoc Q&A, draft commit messages. But the shape is wrong. They're request/response. You ask, they answer, they forget. They wait for you to invoke them. They never grind on your behalf overnight. They have no idea what you were doing on Friday because you never told them.
There's a reason for this shape, and it's economic. Running four agents in the background all day on a hosted API would cost real money, so nobody does it. We've collectively settled for an interactive AI assistant when what we wanted was an ambient one.
This post is about what becomes possible when you flip that constraint.
Why open weights change the math
The experiment uses running locally
ollama pull hermes3:8b # ~4.7 GB
ollama pull nomic-embed-text # ~270 MB, 768-dim
If your GPU has the room, hermes3:70b is a meaningful quality bump and is what the agent loop is most enjoyable on.
Then:
git clone <this-repo> hermes && cd hermes
python -m venv .venv && source .venv/bin/activate
pip install -e .
hermes ingest . # build memory from git log
hermes ask "what changed about retry handling?"
hermes ask "who has touched the rate limiter recently and why?"
A few honest notes:
- Re-running
ingestwipes and rebuilds the store. There's no incremental indexing in v0; the chunker runs end-to-end each time. For a few hundred commits this is a one-coffee operation. - Keep the LanceDB store off
/mnt/cif you're on WSL2 — the default at~/.hermes/store/already is. DrvFs makes small writes painful. - The agent emits tool call markers and the loop parses them. If you want to read the most interesting eighty lines, start in
hermes/llm.pyandhermes/agent.py. They're worth more than this whole post.
The next step from here is the file watcher and the second agent (the test runner is the natural next piece — it has the clearest input/output shape and the most-obvious daily-use loop). After that, the standup composer and the synthesizer make the memory layer earn its keep.
If you build any of that, I'd love to see it. The interesting part of this experiment isn't whether I finish the daemon. It's whether the shape — open weights, ambient runtime, cooperating agents over a shared memory — turns out to be the thing the rest of us have been waiting for.
Where to take it:
The case for Hermes, in one breath: **open weights** make background
inference free at the margin, so always-on agents stop being a budget
question; **native function calling** makes multi-agent a parsing
convention rather than a framework you install; **mixed sizes** let a
cheap 8B router keep a 70B specialist asleep until there's real work
to do; and **nothing leaves the box**, so private code and private
chat become first-class inputs. The reason a continuous developer
assistant is suddenly feasible isn't any one of those properties — it's
the way they compose.
The publicly accessible repo lives at https://github.com/Piwe/hermes . **Clone it** and point it at a codebase you care about — your own, your team's, an OSS project you've spent time in.
Ask it the kind of question you'd normally answer by digging
through `git log` and stale PR threads. If the answer is useful, the
shape works. If it isn't, the chunker probably wants tuning, and
that's where I'd start.
Or **fork it** and build the next agent. The test runner is the
natural next piece: clearest input (file save), clearest output
(failing tests surfaced with memory context), shortest path to a
daily-use loop. After that, a synthesizer keeps the memory layer
earning its keep, and a standup composer makes the morning brief
real. PRs welcome on any of it; new ingestion adapters, alternate
memory schemas, and entirely different agents are all in scope.
The interesting question isn't whether *I* finish the daemon. It's
whether the shape — open weights, ambient runtime, cooperating agents
over a shared memory — turns out to be the thing the rest of us have
been waiting for. Build it and tell me where you took it.
SOCIAL SHARE CARD GENERATOR