Skip to content

Back to the catalog

kerpopule/hermes-jev-skills
github.comrepo

kerpopule/hermes-jev-skills

hermes-jev-skills wires TypeSafe's small, fast decision model "Jev" into agent workflows (Hermes, Claude Code, Codex) to handle cheap sub-decisions — which model should answer a turn, which of many skills to load, which retrieved passages matter, which conversation turns survive a summary — instead of burning frontier-model tokens on them. It ships ten agent-agnostic SKILL.md files, a CLI (jev routing/mail/screen/search), a local dashboard, and a plugin built on public Hermes seams (pre_llm_call, transform_tool_result, llm_request middleware) with detailed data-redaction guarantees for what gets sent to the Jev API. It also includes a shadow mode for safely evaluating routing decisions before enabling them.

TL;DR A skills repo + lightweight decision-model router (Jev) that offloads routing, skill-selection, and compaction choices from expensive LLM agents to a cheap, fast classifier.
Document

What it claims

hermes-jev-skills wires TypeSafe's Jev decision model into an AI coding agent's runtime. The pitch: your agent wastes frontier-model tokens on non-prose decisions — which model answers this turn, which of hundreds of skills to load, which retrieved passages matter, which transcript turns survive summarization. Jev is a cloud API that "never writes text"; you hand it a state plus typed questions (pick one, score, yes/no) and it returns an answer with calibrated confidence in ~0.4s at a fraction of a cent. Ten skills ship as plain SKILL.md files (agent-agnostic — Claude Code, Codex, or Hermes), but the deeper plugin is Hermes-specific.

How it works

The Hermes plugin exposes five tools — jev_memory_filter, jev_compact_select, jev_choose_action, jev_supervise, jev_escalate — and uses only public plugin seams (pre_llm_call, llm_request middleware, tools, a slash command), so it patches nothing in Hermes core. It can swap the model but not the provider connection; on OpenRouter that still covers every vendor, and a manual /model overrides it. Routing pools live in ~/.hermes/jev/routing.json, drawn from models.dev filtered to providers whose API-key name is in your environment. jev models suggest --write drafts pools from price bands.

Safety rails do not depend on Jev being correct: risk words (production, delete, migration, security, payment, legal) never route to the cheapest tier; a large context never downshifts mid-session; a transcript turn drops only on a confident answer; Jev can only return an action id you placed in the table. On any failure (no key, timeout, low confidence, malformed reply) it degrades safely — routing keeps the current model, memory returns the original list, compaction drops nothing. A Jev outage costs at most the 2.5s time budget and never blocks a turn.

The data boundary

Because Jev is a cloud API, the README is explicit about what leaves the machine — the reason to read the actual page:

flowchart TD
  Turn[Agent turn/state] --> Check{Looks sensitive,<br/>or private_profile?}
  Check -- yes --> Coarse[Coarse features only:<br/>length, code present, risk words]
  Check -- no --> Redact[Redacted text sent:<br/>emails/phones/tokens/hex masked]
  Coarse --> Jev[(Jev cloud API)]
  Redact --> Jev
  Jev --> Log[Logs: decision only —<br/>tier, model, confidence, latency.<br/>Never prompt text]

Routing sends the redacted turn capped at 2,500 chars (ask_chars) — never history, tool results, files, or memory. Mailbox sorting decodes quoted-printable/base64/HTML entities before screening (so a base64 MIME body can't smuggle a key past the redactor) and strips URL query strings. Store ids/paths are replaced with P0, P1…. Note the honest caveat: on an automatically routed turn, the agent has no say over the redacted turn being sent — the fix is to list such profiles in private_profiles.

How to use it

Python 3.9+, standard library only, no dependencies.

git clone https://github.com/kerpopule/hermes-jev-skills ~/hermes-jev-skills && python3 ~/hermes-jev-skills/install.py

The installer detects Hermes, Claude Code, and Codex and installs for each found. Preview with python3 install.py --check; reverse with --uninstall. Store your TypeSafe key via jev setup-key, which opens a one-time localhost page (unguessable URL, rejects foreign Host headers, logs nothing, dies after one use or ten minutes) and writes to the OS secret store; the agent only ever sees "stored, verified: yes/no". Then jev doctor.

Start in shadow mode — decides and logs without switching anything:

/jev routing shadow          decide and log, do not switch (start here)
/jev routing on              switch models per turn
/jev skills on               suggest the right skill per turn

Offline tests fake every Jev reply, safe to run anywhere:

python3 -m unittest discover -s tests

Limits

  • The full plugin (routing, five tools, dashboard) is built for Hermes; only the ten SKILL.md files are portable to Claude Code/Codex.
  • Jev is a proprietary cloud API from TypeSafe AI (this repo is independent) — routing sends redacted turn text off-machine by default, and auto-routed turns bypass agent-level "don't send customer data" instructions unless the profile is in private_profiles.
  • MIT (LICENSE); ported work from fazlerocks/jevmail, savka777/jev-use, and rohanarun/computer-use-cache is credited in NOTICE. The optional browser runner wraps browser-use/jev-ultrafast but does not bundle it.

Organisations named here

  • TypeSafe AI
  • Claude Code
  • Hermes
  • Jev
  • OpenRouter
  • TypeSafe

Technologies named here

  • jevkit
  • Jev
  • Kimi K3
  • skills
  • hermes-jev plugin
  • router-dashboard
  • install.py
  • HERMES
  • Claude Code
  • Codex
  • OpenRouter
  • models.dev
  • Model Context Protocol
  • Ollama
  • LiteLLM
  • Python

Techniques named here

  • Jev routing
  • Shadow mode
  • Redaction
  • Web result screening
  • Mailbox lane sorting
  • Compact-select
  • private_profiles data restriction