The Judgment Release: What Changed and Why

When an Agent Claims vs. When It Proves

Every AI agent faces the same uncomfortable moment: it finishes a task and reports back. Before v0.18, Hermes — like every other agent runtime — reported completion by asserting it. The task is done. The tests pass. The file was written. You had no way to verify that directly inside the session; you had to go look for yourself.

Version 0.18.0, released July 1, 2026, is named The Judgment Release because it attacks that exact problem. Judgment, in this context, means the agent verifies its own work before it tells you it's done. Not by asserting success in prose, but by running the actual checks and recording the evidence. It is a shift from I believe the task is complete to here is the proof that it is.

This is not a narrow technical fix. It changes the way you should think about delegating work to Hermes and what you can trust at the end of an autonomous session. The rest of this lesson maps that philosophical shift onto the concrete features that ship with v0.18.

The Scale of This Release

v0.18.0 is not an incremental update. The release notes document approximately 1,720 commits, 998 merged PRs, and 949 issues closed since v0.17.0. In the week and a half before the release date, the team made a specific commitment: close every P0 (critical) and P1 (high-priority) issue in the entire repository. As of the release, they hit that target. Zero open P0s. Zero open P1s.

Why does that matter for you as a practitioner? Because it means v0.18 is simultaneously the biggest feature release in the project's recent history and the most stable version ever shipped. 381 people contributed. The quality bar was set explicitly before a single new feature shipped.

The Three Pillars of v0.18

The headline features of v0.18 cluster into three distinct capabilities. Each solves a different class of problem you have encountered if you've been running Hermes seriously.

Pillar 1: Verify, don't assert. Completion contracts and the updated /goal command replace the "it feels done" stopping condition with an evidence-based judge. You define what done looks like �� the specific command to run, the output to expect, the constraints that must hold — and the agent verifies against that contract before reporting success. Pre-verification hooks let your team inject arbitrary checks before the agent can declare a task complete.

Pillar 2: Ensemble reasoning. Mixture-of-Agents (MoA) is no longer a hidden mode or a toolset. It is a first-class model you select in any interface — CLI, TUI, dashboard, messaging gateway. You configure named presets that combine reference models (which analyze the problem) with an aggregator (which synthesizes and acts). Every reference model's reasoning is visible to you as a labeled block, streamed live. The aggregator's answer follows. Benchmarks show an MoA configuration that includes Claude Opus 4.8 as an aggregator beats Opus 4.8 alone by roughly six points on hard tasks.

Pillar 3: Self-teaching. The /learn command turns any source — a directory, a URL, a workflow you just walked the agent through, or pasted notes — into a reusable skill. The agent gathers the material using its standard tools (read_file, search_files, web_extract), authors a SKILL.md file that meets the Hermes contribution standards, and saves it to your skills directory. You do not write the skill by hand. You demonstrate or describe, and Hermes codifies it.

What This Track Assumes

This track picks up where Hermes Agent Advanced (T19) left off. You should be comfortable with the concepts in Fundamentals — installation, SOUL.md, memory, context references — and in Advanced — cron, skills, messaging gateway, MCP, multi-agent delegation, and event hooks. This track does not re-explain those foundations; it builds on them.

If you completed both prior tracks, you already know the 70% of Hermes that didn't change in v0.18. This track covers the 30% that did — and explains how the new pieces interact with everything you already built.

The Lesson Map

Here is how the thirteen lessons in this track are organized:

• Lessons 2–3 cover Mixture-of-Agents: the theory of how ensemble reasoning works, then the practical configuration of presets, cost tuning, and performance trade-offs.
• Lessons 4–5 cover the updated /goal system: the command itself in depth, then completion contracts and the verification stack.
• Lesson 6 covers /learn and the full self-teaching workflow.
• Lesson 7 goes deep on skills: progressive disclosure, bundles, and the Skills Hub.
• Lesson 8 covers the new async chat commands: /background, /queue, and /steer.
• Lesson 9 covers parallel delegation: running subagent fleets with v0.18 fan-out.
• Lesson 10 covers /journey and the self-improvement loop.
• Lesson 11 covers the v0.18 Desktop redesign: Projects, multi-terminal, PR diffs, and the memory graph.
• Lesson 12 covers cost architecture: provider routing, auxiliary models, fallback providers, and credential pools.
• Lesson 13 covers the production gateway: scale-to-zero, drain coordination, and platform-specific updates.

Each lesson is self-contained. If you already have a specific v0.18 feature in production and want to jump ahead, you can. The recommended order follows the dependency graph: MoA before /goal, /goal before contracts, /learn before the Skills Hub.