anthropics/launch-your-agent

This repository is not a runtime application; it is a Claude Code skill package that orchestrates a human-guided build flow for Claude Managed Agents (CMA). The architecture is mostly documentation, prompts, templates, and reference artifacts that Claude Code uses to drive the process end to end.

1. Primary execution boundary: Claude Code + skills

- The main entrypoint is the /launch-your-agent skill under .claude/skills/launch-your-agent/.

- Claude Code loads the skill automatically when run from this repo, so the repo functions as an operational playbook rather than a compiled app.

- The companion /wrap-up skill provides post-build closeout and status review.

2. Main orchestration flow

- The launch skill is organized into four phases: interview → stage & launch → grade & iterate → run without you.

- This creates a staged control flow where the assistant first elicits requirements, then turns them into a CMA build, then validates the result, and finally sets up unattended operation if the agent should recur.

- The flow is explicitly designed to produce a v0 plus a forward plan for v1/v2 rather than trying to solve everything in one pass.

3. External service boundary: Claude Managed Agents

- The real system being configured lives in Claude Managed Agents on the Anthropic platform.

- The repo’s skill references the CMA API docs and primitive definitions as the source of truth for what can be created, launched, graded, and scheduled.

- The actual agent, environment, graded runs, and scheduled deployment are created in the user’s own Anthropic account, not inside this repository.

4. Interview and scoping subsystem

- The skill’s reference materials include interview guidance and mapping logic so the conversation can be turned into a concrete build sheet.

- This is the requirements-to-architecture translation layer: user intent becomes CMA primitives, launch configuration, and success criteria.

- The repo emphasizes scoping to a versioned build plan, which is why the output includes explicit next steps instead of only a finished launch.

5. Launch and iteration subsystem

- The core build phase generates the artifacts needed to stage and launch the agent, then checks whether the result matches the stated definition of done.

- The iteration loop exists to improve the agent against user-defined evaluation criteria, not just to confirm that deployment succeeded.

- This means the system has a feedback loop between configuration, execution, and grading.

6. Generated local artifact boundary

- The README says the flow leaves behind a my-agent/ folder containing the build sheet, exact API payloads, resumable launch script, eval scaffold, overview page, and next-direction plan.

- That folder is the durable handoff from the interactive skill to a concrete project state the user owns.

- In architecture terms, it is the boundary where the ephemeral conversation becomes persisted implementation assets.

7. Reference knowledge base

- .claude/skills/launch-your-agent/references/ contains the skill’s supporting knowledge: verified API call shapes, examples bank, mock connectors, interview notes, and an overview template.

- cma-primitives.md at the repo root provides a compact inventory of CMA capabilities and limits.

- These files are the system’s “design-time schema” for deciding what can be built and how.

8. UI and presentation artifacts

- The ui/ directory contains example assets for the generated overview page and build sheet JSON.

- ui/agent-overview-example.html is a presentation template for the post-build overview page.

- ui/build-sheet.example.json shows the structured shape of the configuration the skill produces or consumes.

- This is not the application runtime; it is the human-facing reporting layer for the built agent.

9. Documentation and governance layer

- README.md, CLAUDE.md, CONTRIBUTING.md, and LICENSE define usage, operating assumptions, and project boundaries.

- The README explicitly states this is a reference implementation and not maintained, which matters for architecture because it frames the repo as instructional scaffolding rather than an evolving product.

- The docs are part of the repo’s control plane for how the skill should be used.

10. Operational inputs and secrets

- The workflow requires an Anthropic API key in a local .env file for the user’s account.

- That secret is an external input to the launch process and must stay outside chat and out of versioned artifacts.

- This is the only material secret-management boundary called out in the repo.

11. End-state and output model

- Successful use of the repo yields a live CMA agent plus a local package of build artifacts and a documented upgrade path.

- The architecture therefore produces two outputs: a deployed remote agent in Anthropic’s platform and a local handoff bundle for the owner.

- The /wrap-up skill closes the loop by regenerating the overview page and recapping owned primitives.

12. How to draw it

- A clean diagram would show: User → Claude Code → launch skill references/templates → CMA API / Anthropic platform → generated local my-agent/ assets, with a separate wrap-up path fed by the deployed agent state and local artifacts.

- The repo itself sits mostly in the orchestration and documentation layer, while the actual execution happens in the external CMA service and in the user’s local Claude Code session.