Stop Micromanaging Your AI Agent. Give It a Goal Instead.

You have been managing your AI agent like a nervous new hire on day one. Hover over every step. Approve every sentence. Re-explain the same task tomorrow. That job just changed.

You've been managing your AI agent like a new hire

It is 6:40pm on a Tuesday in Manchester. Aaron runs a five-chair barbershop off Deansgate. Two chairs are empty for Thursday morning. A regular cancelled Saturday's slot an hour ago. Aaron knows exactly what needs to happen: text the waitlist, offer Saturday's gap to someone who will actually take it, confirm times, update the book. He also knows he will not get to it tonight.

This is not a technology problem. Aaron has had a booking app for two years. The problem is that filling a calendar is not one task. It is fifteen small decisions in a row, and every AI tool he has tried wants him to make each decision for it. Draft this text. Check this reply. Try this instead. Approve that.

You are not managing an agent at that point. You are doing the job yourself, one keystroke slower.

On 20 July 2026, Nous Research shipped Hermes Agent v0.19.0, nicknamed the Quicksilver release, and buried in the changelog is a feature that quietly ends that pattern. It is called /goal, and it is the difference between giving an agent a to-do list and giving it a scoreboard.

What is an AI agent "goal", and why did this update make it real?

An AI agent goal is a standing objective you hand the agent once, instead of a task you re-explain every turn. You describe the outcome you want. The agent then works in a loop, checking its own progress against that outcome after every step, and only stops when the outcome is met or it runs out of turns.

Hermes Agent's version of this, the /goal draft command, has the agent write something Nous Research calls a completion contract before it lifts a finger. The contract has five parts: the outcome that must be true when it is done, the verification steps that prove it, the constraints on what must not break, the boundaries of what is and is not in scope, and a stop-when rule that tells the agent when to pause and ask a human instead of guessing.

After each turn, a second AI, a judge model, reads the contract and the agent's latest work and rules on one question: is this actually finished, or is there still meaningful work left? If there is more to do, the agent gets a fresh instruction and keeps going, on its own, up to a default budget of 20 turns before it pauses and waits for you.

The completion contract: what "done" actually means for Aaron's shop

Here is what that looks like away from a coding demo, in a business that has nothing to do with software.

Instead of telling an agent to text the waitlist about Thursday, Aaron gives it a goal: fill every open slot on this week's calendar. The agent, before doing anything, drafts a contract like this:

• Outcome: every currently empty slot this week is either booked or explicitly declined by three waitlisted clients.
• Verification: the booking calendar shows no empty slots, or a note explaining why a slot stayed open.
• Constraints: never double-book a chair, never discount below Aaron's published price list.
• Boundaries: this week's calendar only, do not touch next week.
• Stop-when: pause and ask Aaron before sending a message to more than five clients at once, or before offering any discount.

Notice what happened there. Aaron did not write a script. He wrote a definition of success, once, in plain English. The agent worked out the fifteen small decisions itself, texting one waitlisted client, checking the reply, moving to the next slot, and a judge model checked its progress against that exact contract after every step. When it hit the five-client boundary, it stopped and asked, instead of guessing.

That last part matters as much as the goal itself. The same Quicksilver release that shipped /goal also shipped what Nous Research calls smart approvals, plus native support for pulling credentials from Bitwarden and 1Password instead of storing passwords in plain text. Put together, those three features answer the three real objections a business owner has to handing work to an agent: will it know when to stop, will it ask before doing something costly, and does it need my passwords sitting in a text file somewhere. As of this release, the answers are yes, yes, and no.

Isn't this just a chatbot with extra steps?

No, and the difference is the judge model. A chatbot answers what you ask and waits for your next message. An agent set up with a completion contract keeps working, unprompted, across multiple turns, and a second model is checking its output against a written definition of done the whole time.

That second check is what makes it safe to walk away. Without it, a "just keep going" instruction is how you end up with an agent that declares victory three steps too early, or one that never stops because it has no idea what finished looks like. The completion contract gives it both a finish line and a referee.

Why this matters beyond one release

Hermes Agent is not the only agent moving this direction, and that is the real story. Days before the Quicksilver release, Jason Zhou, who builds SuperDesign and teaches at AI Builder Club, posted that you can now build, deploy, and evaluate long-running AI agents using Claude Code, Codex, or Antigravity, without writing a single line of code. Anthropic's own Claude Code has separately added the ability to run unattended for hours at a stretch. The pattern showing up across Hermes Agent, Claude Code, Codex, and Antigravity in the same month is not a coincidence. Agent tools are converging on the same idea: define the outcome, let the agent find the path, and use a verification step to catch it when it is wrong.

For a business owner, that convergence matters more than any single feature name. It means this is not a Hermes Agent trick you will need to relearn next quarter. It is the direction every serious agent tool is heading, which makes it worth learning once, properly, now.

How to build your first goal-based agent workflow

1. Pick one recurring outcome you keep re-explaining. Not scheduling help in general, one specific, repeated outcome: this week's calendar full, this month's overdue invoices at zero, every new lead quoted within an hour.
2. Write the completion contract in plain English before you touch the agent. One line each for outcome, verification, constraints, boundaries, and stop-when. If you cannot describe how you would check the work yourself, the agent cannot either.
3. Turn on an approval gate for anything that spends money or reaches a customer in bulk. Hermes Agent's smart approvals, or the equivalent human-in-the-loop setting in whichever agent you use, is the seatbelt. Keep it on for the first month.
4. Let it run, and review the transcript, not the play-by-play. The entire point is that you stop watching every step. Read the summary at the end.
5. Tighten the contract based on what it got wrong. If it stopped too early, your verification step was too loose. If it kept going past done, your outcome line was not specific enough. Fix the contract, not the agent.

What you have after this

A week in, you have one workflow, maybe the calendar, maybe overdue invoices, running on a goal instead of a leash. You are still checking the results. You are no longer writing the steps.

A month in, you have two or three of these running, and you have gotten good at writing completion contracts, because it turns out that skill, describing exactly what done looks like, is useful for managing people too.

Six months in, the tool underneath may have changed twice. Hermes Agent will have shipped another release. Claude Code and Codex will have caught up or pulled ahead. None of that matters, because you did not learn a product. You learned to define an outcome and let something else find the path to it.

Same shop. Same chairs. A completely different way of getting through a Tuesday.