Idea to Live Agent: Anthropic's launch-your-agent Skill Pack

Ever spent an afternoon wiring up a Claude Managed Agent from scratch? Writing the API payload by hand, setting up the environment, crafting eval prompts, stitching a cron schedule — all before you even know if the thing works?

Yeah, me too. And honestly? It’s a pain.

So when Anthropic dropped launch-your-agent — an official CLA skill pack that automates the entire CMA build pipeline — I had to try it the same day. 342 stars in its first week. That’s not hype, that’s signal.

TL;DR

launch-your-agent is an official skill pack for Claude Code. So you clone the repo, run /launch-your-agent inside the CLA terminal, and it walks you through a 4-phase pipeline: interview → deploy v0 → grade & iterate → schedule. And all inside your CLA session. No manual API drafting.

But the short version: if you’re a technical founder who wants a live CMA in under 30 minutes, this is the fastest path I’ve found. Period.

What Is launch-your-agent?

So it’s a pair of CLA skills — launch-your-agent and /wrap-up — living in anthropics/launch-your-agent on GitHub. Apache 2.0 license, reference implementation, 342 stars as of today.

But Anthropic is clear about what this is: a reference implementation. No contributions accepted, no active maintenance promised. Still, it works right now. And I tested it.

So the repo layout tells you everything about how it’s built:

And the key constraint: you need Claude Code installed and signed in, plus an Anthropic API key from your own account. The key goes into a local .env file — never into the chat. So runs cost cents, not dollars.

My Setup

And I grabbed it on a Thursday afternoon. Ryzen 9 workstation, CLA already set up with an API key in my account.

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

And that took about 30 seconds. Then inside the CLA terminal:

/launch-your-agent

And it started.

The Four Phases — From the Inside

Phase 1: The Interview

So you don’t write any code first. The skill interviews you. I sat through about 8 questions over maybe 5 minutes:

• What does your agent do? (I said: “Reviews incoming PRs for security vulnerabilities and suggests fixes.”)
• Who uses the output? (Dev team, async reviews.)
• How often should it run? (On PR creation + scheduled nightly rescan.)
• What’s your definition of done? (Agent flags ≥90% of critical vulnerabilities, gives actionable patches.)
• What existing tools does it need? (GitHub API, a vulnerability database lookup.)

So each answer gets fed into interview-to-config.md logic — the skill maps your natural-language answers to CMA primitives: agent prompt, tools array, guardrails, schedule window.

Honestly? The most surprising part was how specific the questions were. And this isn’t a generic “what do you want” form. But it drills into scope constraints, tool dependencies, and success criteria in a way that forces you to think through your agent before building it.

Phase 2: Stage & Launch

After the interview, the skill generates the full CMA API payload and pushes it to your Console. It:

1. Creates the agent definition — system prompt built from your interview answers
2. Sets up the environment — tools, integrations, allowed API calls
3. Launches a v0 to your account
4. Puts the build sheet in my-agent/ — the exact payloads, a resumable launch script, the eval scaffold

I watched the CLA terminal spit out the generated payload section by section. About 12 seconds from “staging” to “launched.”

Phase 3: Grade & Iterate

Here’s where it got interesting. Now the skill runs an evaluation against the success criteria you defined in the interview. My PR-reviewer agent went through:

• A test PR with a known SQL injection vulnerability → ✅ Flagged correctly
• A test PR with a subtle XSS vector → ⚠️ Flagged but fix suggestion was generic
• A test PR with no vulnerabilities → ✅ Correct pass

And the eval scaffold lives in my-agent/ so you can re-run it after tweaking the prompt. So the skill showed me the grade breakdown and asked if I wanted to iterate. I adjusted the prompt to be stricter on XSS patterns — re-ran the eval — and the second pass caught it.

This phase alone saved me probably an hour of manually setting up eval cases and iterating through different prompt versions.

Phase 4: Run Without You

And if your agent should run on a schedule (mine did — rescan existing PRs nightly), the skill handles the deployment. The /wrap-up skill generates an overview page and a NEXT-DIRECTIONS.md with v1/v2 plans.

What You Actually Walk Away With

And after my session, I had a live PR-review agent in Console, a local my-agent/ folder with every config I could want to tweak, and a roadmap doc telling me what to ship next.

Manual vs. Skill Pack — A Quick Comparison

Limitations — Being Real About It

Still — it’s not perfect. A few things to know before you jump in: If you’re building beyond CMA’s primitive model, an open-source agent harness might serve you better for custom toolchains.

• No contributions accepted. This is a reference implementation. Anthropic isn’t patching bugs or adding features. So if something breaks with a CMA API update, you’re fixing it yourself.
• You need a paid API key. The skill generates API payloads that hit the CMA endpoint — that costs. Not much (cents per run), but you can’t use the free tier.
• The interview flow is opinionated. It guides you toward agents that fit the CMA primitive model. But if your use case doesn’t map neatly (multi-agent orchestration, custom toolchains), you’ll hit friction.
• CMA itself has limits. Primitives, tool slots, rate quotas — the skill works within CMA’s boundaries. So for a complex production agent you’ll still need to understand those limits.

Who Should Use This

• Technical founders wanting to prototype and launch a CMA in under an hour → This is your tool.
• Existing CLA users who’ve been meaning to try CMA but didn’t want to learn the API → Zero learning curve.
• AI agent researchers wanting a reference implementation of the build pipeline → The interview-to-config.md and examples-bank.md files are gold for understanding CMA internals.

But who should skip it? If you’re building a multi-modal agent that needs video processing or custom streaming logic, CMA’s primitive model probably isn’t the right layer anyway.

The Bottom Line on launch-your-agent

Honestly? launch-your-agent is the fastest way I’ve seen to go from “I want a managed agent that does X” to “I have a live agent that does X.” The interview flow is surprisingly well-designed — it makes you think through your agent’s constraints before writing any code. And the generated artifacts (build sheet, eval scaffold, roadmap) are genuinely useful, not filler.

342 stars in a week is a sign that Anthropic’s CMA ecosystem is hitting its stride. And this skill pack is the front door.

So if you use Claude Code and have been eyeing CMA but haven’t jumped in: clone the repo, run /launch-your-agent, and spend 20 minutes building your first managed agent. You’ll know by the end of the interview whether CMA fits your use case.

And if you want to go deeper on Claude Code and CMA workflows, pick up “Hands-On Large Language Models” by Jay Alammar and Maarten Grootendorst — it covers the foundations that make agent pipelines like this possible.