Managed Agent

A managed agent is a loop you define but don't host: instead of standing up a server, wiring the tools, handling the errors, and keeping the process alive, you specify the agent (model, instructions, tools it may use, goal, success criteria) and the vendor runs the Agent Loop for you — in their cloud, always-on, schedulable. The distinguishing dimension is not the loop (that is unchanged) but where it runs and who operates it: the operational burden moves off the operator's machine into a managed runtime. The video's instance is Anthropic's Claude Managed Agent (CMA), created by the open-source "Launch Your Agent" skill — run the skill, it interviews you for context/goal/success and drafts a success rubric, then it makes the API calls, spins up a cloud (Linux sandbox) environment, optionally attaches a memory store, sets a schedule, and hands off: from then on the managed runtime runs the loop, grades output against the rubric, and repeats until it passes, with no infrastructure code written.

Managed-agent is the deployment altitude the loop concepts don't cover: Agent Loop is the artifact, Loop Engineering is the practice of designing it, Agent Rituals declares recurring steps in a context file — a managed agent is the loop lifted off your machine into a hosted, always-on service. With an attached memory store it becomes a hosted Self-Improving System ("run 10 is smarter than run 1"). The economic pitch in the source is "no additional platform fees — just the underlying API cost."

Claims

A managed agent separates defining an agent from hosting it — you supply model/instructions/tools/goal/success and the vendor runs the loop, always-on, in their cloud. principle — durable altitude shift: it relocates the operational burden (servers, uptime, error-handling, tool-wiring) off the operator; the loop is the same, the who-runs-it changes. This is the "own-the-contract" seam applied to loop execution.
Hosting a loop as an always-on scheduled cloud service removes the "type /loop and wait at your machine" constraint. observation — the source's stated motivation for a CMA over a hand-run loop; it decouples the run from the operator's presence and device.
An onboarding skill that interviews the operator for context/goal/success and drafts a checkable success rubric is the safe on-ramp — "spend 10 minutes now to save hours later." best practice — context: getting non-experts from idea to a live agent; eliciting the three loop inputs and manufacturing an acceptance check up front is what makes an unattended deploy defensible (this is Evidence-Gated Completion and Intent Context wired in before launch).
Attaching a memory store makes a managed agent self-improving across runs — it reads what it learned last time so later runs beat earlier ones. best practice — context: recurring managed agents; a managed instance of the persist-memory rule in Agent Loop and Self-Improving System. Attributed to the source; the mechanism (a place to write notes between runs) is the same, only hosted.
Validate the runtime's premises before you deploy — a managed loop bills tokens+time and self-retries, so a broken assumption is expensive to discover after launch. best practice — context: expensive always-on managed loops; see Pre-Deployment Validation, spun out from this video's own failure (the CMA couldn't reach Reddit and burned ~$12 / 28 min).

Check-worthy source claims (attributed, not adjudicated — a later grounding pass can verify):

Anthropic released a free, open-source "Launch Your Agent" skill for Claude Code (plus a bonus "wrap-up" skill), which stands up a CMA hosted on Anthropic's servers at platform.claude.com. observation — named release, groundable.
A CMA has "no additional platform fees — you pay only the underlying API cost." observation — pricing claim to verify.
The demo CMA defaulted to Opus 4.8 (creator switched it to Sonnet), and one run spent ~27M tokens / ~$12 over ~28 minutes. observation — named models and cost figures, groundable; attributed as the source's report.

Agent Loop — the artifact a managed agent runs; managed-agent adds where it runs and who operates it. The persist-memory rule there has a managed-service instance here (the memory store).
Loop Engineering — the practice of designing loops instead of prompting; a managed agent is that designed loop lifted into a hosted, always-on runtime.
Self-Improving System — a managed agent with a memory store is the hosted face of a compounding system ("run 10 > run 1").
Evidence-Gated Completion — the drafted success rubric the runtime grades against and repeats until it passes; the gate is what lets an unattended managed agent be trusted.
Agent Rituals — CMA scheduling is a managed instance of scheduled "routines"; the bonus "wrap-up" skill is an end-of-run closeout ritual.
Intent Context — the interview step elicits the operator's intent (context/goal/success) before building; the elicitation-then-rubric UX is the on-ramp.
Pure Agent Application — the "Launch Your Agent" skill is one (a SKILL.md, no bespoke code), distributed via a public GitHub repo (Agentic Distribution).
Pre-Deployment Validation — the augment-side guardrail this video hard-earned: check the premises before paying an always-on loop to rediscover a broken one.
Distillate: Claude Code's New Open-Source "Launch Your Agent" Skill — Loops as a Managed Cloud Service
Distillate: Anthropic's Claude Cookbooks — the canonical recipe index — first-party managed_agents/ "CMA_*" recipes (human-in-the-loop gate, outcome-grader verify, operate-in-production).

Managed Agent

Claims

Related

Linked from