Launch-Your-Agent for Hermes: A Blueprint

Anthropic just published an open-source skill for Claude Code called launch-your-agent. It takes a technical founder from “I want to build an agent that does X” to a live, scheduled, self-grading Claude Managed Agent in one conversation. The interview is iterative, not a form. The output is a real deployed agent, not a plan for one. And the first run grades itself against your own definition of done, iterates if it falls short, and delivers when it passes.

I read through the repo, studied the skill design, and started mapping concepts to Hermes Agent. The result surprised me: Hermes already has most of the primitives that CMA provides. The profile system is an agent config. The cron system supports profile-targeted scheduling. The memory system is cross-run persistence. Goals with a judge are outcomes and grading. What’s missing is not infrastructure. It is the pipeline that connects them.

This piece is an analysis and a blueprint. If you use Hermes and want to build something like launch-your-agent for your own stack, here is the map, the gaps, and the plan.

What Launch-Your-Agent Actually Is#

The skill is deceptively simple on the surface. You run /launch-your-agent in Claude Code, answer a few questions, and walk away with a live agent. But the architecture underneath is worth understanding because the pattern generalizes.

There are two distinct loops at play.

The first is the build loop: an interview-driven conversation that maps a founder’s rough idea onto Claude Managed Agents primitives. The skill asks eight question clusters: what the agent should do, what done looks like, what it reads, what it produces, when it runs, what software it needs, what it should never do, and what past examples exist to test against. Each answer locks in a primitive decision. The output is a build sheet, a launch script, an evaluation scaffold, and an overview page.

The second is the operational loop: the deployed agent running on a schedule in Anthropic’s cloud. Each run, the agent works, self-evaluates against a rubric, iterates if the output doesn’t pass, and delivers when it meets the bar. Across runs, a memory store carries learnings forward so each execution is informed by the last.

Boris Cherney, who created Claude Code, described the shift this way in a recent interview: “I don’t prompt Claude anymore. I have loops that are running. My job is to write loops.”

That is the core insight. launch-your-agent doesn’t build a better prompt. It builds a better loop, and then hands that loop to the cloud so it runs without you.

The Hermes Primitive Map#

The first thing I did was map every CMA primitive to its Hermes equivalent. The table is remarkably full.

The one I was most unsure about was profile-targeted cron. Could a cron job run under a different Hermes profile than the default? I checked the source code before writing this. It already does. The cronjob tool accepts a profile parameter. The scheduler’s _job_profile_context()¹ temporarily switches the Hermes home, environment, and config to the target profile’s directory for the duration of the job. When the job finishes, everything snaps back. Profile-targeted cron was already built. I just didn’t know it.

That means every infrastructure primitive for a standing operational loop already exists. The gaps are all at the pipeline level.

What Launch-Your-Agent Has That Hermes Doesn’t#

There are three things the Anthropic skill provides that have no equivalent in Hermes today.

1. The Interview-to-Scaffold Pipeline#

This is the most valuable piece. The skill asks eight question clusters that map directly to CMA primitives. It doesn’t present a form; it starts an open question and iterates. The interviewer is the skill itself, running inside Claude Code, reacting to answers and following up.

There is no equivalent in Hermes. When someone wants to create a new agent profile, they either build it by hand or copy an existing one. There is no guided interview that maps “I want a daily news digest” to a profile with a cron job, a rubric, and an eval set.

2. The Self-Grading Loop Pattern#

CMA agents define success as an outcome: a rubric with 3-6 binary criteria, a max_iterations limit, and instructions to self-evaluate. The agent grades its own output against the rubric before delivering. If it fails, it iterates. This is built into the CMA platform.

In Hermes, a cron job can have a very detailed prompt that includes self-evaluation instructions, but there is no reusable pattern for this. Each standing loop agent effectively re-invents the self-grading mechanism from scratch in its prompt.

3. The Wrap-Up and Overview#

When the build is done, launch-your-agent produces an HTML overview page showing the agent’s identity, live IDs, run log, evaluation verdicts, and next directions. The companion /wrap-up skill regenerates this page, recaps every primitive the founder now owns, and suggests 1-2 tailored upgrades.

Hermes has nothing like this. There is no way to ask “what is the state of my standing loop agents?” and get a single-page view of their schedules, recent outcomes, and suggested improvements.

The Blueprint#

If someone wanted to build equivalent capability for Hermes, the work splits into three skills. No core infrastructure changes needed; everything builds on what already exists.

Phase 1: An interview-to-scaffold skill. This, coded as a slash command (/launch-agent or similar), would walk through adapted interview clusters mapped to Hermes primitives. Instead of “which model should your agent use?” the question is “what should this agent’s identity be?” Instead of “what tools does it need?” the question is “what skills should it have?” After the interview, the skill generates a profile directory: SOUL.md, profile.yaml, skills symlinks, a cron job targeting the new profile, and a set of evaluation cases if the user had past examples to test against.

Phase 2: A reusable self-grading loop reference. Not a standalone executable; it is a documented pattern for writing cron job prompts that include a rubric, self-evaluation instructions, and an iteration budget. Each cron tick: work, self-evaluate against the rubric, iterate if needed (up to a cap), deliver the result, and store what was learned in memory for next time. The pattern is a prompt template, not a code change.

Phase 3: A wrap-up and overview skill. Running /agent-status (or similar) would read the profile directory, fetch recent run history from memory, talk to the cron system for schedule and last-run status, and produce a status page. What profile is running, what schedule, what was the last run’s verdict, what did it learn, and what should you improve next.

Why This Matters#

The launch-your-agent repo is important not because Claude Managed Agents are the future of every agent deployment. They are a specific platform with specific tradeoffs: Anthropic runs the inference loop and sandbox, you pay API costs, and your agent lives in their cloud. That model is right for some people and wrong for others.

What matters is the methodology. The structured interview that maps vague intent to concrete configuration. The separation of the build loop (you are present, making decisions) from the operational loop (the agent runs without you, self-evaluates, self-improves). The self-documenting nature of the output: every artifact is a generated file that survives the conversation. The explicit v1/v2 plan in NEXT-DIRECTIONS.md, so you never close the door on an improvement.

Hermes already has the primitives to support this methodology. Profiles are agent identity. Cron is deployment. Memory is persistence. The goal system is evaluation. What Hermes needs is the pipeline that connects them so that going from “I want to build an agent that does X” to a running, self-grading, autonomous profile is as seamless as answering a few questions and saying “go.”

I am not building this right now. I have two other open-source projects (GroktoCrawl and SlopSearX) that need more of my attention. But the concept is mostly there. The map is drawn, and the gaps are small enough that someone with good Hermes skills knowledge could close them in a focused weekend.

The repo is open source. The Hermes Agent source is open source. The profile system, the cron infrastructure, and the skill system are all documented and working. If this sounds like a project you want to build, you have everything you need to start.