video youtube.com Watch ↗

Claude Code's New Open-Source "Launch Your Agent" Skill — Loops as a Managed Cloud Service

TL;DR

The video walks through Anthropic's open-source "Launch Your Agent" skill for Claude Code, whose payoff is a new deployment altitude the vault hasn't captured: the Claude Managed Agent (CMA) — you define an agent (model, instructions, tools, goal, success rubric) and Anthropic runs the loop for you in their cloud, always-on and schedulable, with an optional memory store so later runs beat earlier ones ("run 10 is smarter than run 1"). Everything up to that point — a loop is a goal-not-a-task cycle that checks its own work and repeats until it passes, the human's job shifts from prompting to designing loops (Boris Cherny: "I don't prompt Claude anymore… my job is to write loops"), the three inputs are context/goal/success — is an independent corroboration of what Agent Loop, Loop Engineering, and Self-Improving System already hold. The distillate's genuinely new nodes are (1) Managed Agent — the who-hosts-and-operates-the-loop dimension, sold as "no platform fees, just API cost"; and (2) Pre-Deployment Validation — the creator's own hard-won lesson, when his demo CMA burned ~28 min and ~27M tokens (~$12) then failed its rubric because the managed environment couldn't reach Reddit (a required source): check the load-bearing assumptions before you pay an always-on cloud loop to rediscover a broken one.

Concepts introduced

