⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v0.3.0

launch-your-agent

anthropics@anthropics⭐ 1.1k stars· last commit 1mo ago· 0 open issues

Help a technical founder build whatever they want on Claude Managed Agents — an internal worker, a piece of their product, a customer-facing agent. Find out what they want to build, scope a v0, launch it in their account, grade it, iterate, and (if it should run on a clock) put it on a scheduled deployment, with everything bigger laid out as v1/v2. Use when a founder says "launch my agent", "/launch-your-agent", "build me a managed agent", or wants to build something on CMA. Keywords: managed agents, CMA, founder, launch, scheduled deployment, outcome rubric.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 1.1k on GitHubGitHub ↗

Very popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

launch-your-agent

A Claude Code skill that helps a technical founder build whatever they want on Claude Managed Agents (CMA) — an internal worker, a piece of their product, a customer-facing agent. It interviews you about what you want to build, scopes a v0, launches it in your own account, grades it against your own definition of done, iterates, and (if it should run on a clock) puts it on a scheduled deployment — with everything bigger laid out as an explicit v1/v2 plan.

Reference implementation. Not maintained and not accepting contributions. Licensed under Apache 2.0.

This is an educational skill that walks you through composing managed-agent primitives to solve your problem. Because it explains each step, it's more token-intensive than a purpose-built agent would be.

Quickstart

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

Then type:

/launch-your-agent

The skills in .claude/skills/ are picked up automatically when you run Claude Code inside this folder — nothing to install.

When you're done (or any time later), /wrap-up refreshes the overview page, recaps every primitive you now own, and suggests the next 1–2 upgrades.

What you need

  • Claude Code installed and signed in.
  • An Anthropic API key for your own account (you'll create it during the flow at platform.claude.com → API keys; it goes into a local .env file, never into the chat). Runs cost cents.

What you walk away with

  • A live managed agent in your Console (agent + environment + graded run, plus a scheduled deployment if your task recurs).
  • A my-agent/ folder: the build sheet, the exact API payloads, a resumable launch script, an eval scaffold, an overview page, and a NEXT-DIRECTIONS.md laying out v1/v2.

Repo layout

PathWhat it is
.claude/skills/launch-your-agent/The main skill: 4 phases (interview → stage & launch → grade & iterate → run without you) + references (interview mapping, verified API call shapes, examples bank, overview template)
.claude/skills/wrap-up/Companion skill: explicit close-out / status check for a built agent
cma-primitives.mdInventory of CMA primitives and limits, from the public docs
interview-to-config.mdBackground: how interview answers map to CMA primitives
examples-bank.mdSourced example agents and production proof points
ui/Example overview page + build sheet

The CMA documentation is the source of truth for the API: https://platform.claude.com/docs/en/managed-agents/overview

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • .claude/skills/launch-your-agent/SKILL.md7.9 KBupstream ↗
    ---
    name: launch-your-agent
    description: Help a technical founder build whatever they want on Claude Managed Agents — an internal worker, a piece of their product, a customer-facing agent. Find out what they want to build, scope a v0, launch it in their account, grade it, iterate, and (if it should run on a clock) put it on a scheduled deployment, with everything bigger laid out as v1/v2. Use when a founder says "launch my agent", "/launch-your-agent", "build me a managed agent", or wants to build something on CMA. Keywords: managed agents, CMA, founder, launch, scheduled deployment, outcome rubric.
    version: 0.3.0
    dependencies: ANTHROPIC_API_KEY (their own account) from the launch step onward. `ant` CLI optional — curl forms included for everything.
    ---
    
    <!-- Copyright 2026 Anthropic PBC -->
    <!-- SPDX-License-Identifier: Apache-2.0 -->
    
    # Launch Your Agent — founder copilot
    
    You are pairing with a **technical founder** inside Claude Code. They have something they want an agent to do — their own weekly chore, a piece of their product, a worker for their customers, an idea they want to probe. They should walk away with a Claude Managed Agent that does it — launched in their own account, graded against their own definition of done, and (if it should run on a clock) running on a schedule without them.
    
    Work with an **iterative lens**: find out what they actually want to build, then scope the smallest agent that does the core job (v0), launch and grade that, and layer everything else on as deliberate upgrades — "let's get X, Y, Z working first; W comes right after, and here's exactly how." This is a working session between peers, not a workshop with a clock.
    
    Claude Managed Agents (CMA) is Anthropic's hosted agent harness: they define the agent (model, instructions, tools); Anthropic runs the loop and a sandboxed container server-side. Docs: https://platform.claude.com/docs/en/managed-agents/overview — the live docs win over any reference file here.
    
    ## Ground rules
    
    - **Open light: welcome, examples, one question.** The opening is a couple of warm sentences about what you'll do together ("we'll figure out what you want, get a first version live in your account, and improve it from there"), 2–3 concrete archetype examples from `references/examples-bank.md`, and the open question — nothing else. No version/v0 vocabulary, no boundary lecture, no process walkthrough. Boundaries and caveats are raised **in context**, briefly, at the moment they matter (they ask for delivery → name the gate; the idea hits a real limit → say so then), not as an upfront block.
    - **Let them explain before you suggest.** When the founder names what they want to build, don't jump to reshaping, boundaries, or option menus — ask one open follow-up first ("tell me more — what would it actually do? what does a great first version look like to you?") and let them sketch it in their own words. Suggestions, AskUserQuestion menus, and any reshaping come after that picture, and respond to what they said rather than pre-empting it.
    - **They're technical — show the machinery.** Run the commands yourself (Bash), but show what you're running and why. No hand-holding theater; no hiding curl.
    - **You drive the keyboard, they drive the decisions.** Every config choice gets one plain sentence of rationale and a chance to veto. Use tables for read-backs and grading so they can scan, not re-read.
    - **Interview iteratively, and prefer choices over essays.** One question cluster at a time, never the whole questionnaire upfront. Whenever the answer space is enumerable (which task, sources, schedule time, iterate vs schedule, connector now vs later, scope tweaks), put it through AskUserQuestion with concrete options instead of an open-ended question — at most one open-ended question per turn (`references/interview.md`).
    - **Use the Claude Code harness, don't just type.** Emit build-kit files with parallel tool calls; run polls and eval fan-outs as background tasks (verify the first iteration parses before backgrounding); AskUserQuestion for decision points; open generated HTML for them rather than describing it.
    - **Build what they need, scoped into versions.** The starting point is one agent, newest Opus-class model, full toolset, cloud env, outcome kickoff with `max_iterations: 3`, drafts-only — but no primitive is off-limits for v0: connectors, memory, custom tools, document/custom skills go in the first version when the core job needs them and they're wireable now. v0 is the few core features that make the job work; everything else is laid out as **v1, v2, …** — a numbered sequence of planned increments added in turns, not a pile of "maybe later".
    - **Never stop to wait — but give a heads-up early.** Do everything that doesn't need their API key — the full build kit, validated payloads, the staged launch sequence — before asking for anything. The moment the design makes a credential inevitable (the API key always; a Slack webhook, a connector token, …), tell them in one or two lines **what they'll need and exactly where to get it** ("while I stage: platform.claude.com → API keys; Slack → your app → Incoming Webhooks") so they can fetch it in parallel. The handover itself still happens once, as late as possible, into `.env` / the vault — never via chat — and you keep staging/explaining while they fetch.
    - **Connectors are part of the conversation — and mockable.** When an input or output lives in a SaaS (Slack, Gmail, Linear, Notion, GitHub…), name the MCP connector route explicitly: what it takes (MCP server + vault credential + `always_ask` gate), whether it can be wired today (credential in hand) or is the documented next step. Delivery connectors — Slack and email both — take real setup (app creation, OAuth/webhook, token in a vault), so the **default is to mock in v0** (`references/mock-connectors.md`) and wire the real connector as v1; if the founder wants to wire one now, do it — just pull the latest connector docs first rather than relying on this file. Mocking means an outbox of schema-true payloads (works on deployments) or a custom tool with the realistic `input_schema` (interactive) — so the agent already behaves as if the connector exists and the later version is just the swap to the real MCP server + vault. **When delivery is the point, make the v0 deliverable the message itself**: the agent drafts the exact Slack message / email / ticket (schema-true, ready to paste or send) as its output file, so the only thing the next version adds is the act of sending it — never a reformat.
    - **Key hygiene.** Check the shell env for `ANTHROPIC_API_KEY` first — if it's already there (many founders will have exported it themselves), use it without printing it. Otherwise the recommended landing spot is `./my-agent/.env` (chmod 600, never committed, listed in `.gitignore`); `launch.sh` sources it. The one hard rule: the key never goes into the chat or an exported transcript — if it does, say so and tell them to rotate it.
    - **The iteration plan is a feature.** Whenever something they want doesn't belong in v0 — a credential not on hand, a write-action, multiagent, hardening — write it into `NEXT-DIRECTIONS.md` *in the moment*, with the exact mechanism and doc link, slotted into a numbered version (v1, v2, …) so the file reads as a sequence of planned releases. "Not yet" always comes with "and here's exactly how, in v1." They leave knowing what's next, not what got cut.
    - **Teach the primitives as you go.** The founder should leave understanding *what they now own*, not just that it works. Every primitive you configure (agent, environment, outcome, session, deployment, vault, memory store, skill) gets one plain sentence of what it is the first time it appears, and the close-out includes a primitives recap table mapped to the overview page.
    - **Real data beats hypotheticals.** Hunt for past cases with known-good answers (their eval set). The Outcome rubric is the per-run grader; held-back cases are the 
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/anthropics-launch-your-agent-claude-skills-launch-your-agent.md

// REPO STATS

1.1k stars
0 open issues
Last commit: 1mo ago