✓ Checked
Anthropic's 90-Minute Claude Managed Agents Course: The Four Official Videos
A viral post calls it a new 90-minute Anthropic course on building agents from scratch. It is a four-part Claude Managed Agents workshop from AI Engineer World's Fair 2026. What each part covers, where the post's timestamps land, and the docs to read for each step.
On November 2, 2026, tobarra (@txbrraa) wrote in Spanish that Anthropic engineers had just put out the best 90-minute course he had seen on building AI agents from scratch. He listed five timestamps: why the brain and the hands of an agent should be kept apart, the architecture behind Claude Managed Agents, a research agent built step by step, agents that run on a schedule and "dream" between tasks, and evals, CI/CD and serving many customers at once. The post does not link to the video.
The recording exists, and the chapter list describes it fairly. It is not a new course on Anthropic's own channel, though. It is a workshop two Anthropic engineers gave at the AI Engineer World's Fair 2026, published by the conference's AI Engineer channel as four separate videos. Below we list what each part covers, where the post's timestamps land, what "dreaming" really is, and the official docs page to read for each step.
The original post by @txbrraa on X (November 2, 2026)
Where the video is
The workshop is called Claude Managed Agents. It was given by two Anthropic engineers: the lead of the Managed Agents engineering team and an engineer on the same team. AI Engineer put it online in October 2026 in four parts, each with its own page on ai.engineer and its own YouTube upload:
So "90 minutes" is close but undercounts a little: the parts add up to 98 minutes 41 seconds by our calculation, and most of the second half is audience questions rather than lessons. We found no single combined video from Anthropic or from AI Engineer, so the post's timestamps most likely come from playing the four parts back to back.
Where the post's timestamps land
| Post's chapter | Post's time | Where it is in the official videos |
|---|---|---|
| Why brain and hands should be separate | 00:00 | Start of Part 1, which opens on harnesses and the model assumptions they carry; the split itself comes a few minutes later |
| The architecture behind Managed Agents | 07:45 | Part 1, the section that starts at 7:53: session log, brain and hands as separate pieces |
| A research agent step by step | 23:40 | About 6 minutes into Part 2, during the setup of the research desk app |
| Agents on a schedule that "dream" | 54:00 | Part 3 starts at 53:14 when the parts play in a row; deployments come at 1:12 and Dreaming at 2:42 into it |
| Evals, CI/CD, many customers | 1:10:23 | About 17 minutes into Part 3, in the Q&A on integration and tenancy; Part 4, with CI/CD and most of the eval talk, starts at 1:19:44 |
Positions in Part 2, Part 3 and Part 4 are by our calculation from the lengths above. The first four marks match the parts played in a row to within about a minute. The last one is about 9 minutes early for Part 4, though Part 3's Q&A does touch on evals and on serving many customers.
Part 1: the brain and the hands
The written version of this part is Anthropic's engineering post Scaling Managed Agents: Decoupling the brain from the hands, published April 8, 2026. It splits an agent into three pieces: the session, an append-only log of everything that happened; the harness, the loop that calls Claude and sends its tool calls where they need to go; and the sandbox, where code runs and files are edited.
The first version kept all three in one container. The engineers call it a pet: when the container failed, the session went with it, and debugging meant opening a shell inside a container that also held customer data. The redesign separates the "brain" (Claude and its harness) from the "hands" (sandboxes and tools) and from the session log. A sandbox is now just a tool the brain calls when it needs one, and a crashed harness is replaced by a new one that reads the log and carries on.
Two practical results come out of that split. Credentials stay outside the sandbox: Git tokens are wired in when the repo is cloned, and MCP tokens sit in a vault behind a proxy, so code that Claude writes cannot read them. And sessions start faster, because a container is created only when one is needed. As reported by Anthropic, median time to first token fell by roughly 60% and the 95th percentile by over 90%. The ai.engineer summary of this part says "about 90%", which is the p95 figure, not the typical case.
Docs for this part: the overview with the four core ideas (agent, environment, session, events), the quickstart, environments and self-hosted sandboxes.
Part 2: building the research agent
Part 2 starts with a no-code agent made in the Claude Console, then moves to the workshop app. The code is in Anthropic's cwc-workshops repository, in the research-desk folder: a Next.js app on top of Managed Agents. The repository is Apache-2.0 and is marked as not maintained and not accepting contributions. A workshop skill in the repo walks Claude Code through the build, so most of the coding on stage is done by an agent.
The agent gets, step by step:
- a skill for SEC filings, which needs your name and email as an EDGAR identity, because the SEC asks callers to identify themselves;
- subagents with their own prompts, tools and permissions, and a custom tool that the app fulfils itself;
- a shared memory store, so a later session can reuse what an earlier one learned about a company;
- outcomes: a task plus a rubric. When the agent thinks it is done, a grader checks the work against the rubric and sends it back if it falls short.
In the Q&A, the team lead describes the Claude Agent SDK as a headless Claude Code you run wherever you like, while Managed Agents is Anthropic's own hosted harness. She also said that per-session dollar and token caps were being explored but not offered at the time; the docs now have a session budgets page, so check it before you rely on a cap.
Docs for this part: define outcomes, skills, multiagent orchestration, memory stores, vaults and the event stream.
Part 3: schedules, and what "dreaming" really is
Part 3 opens with fan-out: a custom tool turns "analyze Google and Microsoft" into one research session per company, each with its own subagents and graded outcomes. Then come deployments, which combine an agent, a schedule, a first message and resources such as memory stores, so the research can run every morning on its own. The live runs failed during the demo, and the cause was not found on stage.
Then Dreaming, introduced as a research preview. In the demo it reads the last 30 days of sessions that used a memory store and adds what it learned to that store. Anthropic's Dreams docs describe the feature more plainly than the post does:
- A dream is a job you start. It takes a memory store plus 1 to 100 past sessions and writes a new, reorganized memory store with duplicates merged and stale entries replaced.
- Your original store is not touched, so you can review the result and throw it away.
- It takes minutes to a few hours and needs its own beta header and an access request.
So "agents that dream between tasks" is a stretch. Nothing happens between tasks unless you start a dream or schedule one, and what changes is a memory store, not the agent's skills or prompts. In the talk, improving skills and prompts directly is mentioned only as a possible extension.
The Q&A in this part covers observability through the event stream, very long sessions, how workspaces separate access, and scale. Two limits are worth knowing: fine-grained access control inside a workspace was not available in the version discussed, and running on your own servers (on-premises) was only under consideration.
Docs for this part: scheduled deployments, Dreams, workflow runs and session observability.
Part 4: evals, CI/CD and many customers
Part 4 is all questions from the room. The useful answers:
- Keep agent definitions in the repo. Store them as YAML and apply changes from CI/CD with the
antcommand-line tool, as Anthropic does for its own long-lived resources. - A pending custom tool blocks chat. While a session waits for a custom tool result, an ordinary user message gets HTTP 400. The suggested fix is to give that tool to a subagent and keep the main agent free to talk.
- Evals start from your own history. Anthropic's example is running 10,000 sessions in parallel against a new model. For your own agent, the advice is to grade past sessions first and to distrust an eval that scores 100% on a vague task.
- One workspace per customer. Separate workspaces are how the speakers suggest keeping customers' data apart; session metadata can record who a session belongs to, but it does not separate anything.
- GPUs and extra memory come from a self-hosted sandbox with another provider.
Before you build on it
Per the overview, Managed Agents is in beta: requests need the managed-agents-2026-04-01 beta header, except memory store calls, which use agent-memory-2026-07-22 instead (sending both returns a 400 error, per the memory docs), and MCP tunnels and dreaming sit in a narrower research preview. Because sessions are stored on Anthropic's side, the service is not eligible for Zero Data Retention or a HIPAA BAA. It is available through the Claude API, Claude Platform on AWS and Anthropic-managed Claude models on Google Cloud. Pricing for the models is on our Claude API page and in Anthropic's docs.
What the post gets right
- The speakers are Anthropic engineers who work on Managed Agents, and the five topics come in the same order as in the videos.
- The brain and hands split really is the core idea, and the research agent is the longest and most hands-on part.
- Scheduled runs and Dreaming are both shown, and evals, CI/CD and multi-tenancy are all answered in the Q&A.
What the post leaves out
- It is not a new course, and it is not on Anthropic's channel. It is a conference workshop recording in four parts on the AI Engineer channel, nearly 99 minutes long, with about half of it audience Q&A.
- It is not "from scratch" in the usual sense. The point of Managed Agents is that you do not write the agent loop, the sandbox or the tool runner; Anthropic hosts them. If you want to build that loop yourself, this is the wrong video.
- Dreaming is a research preview that you request access to and start as a job; it does not run between tasks on its own.
- The scheduled-run demo failed on stage, and the product is in beta, with no Zero Data Retention.
- The code is public, in the
research-deskfolder of anthropics/cwc-workshops, which the post does not mention.
Where it fits on AgentGid
Managed Agents is one of three ways to build on Claude. If you want the loop in your own code, our guide How to Build an AI Agent compares frameworks and vendor SDKs, including the Claude Agent SDK. If your agent needs to use your own service, a managed agent can call MCP servers; What Is MCP explains the protocol.
The verdict
- Worth watching if you are evaluating Managed Agents. Part 1 and Part 2 are the core; Parts 3 and 4 answer the production questions (tenancy, CI/CD, evals, limits) that the docs answer more briefly.
- Read the engineering post first. It covers Part 1 in a few minutes of reading.
- Treat Dreaming as an experiment: a research preview that rewrites a copy of your memory store, not a self-improving agent.
- Check the docs before you copy anything from the stage. The talk was recorded at the World's Fair, well before the October upload, and things such as session budgets have changed since.
Facts about the workshop (titles, lengths, section times and what is said on stage) come from the four talk pages on ai.engineer; the architecture and the time-to-first-token figures from Anthropic's engineering post; product facts from Anthropic's Managed Agents docs and the cwc-workshops README, read on November 6, 2026. Positions in the combined video and the total length are by our calculation. We did not run the workshop code.