Hermes Agent Is Not Just Smarter Now — It Proves It’s Done

The most common failure mode for AI agents is not that they can’t do the work — it’s that you can’t be sure the work is actually done. They confidently declare completion while missing a file. They run a script but never inspect the output. They move on to the next step as if the previous one never failed.

Hermes Agent v0.18.0 — codenamed “The Judgment Release” — is built around one idea: make the agent prove it’s done.

Check out the full v0.18.0 release notes for a complete list of changes.

From “Feels Done” to “Evidence Says Done”

Traditionally, a model stops when it decides it has answered enough. That decision is subjective. Feeling finished is not the same as meeting expectations.

Hermes v0.18.0 introduces two complementary mechanisms that turn completion from a hunch into a verifiable object:

  • Standing Goals: a persistent target condition the agent keeps checking against.
  • Completion Contracts: a checkable agreement that defines what “done” looks like, including evidence and validation steps.

In short: instead of you asking it to do something and trusting it when it says it’s finished, you tell it what finished means, and it brings back evidence.

Why Self-Verification Matters

Hermes could already call tools, write code, run tests, and manage files. But all of that still left one gap: it would not actively verify its own work.

v0.18.0 changes this. After acting, the agent attempts to verify that the result satisfies the conditions you set. This sounds minor, but it moves Hermes from being an executor to being an accountable executor:

  • It checks whether a file exists and matches expectations after editing it.
  • It inspects exit codes, logs, and side effects after running commands.
  • It runs through completion criteria before telling you the task is finished.

This is not a perfect guarantee, but it sharply reduces the chance of “looks done, actually isn’t.”

Standing Goals: Completion Conditions as a Long-Term Contract

Standing Goals let you declare a long-term objective and have the agent continuously measure progress against it. Typical uses include:

  • “Convert every hardcoded path in src/utils.py to an environment variable.”
  • “Resolve all TODO comments in the repo.”
  • “Make sure every API call has retry logic.”

These tasks rarely take a single action. They require checking, editing, and rechecking. Standing Goals force the agent to ask after each step: “Did I get closer to the goal? Is the goal satisfied now?”

You define the target; the agent plans, acts, verifies, and iterates until the goal is reached or it hits a blocker that needs human input.

Completion Contracts: Making “Done” Checkable

If Standing Goals answer “what is the target,” Completion Contracts answer “how do we know it’s finished.”

A Completion Contract can include:

  1. Completion criteria: conditions that must be met, such as file existence, passing tests, correct output format, or successful builds.
  2. Verification method: the tool or command used to validate, such as pytest, curl, grep, or diff.
  3. Failure handling: what to do if verification fails — retry, roll back, or pause and report to the user.

This structure makes the agent’s behavior transparent. You can see exactly what standard it used to judge completion, and you can audit that judgment later.

Example: Let the Agent Verify Its Own Fix

Suppose you ask Hermes to fix a null-handling bug in utils/parser.py and require it to pass tests before reporting completion. A Completion Contract might look like this:

Objective: Fix the null-value parsing exception in utils/parser.py
Completion criteria:
  1. The failing case no longer raises TypeError
  2. pytest tests/test_parser.py passes completely
  3. A regression test covering the exception is added
Verification method:
  - Run pytest tests/test_parser.py
  - Check Git diff includes changes to parser.py and test_parser.py
Failure handling:
  - If tests fail, analyze the log, modify the code, and retry up to 3 times
  - If still failing, pause and report to the user

Hermes will execute the contract: modify the code, run the tests, inspect the diff, and only report completion once all three criteria are satisfied. This is far more reliable than “code changed, task done.”

Combined with Mixture-of-Agents: More Careful Verification

v0.18.0 also strengthens Mixture-of-Agents (MoA): multiple models act as a panel, each reasoning independently, with an aggregator producing the final answer.

For self-verification, MoA adds value by:

  • Having multiple models independently inspect the same evidence.
  • Showing you each reference model’s reasoning.
  • Making the final answer a cross-validated conclusion rather than the most confident guess.

It’s like adding peer review to the agent’s completion judgment.

What Users Will Notice

For everyday users, v0.18.0 brings three concrete improvements:

  1. Fewer false completions: the agent checks itself instead of rushing to finish.
  2. More transparent decisions: you can see the criteria and evidence it used.
  3. More stable long-running tasks: standing goals and completion contracts keep automation on track.

These changes don’t show up as a single flashy feature. They show up in how the agent behaves.

Limitations and Recommendations

Self-verification is not magic. It is limited by:

  • How complete your completion criteria are.
  • Whether your verification tools cover real-world usage.
  • How accurately the model interprets verification results.

So when using it:

  • Write completion criteria that are specific and checkable.
  • Prefer verification methods with clear outputs and exit codes.
  • Keep a human review step for critical tasks instead of fully delegating judgment to the agent.

Key Takeaways

  • Hermes Agent v0.18.0 “The Judgment Release” centers on self-verification and provable completion.
  • Standing Goals keep the agent checking progress against a long-term target.
  • Completion Contracts break “done” into checkable criteria, verification methods, and failure handling.
  • The agent no longer stops on a feeling; it judges completion against evidence.
  • With Mixture-of-Agents cross-validation, completion judgments become more careful and transparent.
  • Users should write specific, checkable criteria and retain human review for critical work.

References: