Hermes + DeepSeek V4 Flash — a 1M-context agent for pennies.

Here's the pairing in one breath. Hermes is the agent — the thing that plans, runs tools, writes files and finishes jobs on your machine. DeepSeek V4 Flash is the brain you point it at. It's the cheap, fast tier, freshly retrained for exactly the kind of long tool-calling loop Hermes runs all day, with a million-token context window behind it. Nous Research's own Teknium flagged the pairing, and the community reaction has been immediate. It took me about two minutes to wire in, and the rest of this page is what came out.

The agent was never the bottleneck. The brain was.

Hermes has always been able to do the work — run commands, write files, browse, chain tools, keep going without you.

What limits an agent like that is the model behind it. Long jobs break when the model forgets what it did twenty steps ago. They get expensive when every tool result costs frontier prices. And they stall when the model wasn't trained for tool-calling loops in the first place.

V4 Flash lands directly on all three:

It remembers everything. A million tokens of context means the whole job — every file, every result, every earlier decision — stays in front of it.

It was retrained for agents. The 0731 build is a post-training upgrade aimed squarely at agent capability and Codex-style write-run-fix loops. Same size as before; better at the loop.

It costs almost nothing. This is the cheap tier, which is what makes "let it grind for ten minutes" a reasonable thing to do rather than something you flinch at.

That's why the pairing matters. An agent that can run for a long time is only useful if the brain can afford to, remember enough to, and was taught how to.

Wire it up in two minutes.

A Hermes profile is just a folder with a config file. Making one for DeepSeek takes about as long as reading this section.

Step 1 — get a key. Grab an API key from DeepSeek's platform. This is the important bit and I'll explain why in the next section: go to DeepSeek's own API, not a middleman.

Step 2 — create the profile. Make a folder at ~/.hermes/profiles/deepseek/ with a config.yaml in it:

model:
  default: deepseek-v4-flash
  provider: deepseek
  base_url: https://api.deepseek.com
  api_mode: chat_completions

toolsets:
  - hermes-cli

agent:
  max_turns: 90
  gateway_timeout: 1800

Step 3 — drop your key in. Alongside it, an auth.json holding the key under a matching provider name. Then check it actually took:

hermes -p deepseek status

You want to see Model: deepseek-v4-flash and Provider: DeepSeek. If it shows a different model, you're not on the profile you think you're on — that trap has its own section below, because it bit me hard.

Step 4 — use it.

hermes -p deepseek -z "build me a thing" --yolo --accept-hooks

That's the whole setup. One flag switches your agent's brain.

Make sure you're on the new one.

This is the part I'd want someone to tell me, because it's easy to get wrong and impossible to notice.

The upgrade shipped as V4-Flash-0731 — a dated build. Same architecture as the previous preview. Same size. Same name in most places. Only the training changed.

Which means a route that just says "v4-flash" with no date might be serving you the older preview, and you'd never know from the output — you'd just quietly conclude the upgrade was overhyped.

Two safe ways to be certain:

1 — Use DeepSeek's own API. The launch shipped there first. Confirm the model appears in their official model list and you're done.

2 — Use the dated ID. On OpenRouter there's now an explicitly dated entry — deepseek/deepseek-v4-flash-0731. If the ID carries the date, you know what you're getting.

Rule of thumb for every launch, not just this one: when the name stays the same but the model changes, only a dated ID or the vendor's own endpoint proves what you're running.

Three builds. One prompt each. All worked first time.

Setup means nothing without proof, so I gave the pairing three jobs — not toy ones — and let Hermes drive.

Each was a single prompt. No follow-ups, no corrections, no fixing anything by hand. Hermes planned it, called DeepSeek, wrote the file to disk, then opened it in a browser and checked its own work before telling me it was done. That last part is worth sitting with: the agent verified its own output by taking screenshots a second apart and measuring how many pixels changed, to prove the animation was actually running.

All three rendered clean with zero console errors when I checked them independently.

Build 1 · three.js 3D

Neon Orrery

A living solar system — six planets on glowing orbits, a moon, drag to orbit, and +/- to speed up time.

Play it →

Build 2 · generative art

Signal Garden

Click anywhere and a luminous vine grows, branches and blooms. The prettiest thing on this page.

Play it →

Build 3 · simulation

Tide Machine

Layered ocean swell under a low sun. Move your cursor to change the wind and stir the tide.

Play it →

Three for three, first time, from the cheap tier. That's the thing worth taking away — not that any one of these is remarkable on its own, but that a model this inexpensive now lands them without a single retry.

Then I gave it a real job — and let the board run it.

Three demos are a nice party trick. Here's the part that actually matters for a business.

My Agent OS has a Kanban board that agents work: a Planner breaks a goal into cards, a Builder does each card, and finished work lands in the Done column. I pointed the whole board at DeepSeek and gave it one instruction — a cluster of articles about running Hermes on this model, for founders who want an agent that finishes long jobs.

The Planner filled the board. Five cards came back, each a real search-intent article: the 1M-context angle, the cost-per-job angle, the setup how-to, the long-jobs angle, and a Flash-versus-V4 comparison. I didn't write any of those. It found the angles itself.

Then it wrote one, start to finish. I moved the how-to card into build and the same model wrote the whole article — front matter, headings, keyword-first opening, the lot. It came back approved, saved straight into the site's posts folder, and it's live now.

The board after one instruction — four cards planned, one written and published, all by the same model. The Done card previews the live article.

That's the difference between a model you chat with and a model doing your work. One sentence in, a planned content cluster and a published article out — while I was doing something else.

The same agent scripted the video promo.

Last one, and it's my favourite, because it closes the loop.

I asked the same Hermes + DeepSeek pairing for a sixty-second promo script for a talking-head video. Spoken words only, third-grade language, a bold promise, one open loop, no jargon.

Then that script went straight into my AI avatar — my own face, my own cloned voice — and came back as a finished video.

Model writes the words. Avatar delivers them. Nobody sat in front of a camera.

Look at what that chain actually is. One model planned a content cluster, wrote a publishable article, and scripted the ad that promotes it — from a board, in an afternoon, on the cheap tier.

I was you. Then I made the brain a swappable part.

Before

Every model launch used to mean a day of rebuilding. New tool, new install, new setup, new habits — and by the time I'd finished, something else had launched. I was permanently behind, and permanently starting over.

Then I stopped rebuilding and started swapping.

After

DeepSeek's upgrade landed and I had it running as a Hermes profile before my coffee went cold. One folder, one config file, one flag. Everything I'd already built — my agents, my memory notes, my whole workflow — carried straight across. Then I pointed it at three jobs and went to do something else while it worked.

You can have this too. Build the system once, and every launch becomes a two-minute upgrade.

Real people. Real builds. Inside the Boardroom right now.

The members running this stack — agency owners, ecom founders, course creators — swapping in new engines the week they ship.

Most people pick a model. Operators keep a socket.

The old way: commit to one model, build your habits around it, and start again when something better lands. Every launch is a threat, because it means your setup is now the wrong setup. You end up defending your choice instead of upgrading it.

The new way: the agent is permanent, the brain is a socket. A launch is a folder and a config file. Everything you've already built inherits the upgrade instantly. You test the new one against the old one on real work, keep the winner, and move on. That's how a launch day turns from a distraction into a free upgrade.

What's actually stopping you isn't technical.

Do it properly — five steps.

The whole thing in 30 seconds.