Jev in Hermes Agent: Cut Your Agent Costs With a Model That Decides

Create a Hermes skill called jev-decide in ~/.hermes/skills/jev-decide/, with a SKILL.md
and a small Python script (standard library only) that calls Jev 1.13.

The script: decide.py "<text to judge>" '<questions as JSON>'
- Read the key from ~/.hermes/.env. If TYPESAFE_API_KEY is set, call TypeSafe; otherwise
  use OPENROUTER_API_KEY and call OpenRouter. Send the key as a Bearer token.
    TypeSafe: POST https://api.typesafe.ai/v1/systemone
      {"model": "jev-latest", "state": "<text>", "questions": <questions>}
    OpenRouter: POST https://openrouter.ai/api/alpha/decisions
      {"model": "typesafe/jev-1.13", "state": "<text>", "questions": <questions>}
- Questions are a map: each key is a name you choose, and the answer comes back under it.
    choice: {"type": "choice", "instructions": "...", "criteria": {"option": "meaning"}}
    noul (yes or no): {"type": "noul", "instructions": "Is ...?"}
    score: {"type": "score", "instructions": "...", "criteria": ["lowest level", "...",
           "highest level"]} (an ordered list, 2 to 10 levels)
- Answers: choice gives "choice" and "confidence", noul gives "noul" (the chance of yes),
  score gives "score" (it can land between levels), "legend" and "confidence". The API
  sends these chances as 0 to 1: always print them as percentages, 0 to 100% (0.93 is
  93%). Print each answer with its confidence when there is one.
- Then print the cost. TypeSafe: usage.input_tokens x $0.042 per million (answers are
  free). OpenRouter: usage.cost. On an error, print the status and message.

SKILL.md tells every agent when to use it: sorting, routing, yes or no checks and
scoring, where a fixed answer from a list is enough. Never for writing or for open
questions.

Test it: ask whether "My card was charged twice this month" is about billing, technical
or other. Show me the answer, the confidence and the cost.

Switch my [AGENT NAME, e.g. Research] agent (profile [profile, e.g. research]) to Jev
Router on OpenRouter:
  hermes -p [profile] config set model.provider openrouter
  hermes -p [profile] config set model.default typesafe/jev-router
If that profile has no OPENROUTER_API_KEY in its own .env yet, set it there too with
hermes -p [profile] config set OPENROUTER_API_KEY, using the key you stored in prompt 1.
Do not show me the key.

Then start a new session for that agent and ask it "Who are you, and which model are you
running on?" Show me its reply.

Prove Jev works, and report in a short table.

1. Jev Router (skip this with a TypeSafe key): send one short question to
   typesafe/jev-router through OpenRouter's chat completions endpoint. Report the answer,
   which model OpenRouter says actually served it, how long it took and what it cost.
2. Jev 1.13: use the jev-decide skill on these three, one at a time:
   - "Lunch tomorrow at 1?" Is it urgent? (yes or no)
   - "Your invoice #2041 is paid" Is it a payment, a question, or spam?
   - "URGENT: verify your account now or it will be closed" Same question.
   Report each answer, its confidence, the time and the cost.

If anything fails, tell me the exact error and the one thing I need to fix.

Every [hour], check the emails that arrived since the last run. For each one, use
jev-decide with three questions in one request:
  choice: which group is it? [Customers, Sponsorships, Invoices, Newsletters]
  score: how urgent is it, from 1 (can wait) to 10 (today)?
  noul: is a real person waiting for a reply?
Hand each email to the agent for its group, and only that agent reads it:
  [Customers: my developer agent, Sponsorships: my marketing agent,
   Invoices: me, Newsletters: nobody]
When an email scores 8 or higher and someone is waiting, that agent writes me a draft reply.
Send me one short list: urgent emails first, each with the agent that has it. If
nothing is urgent, say so in one line. Save this as a scheduled job.

Go through my scheduled jobs. Change every one so that, before it sends me anything, it
asks jev-decide one yes or no question about its own result: "Is there something here
the owner needs to see or act on?" If Jev is less than 60% sure it is yes, the job sends
nothing and only notes the result in its log. Show me the list of jobs you changed.

Score each of these [leads / reviews / ideas] with jev-decide, on a scale of 1 to 10 for:
[what good means, e.g. "how likely this person is to buy in the next month"].
Then give me the list sorted from highest to lowest, with the score next to each line
and the total cost at the end.

[paste your list here, one per line]

From now on, when I give you a task and do not say who should do it, use jev-decide with
a choice question whose options are your teammates, each described by its job from its
SOUL.md. If Jev is 80% sure or more, hand the task to that agent and tell me in
one line who got it. Below 80%, ask me which agent I want. Save this rule to your
memory, then try it on: "[a real task, e.g. find three competitors of my product and
compare their prices]".

I have two models: a light one for easy work, [e.g. MiniMax M3, provider minimax], and a
strong one for hard work, [e.g. Claude Opus, provider anthropic]. Note the exact model
name and provider of each, and check that both answer.

From now on, whenever you hand a task to one of my agents, first ask jev-decide a choice
question about the task:
  light: short, routine or low stakes: summaries, formatting, sorting, simple replies,
         looking something up
  strong: hard thinking or high stakes: code, plans with several steps, anything about
          money, contracts or clients
Then run that agent on the matching model, for this task only:
  hermes -p <agent> chat -m <model> --provider <provider> -q "<task>"
If Jev is less than 80% sure, use the strong model. Do the same for my scheduled jobs.
Tell me in one line who got the task, on which model, and how sure Jev was.

Save this rule to your memory, then try it on two tasks: "[an easy one, e.g. summarise
this article: link]" and "[a hard one, e.g. plan the launch of my new product]".