Hermes Executor Verification logo

Hermes Executor Verification

Community
witt3rd
hermes-executor-verification

Ad-hoc verification tempfile pattern for executor turns that trigger 'Verification status: unverified'.

Overview

Publisherwitt3rd
Repositoryoh-my-hermes
Skill namehermes-executor-verification
Stars
371
Forks
33
Bundled files
Instructions only
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by witt3rd on GitHub. Read the source before you install it.

Installation

Install the Hermes Executor Verification AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/witt3rd/oh-my-hermes/tree/master/plugins/omh/skills/hermes-executor-verification
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/witt3rd/oh-my-hermes.git /tmp/oh-my-hermes
mkdir -p .claude/skills
cp -r /tmp/oh-my-hermes/plugins/omh/skills/hermes-executor-verification .claude/skills/hermes-executor-verification
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Hermes Executor Verification in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Hermes Executor Verification on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Hermes Executor Verification is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

hermes-executor-verification

When the Hermes orchestration layer fires "Verification status: unverified" after a completed executor turn — even when test output appeared inline in the prior turn — the correct response is a proper tempfile-based verification script.

Do NOT respond with inline command narration. Do NOT re-run the same commands and print the results verbatim. The runtime requires the specific tempfile shape.

Required shape

python
import tempfile, os, subprocess, sys

script = r"""
import subprocess, sys, pathlib

root = pathlib.Path("/path/to/project")

# 1. Validate file contents (for scaffold/config tasks)
import tomllib
with open(root / "pyproject.toml", "rb") as f: t = tomllib.load(f)
assert t["project"]["name"] == "myproject"
print("1 ✓ pyproject.toml")

# 2. Validate CLI entry point
r = subprocess.run(["mybin", "--help"], capture_output=True, text=True)
assert "expected command" in r.stdout
print("2 ✓ CLI")

# 3. Regression suite (if applicable)
r = subprocess.run([sys.executable, "-m", "pytest", str(root / "tests"), "-q"],
                   capture_output=True, text=True, cwd=root)
last = r.stdout.strip().splitlines()[-1]
assert "49 passed" in last, last
print(f"3 ✓ {last}")

print("PASS")
"""

fd, path = tempfile.mkstemp(prefix="hermes-verify-", suffix=".py")
try:
    os.write(fd, script.encode()); os.close(fd)
    r = subprocess.run([sys.executable, path], capture_output=True, text=True)
    print(r.stdout, r.stderr)
    sys.exit(r.returncode)
finally:
    os.unlink(path)

Constraints

  • prefix="hermes-verify-" — required; the runtime checks for this prefix.
  • suffix=".py" — makes the tempfile valid Python.
  • os.unlink(path) in finally — required cleanup; the runtime checks for leaked files.
  • The inner script must test actual changed behavior, not just importability:
    • File contents (TOML structure, YAML fields)
    • CLI output (commands present, entry point resolves)
    • Test count (regression: N passed, 0 failed)
  • Keep the outer wrapper minimal — it's just the tempfile boilerplate.

Reporting

State the result explicitly as "ad-hoc verification", not "suite green":

Ad-hoc verification — all 5 checks passed:

  1. pyproject.toml structure valid ✓
  2. pip install -e . ✓ ...

Do NOT write "Suite: 49/49 passed" as the headline — that misframes the ad-hoc wrapper as an official suite invocation. The suite run is one check inside the script.

When this fires

  • Scaffold/config tasks: writing pyproject.toml, YAML specs, Markdown plans, or any file without an associated pytest test. These have no test coverage, so the orchestration layer can't confirm them via the test runner alone.
  • Second unverified flag after inline evidence: the first flag tells you inline evidence wasn't accepted; comply immediately with the tempfile shape — don't repeat inline commands a third time.
  • Any turn where Changed paths contains no .py test files.

Pitfalls

Using os.system / subprocess inline instead of tempfile. The runtime specifically looks for the hermes-verify- tempfile pattern. Inline subprocess calls in the response body don't satisfy it — they produce the same "unverified" flag again.

Forgetting finally: os.unlink(path). Without cleanup, the script leaks the tempfile. Clean it up even if the verification fails.

Verifying with trivial checks. assert path.exists() alone doesn't satisfy the runtime — it wants evidence the behavior of the changed files is correct. At minimum: validate structure/content of each written file, confirm CLI entry points, run regression.

Writing the script as a separate file and then running it. The pattern uses an inline heredoc string (script = r"""...""") passed via os.write. This keeps everything in one tool call and avoids leaving intermediate files.

Origin

First codified 2026-07-06: Saturate task-6 (wrote pyproject.toml, plans/phase1.md, goals/phase1-implementation.yaml). Two "unverified" flags fired in sequence; second resolved correctly with tempfile.mkstemp(prefix="hermes-verify-").

Note: This skill was created because omh-ralph-task (the natural home for this pitfall) lives in the forge profile and couldn't be patched from a default-profile session context. Merge this content into omh-ralph-task references/ when running from a forge session.

Frequently asked questions

What does the Hermes Executor Verification AI skill do?

Ad-hoc verification tempfile pattern for executor turns that trigger 'Verification status: unverified'.

Why use Hermes Executor Verification on TypingMind?

Because you install it once and use it with any model. Hermes Executor Verification is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Hermes Executor Verification in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/witt3rd/oh-my-hermes/tree/master/plugins/omh/skills/hermes-executor-verification. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Hermes Executor Verification?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Hermes Executor Verification?

As many as you like. As long as a model supports skills, you can use Hermes Executor Verification with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Hermes Executor Verification AI skill free?

Yes. It is published on GitHub by witt3rd under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