Launch Your Agent: How Anthropic's Free Skill Works

This post describes Anthropic's free Launch Your Agent skill from its repository and documentation. Here is what it is, how to install it, where it can break, and when you should use a cron job instead.

What the Launch Your Agent skill actually is

Launch Your Agent is a free, open-source set of Claude Code skills that interviews you about a task and deploys it as a live, cloud-hosted Claude Managed Agent. It lives at github.com/anthropics/launch-your-agent under an Apache 2.0 license. That one sentence hides three separate things the marketing blurs together.

The skill itself is just a folder of Markdown and scripts. The repo ships two skills, launch-your-agent (the main four-phase flow) and wrap-up (a companion that recaps your agent and suggests upgrades). Anthropic labels it a reference implementation, explicitly not maintained and not accepting contributions. That caveat matters and I will come back to it.

Claude Managed Agents (CMA) is the paid infrastructure underneath: Anthropic's hosted runtime, in public beta since April 8, 2026. Anthropic runs your agent in an isolated container, handles state and tool execution, and bills standard API token rates plus $0.08 per session-hour of active runtime. I wrote a separate platform teardown of Anthropic's Managed Agents beta; this post is about the skill that sits on top of it.

The third thing is the loop idea, and it is the part worth slowing down for. A prompt hands Claude instructions and you own the output quality. A loop hands Claude a goal, context, and success criteria, and then Claude owns the quality: it plans, runs tools, grades its own output against your criteria, and retries until it clears the bar or exhausts the budget. Success criteria are the input everybody underweights. Without them, the loop either stops early or spins forever, and spinning costs money. The skill spends a real chunk of its interview dragging those criteria out of you, and that interrogation is honestly the most valuable thing it does.

Installing it takes three minutes

There is no npm install and no build step. Claude Code auto-discovers skills sitting in a .claude/skills/ directory, the same discovery pattern I covered in my advanced Agent Skills breakdown, so the entire install is launching Claude Code from inside the cloned folder:

git clone https://github.com/anthropics/launch-your-agent
cd launch-your-agent
claude

Then, inside the session:

/launch-your-agent

The step the breezy tutorials skip is the API key, and it is the step that costs you money. CMA runs on your own Anthropic account, so you need a key from the Console. The skill stores it in a local .env file rather than the chat transcript, which is the right call for a credential. Before you generate that key, set a hard spending limit on it.

The interview is the actual product

Phase 1 of four (Interview, Stage & Launch, Grade & Iterate, Run Without You) pushes on the specific shape of the output, the audience, the data sources, the schedule, and, hardest of all, the grading rubric: what does a good digest look like versus a mediocre one, in terms the agent can score against.

It scopes a v0, a deliberately minimal first version, instead of building the full agent on the first pass. That is engineering discipline baked into a skill, and it is the biggest reason a non-coder can use this without producing a tangled mess.

The interview ends with a generated my-agent/ folder: a human-readable build sheet, the exact JSON payloads the skill sends to the CMA API, a resumable launch script, an eval scaffold that scores each run, and a NEXT-DIRECTIONS.md with a v1/v2 roadmap. That folder is the difference between "an AI did something opaque in the cloud" and "here is the inspectable, version-controllable definition of my agent." You can read the payloads, commit them to git, and walk away from the skill entirely while keeping the agent. For something pitched at beginners, that is unusually honest design.

Where it bites

Three risks stand out.

Third-party reliability is your problem, not the skill's. The open web fights automated access, and a retrying loop happily converts that friction into a token bonfire. Before pointing an agent at a source, ask whether the source will let a bot in. If the answer is shaky, the loop will find out the expensive way.

The cost model rewards precision and punishes vagueness. A tight goal with crisp criteria converges in a few cheap iterations. A loose goal spins, because the agent keeps trying to satisfy a target you never clearly drew. Your spend is directly proportional to how sloppy your interview answers were. My AI agent cost-optimization guide covers the token-discipline tactics that matter most here.

"Reference implementation, not maintained" is real. When the CMA API shifts, and a public-beta API will shift, this skill will not get a patch. You are adopting a snapshot. Fine for learning and prototyping; think harder before building a business-critical workflow on an explicitly unmaintained scaffold.

When the skill wins and when a cron job wins

Reach for the skill when the task is genuinely judgment-heavy (summarizing, triaging, prioritizing, writing), when it recurs and CMA's scheduled deployments can fire it without you, and when the data sources are automation-friendly: your own APIs, plain web search, services with proper credentials.

Write the cron job when the task is deterministic. If a forty-line script produces the exact right answer every time, an LLM loop is a strictly more expensive way to get a worse-defined result. Do not pay Opus rates to run if/else. Skip the skill too when the source is hostile to bots or when you need predictable cost; a script costs pennies, a reasoning loop costs whatever it takes to satisfy your criteria.

The bigger shift underneath this is the unit of automation moving from scripts you maintain to goals you delegate, which I explored in running Claude Code loops on a cron schedule. This skill is a friendly on-ramp to that world, as long as you go in knowing it is a metered taxi, not a flat rate.

A safer sequence for your first agent

1. Run the interview on a real task, but pick a friendly data source for your first agent: your own files, your own API, or web search. Not Reddit.
2. Set a spending limit on a fresh API key first. A $5 cap turns "I lost track of cost" into "the run stopped itself."
3. Run once, on-demand. Read the graded output and the my-agent/ folder. Treat the first run as a paid lesson, not production.
4. Only then schedule it. Automate a known quantity, not a question mark.
5. Run /wrap-up and decide whether v1 is worth the spend.

The lesson under all of it: the skill does not make automation easy. It makes defining the goal easy, then a retrying loop exposes every sloppy definition by charging for it in real tokens. That is not a flaw; it is an honest feedback loop. If you can write down the exact success criteria for a task you do every day, you can hand that task to a loop. If you cannot, you have found the part of your work that was never going to be automated anyway.