Managed Agent — new. The deployment/hosting altitude: define an agent, let the vendor host and run the loop always-on in their cloud (Anthropic's "CMA"), schedulable, with an attached memory store; "no platform fees, just API cost."
Pre-Deployment Validation — new. Smoke-test the load-bearing assumptions (especially tool/environment access) before committing a task to an expensive always-on loop, because a managed cloud loop will pay real time+tokens to rediscover a broken premise and then fail its own rubric.

Concepts corroborated / built on (no new page)

Agent Loop — the goal-not-a-task, check-your-own-work, repeat-until-it-passes engine; and the persist-memory rule now has a managed-service instance (the CMA memory store).
Loop Engineering — another independent restatement of "stop prompting, write loops" (same Boris Cherny quote), extended with the managed-hosting angle.
Self-Improving System — "run 10 is smarter than run 1" via an attached memory store is the hosted, managed face of a compounding system.
Evidence-Gated Completion — the drafted success rubric that the CMA grades against and repeats until it passes; the demo's failure is the gate working (it refused to call a run that missed the real-Reddit-link requirement a success).
Agent Rituals — CMA scheduling is a managed instance of scheduled "routines"; the bonus wrap-up skill is an end-of-run closeout ritual.

Held, not dropped

The interview → drafted-rubric elicitation UX (skill interrogates you for context/goal/success and drafts the acceptance criteria for you) — a reusable onboarding pattern; folded into Managed Agent for now, could spin out toward Intent Context if a second source converges.
The bonus "wrap-up" skill (congratulate → overview page → 1–2 next upgrades) — an end-of-run closeout; noted under Agent Rituals, too thin for its own page yet.
The local overview HTML dashboard that lives on your machine and updates over time — an agent-facing status surface; held.
"Agent as an employee" and personalized-from-past-conversations onboarding — definitional / product-UX color already covered by Workflows vs Agents and The Augmented LLM; held.

Key claims

A managed agent separates defining an agent from hosting it — you specify model/instructions/tools/goal/success and the vendor runs the loop, always-on, in their cloud. principle → Managed Agent
The video states Anthropic released a free, open-source "Launch Your Agent" skill for Claude Code that stands up a "Claude Managed Agent (CMA)" hosted on Anthropic's servers. observation → Managed Agent — attributed, groundable (named release).
The video attributes to Boris Cherny (named as the creator of Claude Code): "I don't prompt Claude anymore… my job is to write loops," Claude then prompts itself. observation → Loop Engineering — attributed quote.
The video states a CMA has "no additional platform fees — you pay only the underlying API cost." observation → Managed Agent — attributed pricing claim to verify.
The video states a CMA can attach a memory store so agents remember across runs and improve each time ("run 10 is smarter than run 1"). observation → Self-Improving System
A loop is a goal-not-a-task cycle that decides its own next action, reads its own result, and repeats until the output passes the acceptance test. principle → Agent Loop
A managed agent's onboarding skill should interview the operator for context/goal/success and draft a checkable success rubric before deploying — "spend 10 minutes now to save hours later." best practice — context: getting non-experts from idea to a live agent → Managed Agent
Validate load-bearing assumptions — especially tool/environment access — before committing a task to an expensive always-on loop; a failed premise surfaces as an expensive retry loop that then fails its own rubric, not a fast error. best practice — context: managed cloud loops billed by tokens+time that self-retry on failure → Pre-Deployment Validation
The video reports the demo CMA defaulted to Opus 4.8 (creator switched to Sonnet), ran ~28 minutes, spent ~27M tokens / ~$12, and failed because the managed environment could not access Reddit (a required source). observation → Pre-Deployment Validation — attributed, groundable (named models, cost/token figures).

Why this is novel (with strong corroboration underneath)

The dominant stance is novel: the CMA — a managed, hosted, always-on loop runtime you configure rather than operate — attaches to no existing concept page. The vault's loop concepts (Agent Loop, Loop Engineering) live at the artifact and practice altitudes; none of them capture where the loop runs and who keeps it alive, which is the whole selling point here. That new node is Managed Agent, and the demo's failure spins out a second: Pre-Deployment Validation.

Underneath the new node, most of the teaching is corroboration. The goal-not-a-task loop, the self-checking cycle, the "stop prompting, write loops" role shift (same Boris Cherny quote), the three inputs (context/goal/success), and "run 10 is smarter than run 1" are all convergent restatements of Agent Loop, Loop Engineering, and Self-Improving System — a second independent source now agrees. Notably, the drafted success rubric and "grade against it, repeat until it passes" is Evidence-Gated Completion baked into the runtime, and the demo shows the gate doing its job by refusing a run that missed a hard requirement.

One productive tension to flag rather than resolve: Pre-Deployment Validation ("smoke-test the premises first") sits against Self-Improving System's DRIVE mindset ("action over analysis, action produces information, don't over-engineer"). They reconcile as a boundary, not a contradiction — cheap checks on the one or two load-bearing premises are worth it precisely when the run is expensive (a managed cloud loop billing tokens+time), whereas a cheap local one-shot should just run. The demo is the case where skipping the check cost ~$12 and 28 minutes to learn one fact ("this environment can't reach Reddit").

Illustrated walkthrough

Visual coverage is ok (max blind gap ~46s; the teaching half is clean Excalidraw slides, the demo half is largely talking-head narration over a screen-record of platform.claude.com, so a few spoken beats aren't on a slide).

t=00:34 — Agent = an employee with tools. Framing slide: an agent, unlike plain chat, has tools (search the web, write files, run code, call APIs) and chooses which to use at each step. Punchline: "if you want AI to do recurring work without you touching it, you need an agent, not just a better prompt."
t=01:29 — "My job is to write loops." A Boris Cherny clip (named as the creator of Claude Code) is used as the authority: he no longer prompts Claude directly — he writes loops that prompt Claude. This is the same quote the graph already anchors Loop Engineering on.
t=02:20 — /loop = a goal, not a task. The core teaching slide (below): a 5-step engine — 01 receive the task (give Claude a goal, not a question) → 02 think about what to do next (Claude reasons, doesn't ask you) → 03 pick a tool and use it → 04 read the result → 05 decide: is it done? if not, go back to step 2; if yes, deliver. Footer: "this cycle repeats 10, 20, even 50 times without you touching it." Claude "often knows a better way to accomplish your goal than an explicit set of instructions."
t=02:57 — The self-improving feedback loop. The human is "no longer responsible for the results of Claude — it's responsible for its own results." Only output that passes the test is presented back.
t=03:15 — Three inputs to a good loop: context (what it should already know / prefs / data), goal (what you're trying to achieve), success (what the ideal outcome looks like).
t=03:46 — CMA = Claude Managed Agent (the pivotal slide): "Anthropic runs that loop for you, in their cloud, on their servers. You don't write the loop. You just define the agent (what model, what instructions, what tools it has access to). Trigger it." A THE-OLD-WAY (build the loop / host a server / handle errors / wire tools / months of work, all X-ed out) → CLAUDE-MANAGED-AGENTS (Anthropic Cloud: your agent = Linux sandbox + tools + memory) diagram. Callouts: "No platform fees, just API costs" and "It remembers things across sessions… run 10 becomes smarter than run 1 automatically."
t=04:47 — /launch-your-agent, five steps (slide): (1) run it in Claude Code → (2) the skill interviews you (what should it do, what does success look like) → (3) it makes the API calls (creates the agent definition, spins up the cloud env, sets a schedule) → (4) "Claude Code is out of the picture — CMA takes over, runs the loop, grades the output against your rubric, repeats until it passes" → (5) "you get the result without writing a single line of infrastructure code."
t=05:45 — Install via GitHub. Paste the repo link, tell Claude Code "install this skill globally"; it reads the repo to learn how, then installs the launch-your-agent skill plus a surprise bonus wrap-up skill (congratulates the user, writes an overview page, and picks 1–2 next-step upgrades). Requires the operator's own Anthropic API key; restart the desktop app to see the new skill.
t=08:17 — Interview gets specific, not vague. The skill personalizes example agent shapes from past conversations, then drills in: what's the concrete deliverable, what niche / audience, what sources — "spend 10 minutes now to save hours later."
t=09:57 — It drafts a success rubric. For a daily news digest: exactly five items, each with a real Reddit post and working link, each with a distinct hook angle "in your voice", each with a "why it matters to your audience", genuinely recent/trending, no duplicates, clean scannable markdown. (This drafted, checkable rubric is Evidence-Gated Completion wired in up front.)
t=11:29 — The plan in "CMA shape." Model defaults to Opus 4.8 (creator swaps it to Sonnet — "don't need Opus for this"), plus environment, tools, deliverable, schedule, and evaluation. Deploys live at platform.claude.com: a built system prompt, a sessions view of every call, visible self-fixing on errors, and a local overview HTML dashboard that updates over time.
t=13:23 — Results: the good, the bad, the ugly. The digest did produce five story/link/hook/why-it-matters items — but the managed environment couldn't access Reddit directly, so the run took ~28 minutes (mostly retrying Reddit errors), spent ~27M tokens (~$12), and ultimately failed because "each item links to a real Reddit post" was a hard requirement. Creator's lesson: "before creating the managed agent, have the system check the individual pieces… make sure the theories behind the build are good before setting it up on the cloud." The self-improving angle then works as advertised — the agent proposes the fix (web-search-only, ~2–3 min instead of 30) as the next run's upgrade.