I wanted a simple, human-friendly record of the changes I’m making to my apps.
What did we change? Why? Does it work? What’s still left to do?
GitHub keeps the technical record, including the diffs showing exactly which lines of code changed. Useful, but I’m not going to sit down with a coffee and digest those. When I come back to a project, I want a readable account of where I left it.
So I wanted Hermes to write up each coding session and save it to a running log in Notion.
Then another question occurred to me: why pay the same AI model to do the development work and write the notes? Surely a free model could handle the summary?
It can. I now use a paid DeepSeek model (but this works for any paid model, DeepSeek is cheapest at the moment) for the main development work and a free Gemini sub-agent for the write-up. I say “archive to Notion”, and the skill adds a readable entry to my project log. It’s working, and the page keeps growing as I use it.
Getting there involved a small configuration change and a lesson in free-tier limits.
What I wanted the helper to do
At the end of a session, I wanted an entry covering:
- What I’d asked Hermes to do.
- What changed in the app, explained in ordinary language.
- What had been tested and anything still unfinished.
- Any useful lesson worth keeping for next time.
That gives me something I can scan before starting work again. GitHub has the code history; Notion gives me the account of what happened and why it mattered.
Sub-agents are a familiar feature in agentic coding tools: the main agent hands a defined piece of work to another agent, which works through it separately.
Hermes has an inbuilt function called delegate_task to call up the sub-agent. That’s the mechanism I used to hand over the session write-up.
Beyond my coding log, the same setup could be useful for turning supplied meeting notes into actions, preparing a project handover or drafting release notes from completed changes.
Start with a clear, contained job whose output you can easily check.
Delegate the write-up and change who’s doing it
Delegation alone wasn’t the money-saving bit.
By default, Hermes sub-agents inherit the main agent’s model and provider. If your main conversation uses a paid model, its helpers normally use that paid model too. You’ve divided the work, but you’re still paying the same model rates.
What I wanted was a different arrangement: keep DeepSeek on the development work, then send the routine write-up to Gemini’s free tier.
Two settings make that possible: delegation.provider and delegation.model. They tell Hermes which provider and model to use for delegated work. The official Hermes documentation explains this model override.
That gave me the workflow I was after:
Paid agent makes the app changes → free sub-agent writes the human-friendly record → the record goes into Notion.
The main agent still does some paid work preparing the handover. The saving is on the helper’s model calls, rather than making the entire conversation free.
Setting it up
This assumes you already have Hermes running with your main model. If you don’t, Hermes has an easy quick-start guide.
1. Get a Gemini API key
Head to Google AI Studio and create an API key. This lets Hermes talk to Gemini directly.
Check that the project you’re using is on the free tier and that your chosen model has a free allowance. An API key isn’t inherently a “free key”: the project’s billing tier and the model matter.
I ended up choosing gemini-3.5-flash-lite. Google currently lists free-tier input and output for it on its API pricing page.
2. Add the key to Hermes
In a standard Hermes installation, credentials live in ~/.hermes/.env. The ~ means your home directory on the machine running Hermes.
Add your key like this, replacing the placeholder:
GOOGLE_API_KEY=your_actual_key_hereHermes also supports GEMINI_API_KEY. You only need one for this setup. See its provider setup documentation.
Treat the key like a password. Put it in the local settings file, rather than sharing it in a prompt or screenshot.
3. Choose the helper’s model
In ~/.hermes/config.yaml, add:
delegation:
provider: gemini
model: gemini-3.5-flash-liteIf there’s already a delegation: section, update it rather than adding a second one. Keep the indentation as shown.
These settings select Google as the helper’s provider and Flash-Lite as its model. Your main model can stay as it is.
One detail worth knowing: this sets the default for ordinary delegated sub-agents generally. It doesn’t create a special “summaries only” helper. Remember that if you also delegate more demanding work. Hermes explains the scope here.
Restart Hermes so it loads the updated settings.
4. Try a small job first
Before involving Notion, test a basic summary. For example:
Use a sub-agent to summarise these notes in three bullets: we fixed the mobile menu, updated the contact page and still need to test the newsletter form. Return the summary here. Don’t change any files.
Then check which provider and model actually handled the delegated task. Ask Hermes to inspect the task details or logs, rather than relying on the helper saying “I’m Gemini”.
During my setup, we tested the Google connection directly and then ran an actual sub-agent. Both returned output.
That proved the connection and delegation worked. The next test was whether it could finish the job I really wanted.
Then I hit the free-tier ceiling
My first attempt to archive a session to Notion failed.
The helper hit a rate limit.
This is the bit I’d overlooked: “write up this session and save it” sounds like one request to us. An agent may need several exchanges with its model while it reads information, calls tools, checks the responses and decides what to do next.
The limits recorded during my session were five requests per minute for the Flash model I tried first (Gemini 3.8), compared with fifteen for Gemini 3.5-Flash-Lite. (I’ve heard that you can get even more out of Gemini 2.5 but when I looked at Google’s documentation it was talking about depreciation so I gave it a swerve.) Switching to Flash-Lite gave my archive workflow enough room to complete. It has continued updating the Notion page as I use the skill.
Those numbers are a snapshot of my setup, not a promise about yours. Google also limits requests per day and tokens per minute—the amount of text being processed. Check your project’s active allowance in AI Studio using Google’s rate-limit guide.
If your helper starts successfully but runs into a quota error partway through, check those limits before assuming the configuration is broken. More room per minute won’t fix an exhausted daily allowance.
Give the helper a proper handover
There was another detail that mattered for my archive job: the sub-agent doesn’t automatically inherit the conversation we’ve just had.
It starts a fresh conversation. Hermes can supply project instructions, but the main agent still needs to pass on the task and relevant background. The delegation documentation makes this explicit.
“Write up what we did” is therefore a fairly useless brief on its own.
The main agent needs to gather the original request, the completed changes, the test results and any outstanding work, then give that information to the helper with instructions about where to save it.
It’s much the same as handing work to a colleague. If they weren’t in the meeting, “you know, that thing we discussed” won’t get them very far.
Turning it into “archive to Notion”
I put the archive workflow into a reusable Hermes skill: saved instructions for a job I expected to repeat.
The trigger is simply:
Archive to Notion.
The skill tells the main agent to prepare the handover, delegate the write-up and have the helper add a dated entry to my project log.
It also specifies how the notes should read. “Updated the authentication handler” might be technically accurate, but “Fixed the login problem that stopped returning users getting into the app” tells me something I can use.
That’s the point of the summary. I want to understand the change without having to reconstruct it from filenames and code.
For anyone copying this part, Notion access is a separate prerequisite. Choosing Gemini as the helper’s model doesn’t connect your Notion account or give it access to a page.
Once that connection is available, you can ask Hermes to create your own version of the skill:
Create a reusable skill called “archive to Notion”. When I use it, gather what I asked for, what changed, what was tested, any unfinished work and lessons learned. Pass that information to the configured sub-agent. Have it write a concise, plain-English entry with a session title and date, then append it to [my Notion page]. Preserve the existing entries and read back the new entry before reporting success. If the free helper can’t complete the task, use the main model to finish it and tell me that you did.
Replace the page placeholder with your own destination. Change the fallback instruction if you’d rather stop when the free model hits a limit.
There’s a useful line in this independent guide to Hermes delegation: “Subagents reduce context load; they do not remove the need for verification.”
For my workflow, that means checking the entry actually exists in Notion. A helper saying it saved something isn’t quite the same as having a record I can read.
Decide what should happen when free fails
When my first free archive attempt hit the rate limit, nothing had been saved.
The workflow built in its own fallback: basically if the free model doesn’t work then the paid model would do the job. As you can imagine, for me that was pointless. I did have stern words with DeepSeek on that and then they realised the error of their ways, we came up with a different fallback – don’t fail quietly, say what’s wrong. Then we can fix it once and get the free model working going forward.
For me, free and working was more important than ignoring the issue and paying.
The rule to the paid model was:
If the free helper fails, stop and tell me. Don’t switch to a paid model.
This is something to be aware of if you creating this setup for yourself.
A record I’ll actually read
I now have a growing Notion log of the work I’m doing on my apps. Each archive adds another readable account of what changed, what worked and where I left things.
That was the job I wanted done. The free sub-agent makes the routine write-up cheaper, and the skill makes it easy enough that I keep doing it.
If you’re trying this yourself, get a simple summary working first. Then add the saving and verification steps.
And make sure the notes sound like something you’ll want to read. Otherwise, you’ve gone to quite a lot of trouble to create another page you’ll never open.
Fancy a chat about this? Find me on LinkedIn or X, or drop a comment below.