I’ll not bore you with the log files and gateway restarts. It’s the interesting bit that came next.

The detour that paid for itself

While I was geetting DeepSeek v4 Flash (my favourite model at the moment in Hermes), my agent noticed something else was broken: vision. The tool for reading images was pointing at a model that no longer existed on the provider. It returned a 404, quietly, the way these things do.

I asked it to find a working one. It went digging through the provider’s live catalogue and came back with something better than a fix — it came back with a free one.

Nous carries genuinely free models. Not free-trial, not free-until-the-end-of-the-month. Free. And the free vision model worked perfectly – but whist the agent was working through the logic of finding the free model, it was pinging around reading price lists of different provider APIs.

That’s when the actual idea arrived.

“Am I on the best model?”

So by default I have some credits in Nous and Merge. I also think that Nous can route through Open Router, but whenever I’ve tried to do that before, I’ve got frustated and gave up.

So Hermes is logicizing as a good agent would and then I stopped it:

That’s interesting that Merge and Nous expose their model prices. Can you set up a skill and a cron job to email me the list of the cheapest once a week so that I know I’m on the best model? Or maybe actually that list would be too long — I don’t need any Anthropic or OpenAI or Gemini info because I have monthly plans for all of those. It’s really where is the cheapest DeepSeek model and if there are any new models at a good price to try.

That last bit is the whole thing. A list of every cheap model is noise. A list that says here’s the cheapest DeepSeek, and here’s anything new worth trying is a decision. And the filter that makes it useful is the one only I could give: I already pay flat monthly rates for Anthropic, OpenAI and Google. Their prices are irrelevant to me. Showing them would be filling the page to look thorough.

So: two providers I actually route to (Nous and Merge), cheapest-first, with the flat-rate vendors stripped out.

Then we hit the small problem

I’d asked for it by email. My agent went looking and found that email isn’t set up on this machine at all. No mail client, no SMTP credentials, nothing. A perfectly good idea, blocked on a delivery route.

What I liked about this bit is that it didn’t just stop and ask me to configure email. It went and found what was already wired up. Which helped me to also suggest an option:

Me: Slack?

Slack. Already connected, already delivering, already where I’d see it. The channel was the easy part; I’d just assumed email because that’s what I’d asked for.

The build

What came out the other side was three things:

• A script that queries both providers’ live catalogues, reads the real per-token prices, and prints a short digest. No AI in the loop for the data — it’s deterministic, so the numbers can’t drift or get “summarised”.
• A skill — a note to my agent about how the whole thing works, so next time it doesn’t have to rediscover that one provider quotes prices per token and the other per million, or that a listed route sometimes 404s on the real call.
• A cron job — every Monday at 8am, straight into my Slack.

It also keeps a list of every model it has seen, so from week two onward it can tell me what’s new rather than re-reading the whole catalogue at me. Small detail. But that’s the difference between a report and a notification.

The first thing the radar found was me

Here’s the bit I didn’t expect. I asked it to check the cheapest DeepSeek route, assuming the answer would be “the one you’re on, well done”. It wasn’t.

Same model, different route, and the price gap was silly:

Merge’s input price is higher. Its output price is eleven times cheaper. Which one wins depends entirely on how you actually use the thing — and I didn’t know that, so I asked it not to guess either. It went to my real logged usage and did the maths on my own numbers, not a hypothetical.

Merge came out about 57% cheaper for me. The reason is that my usage is dominated by cached reads — the same long context being re-read over and over — and Merge charges a fraction of what Nous does for exactly that.

But a price on a page isn’t proof. So it made one live call, and the listed price matched the actual bill to the cent. Then it switched me over and checked the gateway came back up on the right model.

Me: Yes, make the switch please

Done. Same model, roughly half the price, verified rather than assumed.

What I’m taking from it

Silent failures are the expensive ones. A model that stops answering tells you immediately. A model that quietly downgrades itself tells you nothing, and you carry on for weeks wondering why the thinking feels thinner. If a setting matters, test that it works, not that it’s set.

The useful version of “monitor prices” is “answer one question”. I didn’t want a market report. I wanted to know whether I was on the cheapest DeepSeek and whether anything good had shown up. Everything else was decoration.

Give the constraint, not the spec. “I have flat plans for those three” is the most valuable sentence I gave it. That’s the bit a generic tool can’t know and can’t guess — and it’s the bit that turned a long list into a decision.

The best fixes are the ones that keep working. I could have asked “what’s the cheapest model?” and got an answer that was stale within a fortnight. Instead I’ve got a robot that checks every Monday, and a note to my agent that means it won’t have to learn the same lessons twice. The answer is the small part. The habit is the useful part.

And it did, in the end, find itself a cheaper model. I just had to ask.

If you think this would be useful, you can have it. The script and the skill are on GitHub — point them at your own providers and they’ll do the same job for you:
github.com/andygauk/model-price-radar

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_here

Hermes 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-lite

If 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.