Launch Your Agent: I Tested Anthropic's Free Skill

The agent had been running for nineteen minutes and I was watching my API spend climb like a taxi meter stuck in traffic. I had asked for something simple: a daily digest of five trending Reddit posts with a hook angle for each, the kind of thing I would normally bang out with a cron job and forty lines of Python. Instead I let Anthropic's free Launch Your Agent skill interview me and ship the whole thing to the cloud without my writing a line of code. At minute nineteen, the Console showed retry after retry, Reddit kept refusing the agent's requests, and the token counter had quietly crossed eight dollars.

That tension, between "I built a cloud agent in a five-minute conversation" and "this one run cost me twelve bucks," is the whole story. Most of what has been written about this skill reads like it was copied off the GitHub README without anyone running it. I ran it three times on three different tasks. Here is what it is, how I installed it, where it broke, 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

I did this on a clean setup, Claude Code v2.1.101 on macOS, specifically so I could write down every step. 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. I did not, the first time. You can guess where this is going.

The interview is the actual product

I expected a config wizard. What I got felt more like a sharp PM cornering me in a hallway until I admitted what I actually wanted. Phase 1 of four (Interview, Stage & Launch, Grade & Iterate, Run Without You) pushed 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.

Then it did something I did not expect. It scoped a v0, a deliberately minimal first version, instead of building my full dream 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.

What the first run actually cost

Phase 2 pushed my v0 to CMA and triggered the first graded run. This is where the gap between demo and reality opened. The agent's job needed Reddit data, and Reddit would not reliably give it any: rate limits, access blocks, the usual hostility public endpoints show anything that smells automated. The loop did exactly what loops do. It failed a step, evaluated, and tried again. And again. Every retry burned tokens.

The real numbers, not the flattering ones:

• ~28 minutes of wall-clock time, almost all spent on retries rather than productive work
• ~$12 in API cost for a single run, because each retry chewed through Opus-class reasoning (Opus 4.8 runs $5 input / $25 output per million tokens, and a thrashing loop generates a lot of output tokens)
• 5 usable stories in the final digest, with working links and commentary, because despite the thrash it did finish

So it worked, and it also cost more than some SaaS subscriptions charge per month, for one digest. Run that every morning unsupervised and you are near $360 a month for a Reddit summary. Nobody puts that math in the launch threads.

Here is what redeemed it. Phase 3 graded the run, identified the Reddit failures as the cost driver, and recommended dropping the flaky dependency in favor of web search, cutting both the error rate and the token burn. The agent diagnosed its own most expensive failure mode and proposed the fix. That is the loop earning its keep.

Where it bites

After three runs (the digest, a competitor-pricing watcher, a repo changelog summarizer), three patterns held.

Third-party reliability is your problem, not the skill's. The Reddit wall was not a bug. 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 the friendliest on-ramp to that world I have found, as long as you go in knowing it is a metered taxi, not a flat rate.

The sequence that saves you my $12

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 did not make automation easy. It made defining the goal easy, then ruthlessly exposed every place my definition was sloppy by charging me for the sloppiness in real tokens. That is not a flaw. It is the most honest feedback loop an AI tool has given me in a while. 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.