01What Hermes Loop Engineering Is and How It Works

Hermes loop engineering is a system inside the Hermes agent operating system that automates quality control for AI-generated work. You set a clear definition of what 'done' means, a builder model creates a draft, and a separate judge model grades it. If the output fails, the system loops—sending feedback back to the builder—until it passes.

This removes you from the middle of every AI cycle. Instead of reading, critiquing, and resubmitting drafts yourself, the system does it automatically. Julian Goldie explains that you can use free or cheap models to run the loop, so you get better outputs without spending on frontier models.

02Key Features of the Loop Engineering System

The loop system has several powerful features that make it easy to use and effective. Here are the main ones:

  • Define done – You write what a great result looks like, and the judge checks against that standard.
  • Separate builder and judge – The model that writes never grades, so there's no self-rubber-stamping.
  • Adversarial judge – The judge is told to find holes and critique harshly.
  • Max rounds – You can set a limit on how many times the loop runs, like 4 loops, to control time and tokens.
  • Model selection – You pick the builder and judge models, from free options like N2 to frontier models like Opus 4.8.
  • Full record – Every round's score, issues, and fixes are saved to your vault for review.

These features work together to automate the entire quality control process, so you can walk away and come back to a finished, graded result.

03How to Set Up Your First Loop

Setting up a Hermes loop is simple and only takes about five minutes of your time. Follow these steps:

  1. Open the Hermes agent operating system and go to the loop section.
  2. Write your definition of done – be specific, like 'a five-line cold email for agency owners that has one CTA and reads like a human wrote it.'
  3. Optionally, provide a starting point if you have one.
  4. Choose a builder model – for example, N2 (free via OpenRouter) or a frontier model.
  5. Choose a judge model – this should be separate from the builder; free models work fine.
  6. Set the max rounds – for instance, 4 loops to keep it quick.
  7. Hit run and walk away.

That's it. The system will loop until it passes or hits your max rounds. You don't need to be technical—it's just a text box and a button.

04Using the Loop in Real Examples

In the episode, Julian shows a real loop in action. He sets the definition of done, chooses N2 as the builder, and picks a free model as the judge. The system runs round one, and the judge scores it out of 100.

For example, a draft might get a score of 54. The judge lists what's wrong, and those notes go back to the builder. The builder fixes the issues, and the loop runs again—next score 71, then 83, and finally 92.

Once the judge passes it, you get the final result plus a full record of every round.

This example shows how the system iterates automatically. You don't have to sit there reading and giving feedback. You just define the bar, start the loop, and let the machine do the work.

05Results and Comparisons from the Episode

Julian compares the old way to the new way. The old way: you ask AI for something, read it, spot problems, type feedback, paste it back, and repeat five times. You lose focus and settle for mediocre because you're tired.

The new way: you spend five minutes writing what done means, hit run, close the tab, and the system loops until it passes. You come back to a greater finished result.

He also notes that the goal feature in Hermes was a bit buggy for him, but the loop engine works better. Additionally, he shows that the system passed a round with GLM 512, giving a graded score and feedback. This proves the system works with free models and delivers quality outputs.

06Tips, Limits, and Mistakes to Avoid

To get the most out of Hermes loop engineering, keep these tips in mind:

  • Be specific about done – The more honest you are in your definition, the better the judge can grade.
  • Use free models – You can run the loop with free APIs from OpenRouter or free models on Nous Portal, so don't worry about tokens.
  • Don't be the loop – Set it up and walk away; don't babysit each round.
  • Separate builder and judge – Never use the same model for both, or it will rubber-stamp its own work.
  • Set max rounds – Without a limit, the loop could go forever; set a number like 4 to control time.
  • Don't delay setup – If you say 'I'll do it later,' you'll keep wasting time and energy in the meantime.

Avoid the mistake of thinking better prompts fix everything—better prompts still put you in the chair every round. And don't assume AI grading AI is a gimmick; the adversarial judge makes it work.

07Who Should Use Loop Engineering and Why

Hermes loop engineering is for anyone who uses AI agents and wants better outputs without babysitting. Use cases include cold emails, ad copy, landing pages, coding, SOPs, websites, apps, tools, games, videos—anything that requires quality control.

It's especially beneficial for non-technical users because it's a simple text box interface, not a terminal command. Julian emphasizes that you define the bar, and the system earns the pass. You stop reading drafts, stop settling for mediocre, and stop trusting outputs without checking.

By automating quality control, you get your time back and improve the quality of everything you produce. The system saves every loop to your vault, so you can review and reuse work anytime. This changes how you work with AI forever.