Hermes: one harness to rule them all
Since I started using Hermes from Nous Research, my way of thinking about and conceiving AI usage has changed radically. Before, with Claude Code, I reasoned in separate compartments and context. With Hermes I’ve started reasoning in a much more abstract, holistic way. I’ve started structuring work into well-defined, automated, and optimized pipelines, which weren’t feasible with Anthropic models alone, because of the cost.
My workflows often involve multiple models from different providers, and they’re structured roughly as follows:
- an orchestrator, often the conversational interface of my Hermes
- specialized profiles for different specializations, each with their own context and set of skills
- different harnesses, like Pi for code writing
- separated Hermes sessions orchestrated via SSH, executing specific tasks on other machines, like the iOS development workflow on a Mac mini
Every workflow requires manual selection of a specific model suited to the workload, but this often changes and leads to frequent config file edits and added bottlenecks.
But this may be solved with Jev: it reads the brief and returns a tier (small, medium, or large) and a confidence score. It does not name a coder. When the score is too low, my code launches a cheaper one instead of making me edit a config file.
Jev classifies each workload and gives a confidence score based on these categories:
- small One file, one function, a string, a test. No new module, no new boundary, no design judgment.
- medium Several files, within an existing layer. Tests and implementation of a new feature, or a new feature model.
- large A new boundary, a change that crosses layers, a design choice the coder would otherwise invent.
From there the decision is fixed, and each workload has each model assigned:
Let’s test it
I wrote three generic example briefs, which replicate real world task scenarios. Same words as the criteria, and ran each three times. Same question every time: enough to have a clear test case:
- small A settings label is a hardcoded English literal — move it to the localization catalog (en + it), use the localized lookup, update the one test that asserts the old string.
- medium Inside an existing TCA feature module, add a new screen: its own Reducer, the SwiftUI view, pushed from the parent's navigation, TestStore unit tests. Module, navigation, and dependencies already exist.
- large A new TCA feature module from scratch: several screens behind a root Reducer and a navigation stack, a new Client dependency — plus open design decisions the brief doesn't settle. Propose the boundaries and the data flow, then implement.
The router asks Jev one choice question over the brief and it returns the chosen option, the full probability distribution, and a confidence score.
QUESTIONS = {
"size": {
"type": "choice",
"instructions": (
"What is the smallest coding tier that can finish this task? "
"Judge the change in the brief, not how large the surrounding app is."
),
"criteria": {
"small": (
"One file or one function. The brief names the exact edit. "
"No new module, no new boundary, no design judgment."
),
"medium": (
"Several files inside an existing layer. New tests and "
"implementation, but the architecture is already decided."
),
"large": (
"A new boundary, a cross-layer change, or a brief that does "
"not pin the files."
),
},
}
}
The answer comes back as typed JSON:
{
"model": "typesafe/jev-1.13-20260917",
"answers": {
"size": {
"type": "choice",
"choice": "medium",
"probabilities": { "small": 0.0, "medium": 0.98, "large": 0.02 },
"confidence": 0.97
}
},
"usage": { "input_tokens": 532 }
}
Confidence is not the probability of the chosen tier. TypeSafe derives it from how peaked the distribution is: a peak of 0.98 comes back as 0.97, a peak around 0.77 comes back between 0.60 and 0.67.
The decision itself belongs to code: fixed thresholds map the answer to a model:
# the closed table: tier -> (provider, model, launcher)
TIERS = {
"small": ("openrouter", "z-ai/glm-5.3-flash", "ori-pi"),
"medium": ("openrouter", "deepseek-v4.1-flash", "ori-pi"),
"large": ("xai-oauth", "grok-4.7", "hermes"),
}
DEFAULT_TIER = "small"
FLOOR = 0.5 # trust threshold for any answer
LARGE_FLOOR = 0.7 # a large must be more confident to launch
def decide(choice, confidence):
if choice not in TIERS or not isinstance(confidence, (int, float)):
return launch(TIERS[DEFAULT_TIER], fallback=True, reason="invalid_answer")
if confidence < FLOOR:
return launch(TIERS[DEFAULT_TIER], fallback=True, reason="low_confidence")
tier = choice
reason = "as_classified"
fallback = False
if tier == "large" and confidence < LARGE_FLOOR:
tier = "medium"
reason = "large_downgraded"
fallback = True
return launch(TIERS[tier], fallback=fallback, reason=reason)
On all nine, Jev named the tier I had aimed at: small, medium, large, no fallbacks.
| Brief | Jev answer | Confidence | Tokens | Latency | Cost |
|---|---|---|---|---|---|
| small | small 3/3 (p ≈ 0.77) | 0.60–0.67 | 526 | 624–926 ms | $0.000022 |
| medium | medium 3/3 (p ≈ 0.98) | 0.97 | 532 | 628–670 ms | $0.000022 |
| large | large 3/3 (p = 1.00) | 1.00 | 539 | 637–714 ms | $0.000023 |
One call costs about $0.000022, two hundred-thousandths of a dollar, and comes back in under a second. Super fast! And cheap, extremely cheap! (especially if you’re used to Anthropic models :p) Even if Jev misrouted every brief to the most expensive tier, the routing itself would never show up on the bill. The coder it picks is the expensive part, and that’s the call it saves me from making by hand.
Conclusions
Jev is the piece I was missing in these pipelines: a fast model that doesn’t write the code. It evaluates. Who writes stays in the table above.
On its own that doesn’t do much. It earns the step where something has to be picked, quickly, and then handed to another model.
Speed is the part I feel day to day. The expensive model still does the slow, serious work. Everything in front of it just gets out of the way.
Till Next Time ;)