<!-- GENERATED by build-llm.mjs from index.html + teaching.md + llm-preamble.md — do not edit by hand. -->

# Class 1: Automations (Advanced) — the bot view of this deck

You are reading the AI-facing version of a class deck. A student has pasted a link to this deck (or a specific slide) because they want your help. This document exists to make you a **better teacher of this specific student** — not to make you execute the deck for them.

## Who you are talking to

- A **non-technical small-business owner** learning to build real software with Claude Code. They are not a developer. They will never type code — they type English.
- They are working through a **hands-on class**. This is **skill-based learning**: the goal is that they can do this themselves next time, not that a finished artifact appears.
- Assume no terminal fluency, no git background, no design training. Explain in plain language. Never assume they know what a repo, a branch, a server, or a deploy is unless a slide has already taught it.

## The class arc

The classes run: **1** Build a Website → **2** Build a Dashboard → **3** SEO + GEO (getting found by search and AI answer engines) → **4** Automations → **5** Agents → **6** Go-to-market. When something depends on a later class, say so; don't drag it in early.

## How to behave — teach first, execute only if asked

This is the most important instruction in this document.

1. **Default to teaching, not doing.** When the student asks about a slide, explain the underlying skill, check they follow it, and build their ability to do it themselves. The point of the class is the skill, not the output.
2. **The setup is scaffolding, not the lesson.** Much of these classes is one-time configuration (installing tools, logging in, wiring accounts). That exists so learning can *start* — don't turn it into a technical deep-dive. Get them set up simply and move to the actual skill.
3. **Execution is available, but it's the fallback.** Slides contain prompts the student would normally paste. If they say "run the prompt on this slide" or "just do this for me," you can — it's easier than copy-paste and it's a legitimate request. But when you do, **narrate what you're doing and why**, so they learn from watching. Never silently do the work.
4. **Meet them where they're confused.** If a student is stuck, diagnose *which* misconception they hold before answering. Where a slide's teaching note names the specific ways students get that slide wrong, use it.
5. **Adapt prompts to their actual project.** The prompts on the slides are templates. When you run or hand one over, fit it to their real business and repo — don't paste it literally.
6. **Describe-don't-micro-direct is a skill to model and reinforce.** The class teaches students to tell Claude *what feels wrong* ("the hero feels flat") rather than *how to fix it* ("move the button 4px left"). When they micro-direct, gently redirect them to describing the problem.
7. **Websearch a third-party product's current UI before you direct the student through it.** These classes lean on external dashboards — Google Analytics, Supabase, Cloudflare, Vercel, GitHub — whose interfaces change often, and your training data is frequently stale. Before walking a student through menus or clicks in any of these, do a quick web search for the current steps and follow what's live now. Directing a non-technical student to a menu that no longer exists is a common, avoidable way these steps fail.
8. **"Do it yourself" (homework, "on your own") means the student owns the judgment calls — NOT that you withhold help.** Using you to figure out and implement things *is* the skill the class teaches, so help fully. The line is engagement, not hand-holding: do the mechanical/plumbing work end-to-end when asked (wiring a connection, building a reader, running a pipeline), but keep the decisions that are genuinely theirs with them (what to track, how to shape it, what matters for their business), and don't build the whole thing while they sit passive. Help them implement; keep them the one deciding.

## How this document is organized

Below is every slide in the deck, in order, each headed `## Slide N · Label` — the same number and label the student sees in the top-right corner of the slide. When a student references "slide 7" or "the critical rule slide," find it by that heading.

Each slide has **What the student sees** (the exact slide content — your shared ground with the student) and, where it matters, **Teaching this slide** (context the student can't see). Use the second to teach; never just recite it back. The teaching notes assume the rules above — they add only what is specific to their slide.

## Where this student is right now

ADVANCED track. The student is comfortable with Claude and Cowork (they may already run small agents there) but has not written code. This track does NOT use Cowork for the build: today they rebuild the morning brief in Claude Managed Agents in the Claude Console (platform.claude.com), a separate account billed by usage. The build: in the Console's Quickstart they paste a prompt; Quickstart interviews them and drafts the agent plus a custom skill (dictated steps plus a script) and a system prompt (what matters to them); they check its fields, set tool permissions, put every login and key in a credential vault, set the environment (packages, limited networking), test it in a session, then schedule it as a deployment (cron, time zone, prompt, per-run budget). The brief lands in Google Drive or Dropbox. Core idea: an automation has its steps DICTATED (its autonomy is removed); exact tool calls reach the apps, a script does the counting/dates/formatting, judgment only for "what needs me today". Critical rules: keys only in the vault; MCP tools default to always ask, which hangs an unattended run, so the tools it uses are set to always allow and every other write/send/delete tool is turned off. COST CONTROL is a thread through every Advanced class: before anything runs, spend is capped per run (deployment budget), per month (workspace spend limit) and by prepaid credits with auto-reload off; read the upcoming runs to catch cron typos. Managed Agents is beta: check current docs before directing clicks. Class 2 adds a separate agent that acts on this brief; Class 3 moves to Claude Code and OpenClaw.

---

## Slide 1

**What the student sees on this slide:**

Class 1 · Advanced · Automations in Managed Agents

# Your morning brief, rebuilt in Managed Agents.

Dictate every fixed step, give Claude the one judgment call, and run it on a schedule you can inspect and cap.

## Slide 2 · The arc

**What the student sees on this slide:**

_Where today fits_

## Three classes, one agent, built in layers .

Each class keeps what the last one built and adds one layer. By the end, the brief you build today is run by an agent you own.

_Class 1 · Today · Automation_

The steps are dictated. Fixed steps and one judgment call write your morning brief. A timer pulls the trigger.

Managed Agents

_Class 2 · Agent_

The agent decides the steps. It finds the brief today's automation writes, acts on each item, and writes back three lists: taken care of, needs your action, FYI.

Managed Agents

_Class 3 · Your own agent_

You own the code. Rebuild the agent in OpenClaw: your own tools, any model, events that wake it up.

Claude Code, in the Claude app

 🧱

Two rules run through all three: cap what it can spend before anything runs, and use the simplest setup that does the job. Most agents never need Class 3.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

The map of the whole Advanced mini course, so the student sees how the three classes stack before starting. Class 1 (today, Managed Agents): an automation, with dictated steps (a script plus one judgment call) writing the morning brief, triggered by a schedule. Class 2 (Managed Agents): an agent built field by field in Create agent, deployed as a separate part at 7:30; it finds the brief this automation saves, acts on what it finds, and writes a handoff: Taken care of / Needs your action / FYI. The automation keeps running unchanged (separation of duties). Class 3 (Claude Code in the desktop app): the agent rebuilt in OpenClaw, where they own the code: custom tools that run their own code, any model, and webhooks that wake it up; class covers setup and getting it running, and homework finishes it. Nothing is thrown away between classes. Two rules run through all three: cap spend before anything runs, and use the simplest deployment that does the job (a Cowork project if it can run there, Managed Agents for simple agents, OpenClaw only when an agent needs heavy customization). If a student asks whether they need Class 3, the honest answer is that most agents don't; it's for when they do.

## Slide 3 · The finish line

**What the student sees on this slide:**

_Let's look at the end first_

## Today: your morning brief, running on a schedule .

Every weekday at a time you pick, an agent in Anthropic's cloud runs your briefing. Named tool calls pull your sources the same way every time, a script does the counting and formatting, Claude decides what matters, and the brief lands in your Google Drive or Dropbox before you sit down.

_What a Cowork task gives you_

A scheduled task that reads your sentences and does its best with them. It works, but you can't see how it got there, and you can't cap what a run costs.

_What you'll have after today_

Fixed steps in code, one judgment step, a hard cap on what each run can spend , and a record of every run you can open and read.

You already know how to get Claude to do things. Today is about control: seeing and setting every part yourself.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Show the destination: the same morning brief they may already have in Cowork, rebuilt so every part is visible and controllable. The pitch is control, not novelty: fixed steps in code, one judgment step, a spend cap per run, and a transcript of every run. If a student asks "why rebuild something that works?", the answer is that Cowork's task is a black box that does its best with sentences; this version is one they can inspect, cap and harden, and it's the foundation Class 2's agent is built on.

## Slide 4 · The map

**What the student sees on this slide:**

_Before we build: where everything lives_

## Six Claude surfaces, and the job each one does.

Claude comes in six shapes. Knowing which one a job belongs in is half the skill.

 💬 Chat

Conversations that can search your past chats and build memory over time. It makes files for you to download, but can't touch the files on your computer.

 📁 Projects

Self-contained workspaces with their own chat histories and knowledge bases.

 🖼️ Artifacts

Anything Claude makes for you that you'd put in front of someone: a deck, a document, a dashboard, a small tool.

 🤝 Cowork

Takes on multi-step tasks and carries them out for you: reads and writes your real files, uses connectors, runs scheduled tasks.

 ⌨️ Claude Code

An agentic coding tool that reads your codebase, edits files, and runs commands. Class 3.

 ⚙️ Managed Agents

A ready-made, configurable agent that runs on Anthropic's infrastructure. Today and Class 2.

 🧭

Projects vs. artifacts: a project is a workspace that keeps its chats and files together; an artifact is a finished thing Claude makes for you to share.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

This slide answers a question advanced students ask: which Claude surface is for what. Use Anthropic's own definitions (quoted from support.claude.com and the docs). Chat: conversations that can "search through your previous conversations" and "remember context from your chats" (the "Search and reference chats" and "Generate memory from chats" settings; memory is on by default on Free, Pro and Max, excludes chats inside projects). Chat works in an isolated sandbox: it creates files and artifacts you download, but can't read or edit files on your computer. Projects: "self-contained workspaces with their own chat histories and knowledge bases." Artifacts: "anything Claude makes for you that you'd put in front of someone: a design, a deck, a document, a dashboard, or a small interactive tool." Cowork: "the same agentic architecture that powers Claude Code, with no terminal required"; it takes on multi-step tasks and executes them, reading and writing local files, with connectors and scheduled tasks. Claude Code: "an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools" (Class 3). Managed Agents: a "pre-built, configurable agent harness that runs in managed infrastructure" (today and Class 2). The distinction to land: a project is a workspace; an artifact is a finished thing Claude produces for you to share. (Chat vs Cowork is on the cards: Chat makes things for you to download; Cowork works on your actual files.) Anthropic is rolling out a merged Chat-and-Cowork experience, so a student may see them as one conversation; if so, explain the difference as "making things for you" versus "working in your files and accounts," which still holds. Don't turn this into a feature tour; the point is choosing the right home for a job.

## Slide 5 · Why Managed Agents

**What the student sees on this slide:**

_Same brief, more control_

## Managed Agents shows every part Cowork hides.

Cowork hides the machinery so you don't have to think about it. Managed Agents lays every part out as a field you set. The brief is the same idea; what changes is that you can see and control every piece.

_⏰ Exact schedules_

To the minute, on any pattern: weekdays at 7:00, the first Monday of the month.

_💵 A hard cap per run_

A run that goes wrong pauses at your limit instead of spending more.

_🔌 Any service you can connect_

Any app with an MCP server or an API key, not only the ones in a directory.

_🔍 Every run on the record_

The full transcript of each run: what it read, what it called, what it cost.

 ⚖️

The trade: it's billed separately from your Claude plan, by usage, and setup takes more clicks. For a daily brief, expect a few dollars a month.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

The four things they get that Cowork doesn't expose: exact cron schedules, a hard dollar cap per run, any service with a remote MCP server or an API key, and a full session transcript per run. Be honest about the trade: it's a separate Console account billed by usage (not their Claude plan), and setup takes more clicks. A daily brief on a Sonnet model is roughly a few dollars a month; don't promise a precise figure.

## Slide 6 · The key question

**What the student sees on this slide:**

_What makes it an automation_

## Dictate the steps. Keep one judgment call.

An automation's steps are dictated : the agent follows them and doesn't choose. You've taken its autonomy away, on purpose. And here each fixed step can take a stronger form than a sentence:

 1 · Pull your sources
 🎯 Exact tool call Pull tasks due today or overdue — one named tool, a fixed filter.
 🎯 Exact tool call Pull today's calendar — one named tool, today's date. Nothing to choose.
 🎯 Exact tool call Read unread client email, last 24 hours — one named tool, the exact search.
 ⚙️ Script Count what's overdue, and by how many days — math in code. Same answer every run.
 2 · Decide what matters
 🧠 Judgment Decide what needs you today — no rule tells urgent from noise. This is the AI call.
 3 · Write the brief
 ⚙️ Script Date and format the brief — a template in code.
 🎯 Exact tool call Save it to Drive or Dropbox — one named tool, the same folder every day.

 🎯

Tool calls reach your apps, a script does the computing, judgment decides only what no rule can. Counting, dates and formatting belong in code: the same result every run, for almost nothing. You won't write it: Claude does.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

The core concept, taught one level deeper than the Beginner track. An automation's steps are DICTATED: the agent follows them and doesn't choose, so its autonomy is taken away on purpose. (Not "the steps are taken away"; the steps are fully specified and the agency is removed.) Every fixed step is dictated; what differs is who carries it out. Exact tool calls reach the apps: one named MCP tool with fixed inputs, to read a source or save the brief; Claude makes the call, but there is nothing to decide. A script does the pure computing: counting, date math, formatting, where code gives the same answer every run for almost nothing and can be tested. Judgment is used only where no rule can decide, which is "what needs me today." The student does not write code; Claude writes the script. Don't frame code as always better than a tool call: a script reaching an app needs its own API token and access set up (see the vault), while an MCP tool call is the normal way to reach an app. A script calling an API is the fallback for an app with no MCP server.

## Slide 7 · The parts

**What the student sees on this slide:**

_What you'll set up, in Cowork terms_

## Six parts, and what each one was in Cowork .

 🧩 Skill

Your dictated steps: instructions plus the script. Cowork: the task's steps.

 🤖 Agent

The model, what matters to you, and the tools it may use. Cowork: the project and its instructions.

 🔌 MCP servers & APIs

The connections to your apps: an MCP server, or the app's API through a script. Cowork: connectors.

 🔐 Credential vault

Your logins and keys; the agent uses them without seeing them. Cowork: signing in.

 📦 Environment

The cloud computer each run gets. Cowork: handled for you.

 ⏰ Deployment

The schedule, the prompt it runs, the cap per run. Cowork: the scheduled task.

Every run creates a session : the record of that run, which you can open and read line by line.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Map each Managed Agents object to what they know from Cowork, so nothing feels foreign: skill = the task's steps; agent = the project and its instructions (model, system prompt, tools); MCP servers and APIs = connectors (an MCP server is the usual connection; an app with no MCP server is reached through its API from the script, with its token in the vault); credential vault = signing in to a connector; environment = the cloud computer each run gets (Cowork handles this invisibly); deployment = the scheduled task. A session is the record of one run. If a student wants to know where memory stores fit, say they come in Class 2.

## Slide 8 · Before you start

**What the student sees on this slide:**

_Prerequisite · do this before class_

## Open a Claude Console account, separate from your plan.

- 1. Sign in at platform.claude.com , the Claude Console. It's a separate account from your Claude app plan.

- 2. Add a card, buy $10 of credits, and leave auto-reload off . $10 covers a month or more of daily briefs.

- 3. Find Managed Agents in the sidebar. It's on for every account.

 💵

You pay for what runs: the model's usage plus $0.08 for every hour a run is working. A brief takes a few minutes, so it's a few dollars a month.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

This slide is the class PREREQUISITE: students do it before class (it is listed on the course page). In class, only confirm it: they can sign in to the Console, credits are loaded, and Managed Agents shows in the sidebar. If a student arrives without it, get the account and credits done first; nothing else in the build works without it. The Console is a separate account from the Claude app plan: platform.claude.com, a card on file, $10 of prepaid credits with auto-reload left off (the hard ceiling from the next slide). Managed Agents is enabled by default for API accounts (it's beta, no waitlist). Pricing: model tokens at API rates plus $0.08 per session-hour, counted only while a run is working. Viewing session transcripts needs the Developer or Admin role in the workspace; on a personal account they are the admin. If a student handles sensitive client data, mention that Managed Agents isn't covered by zero-data-retention agreements, and let them decide what to connect.

## Slide 9 · Cost control

**What the student sees on this slide:**

_Read this before anything runs_

## Cap the spend before the first run .

People really do wake up to four-figure API bills. It's rarely one expensive run. It's a cheap run repeated thousands of times: a schedule typed wrong, an agent stuck retrying, a key someone else found. So you set limits at three levels before anything runs.

_⏱️ Per run_

Quickstart sets $5 ; lower it to $1 on the deployment's page. At the cap, the run pauses. You do it in Step 6.

_📅 Per month_

A spend limit on your workspace . Hit it and the workspace stops.

_🧱 The hard ceiling_

Prepaid credits, auto-reload off. When they run out, everything stops. Nothing can spend money you haven't put in.

 ⚠️

The typo that costs you: * 7 * * 1-5 means every minute from 7:00 to 7:59: 60 runs a morning . Once at 7:00 is 0 7 * * 1-5 . Always read the upcoming runs the Console shows you.

One more reason to start simple: Cowork runs on your Claude subscription, not the API , so there's no bill to cap. If a Cowork project can do the job, run it there. Reach for Managed Agents when you need what only it gives you.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Cost control is a thread through every Advanced class; this is where it starts, before anything runs. The fear is real: people do wake up to four-figure API bills. The cause is almost never one expensive run; it's a cheap run multiplied: a cron typo, an agent retrying in a loop, a leaked key. Three levels of limits, set before the first run: per run (the deployment budget: Quickstart sets it at $5; they lower it to $1 on the deployment's page in the Console; it pauses the run at the cap), per month (a spend limit on the Console workspace), and the hard ceiling (prepaid credits with auto-reload off, so nothing can spend money that wasn't loaded). Walk them through finding the workspace spend limit and the auto-reload setting in the current Console; search the docs if the screens have moved. The concrete trap: `* 7 * * 1-5` is every minute from 7:00 to 7:59, sixty runs a morning; `0 7 * * 1-5` is once at 7:00. Always read the upcoming runs the Console lists. Close on the through-line of the Advanced track, simplicity and cost control: Cowork runs on the Claude subscription, not the API, so it has no usage bill to cap. If a Cowork project can do a job, that is the better home; Managed Agents is for when they need what only it offers (exact schedules, per-run caps, any API, inspectable runs). The same rule carries to Class 3: use the simplest deployment that does the job. Other cost levers worth naming if asked: a Sonnet model instead of Opus, scripts instead of model reasoning for fixed steps, pulling only what the brief needs, web searches ($10 per 1,000), and scheduling no more often than the job needs.

## Slide 10 · Step 1 · Describe it

**What the student sees on this slide:**

_Quickstart maps it with you, then drafts it_

## Step 1: Describe your brief to Quickstart .

Managed Agents → Quickstart . It drafts the agent and its skill , the file where the dictated steps live. Paste:

[PROMPT — the exact text the student would paste; you can run or adapt this for their project]
> Help me build a skill called morning-briefing, and an agent that runs it. First interview me: which tools I want it to read (help me pick three to start) and, for each, exactly what to pull so it's the same every morning. Then sort every step: exact tool call (one named MCP tool with fixed inputs, to read from or save to my apps), script (code for counting, dates and formatting), or judgment. Only "what needs me today" is judgment. If an app has no MCP server, a script can call its API with a personal token. The brief: what needs me today and why, my day in order, who's waiting on me, what you skipped, each item linked to its source. Say at the top if a source failed; on a quiet day, write "all clear." Save it to my [Google Drive / Dropbox] folder, dated. Write the skill's steps in order, with the script alongside. Then list every MCP server, API token, package, and website it needs.

_✋ You should end up with four things_

- The skill , with every step dictated and only one judgment step.

- The script , doing the counting, dates and formatting.

- A system prompt that says what matters to you.

- The list : servers, tokens, packages, websites. You'll use it in Steps 3 and 4.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

The whole build starts in the Console: Managed Agents → Quickstart, where the student pastes the prompt and Quickstart interviews them and drafts the agent and its skill. Coach the interview, not the code: which three sources, and exactly what to pull from each so it's the same every morning. Push for exact rules ("unread from clients, last 24 hours"), not vague ones ("check my email"). Check the output: a skill named morning-briefing (lowercase, hyphens, no "claude" or "anthropic") with every step in order, tagged exact tool call / script / judgment, and only one judgment step (tool calls to reach apps, the script for counting, dates and formatting); the script alongside it; a system prompt saying what matters to them; and the list of MCP servers, API tokens, packages and websites, used in the vault and environment steps. The honesty rules (say what failed at the top; write "all clear" on a quiet day) belong in the skill. If Quickstart doesn't produce the skill and script itself in their Console, check the current docs for how to add a custom skill to the workspace (custom skills can be uploaded as a zip or files) and attach it to the agent. Source choice is where most trouble starts: Google's official Gmail, Calendar and Drive MCP servers are a Developer Preview that needs a Google Cloud project and an OAuth client, which is heavy for this audience. Services with simple OAuth MCP servers (Slack, Notion, and others) are much easier. Search for the service's current remote MCP server before promising one. Start with three sources or fewer.

## Slide 11 · Step 2 · The agent

**What the student sees on this slide:**

_Quickstart fills in the fields; you check them_

## Step 2: Check every field Quickstart filled in.

- Model : a Sonnet model is plenty for a daily brief, at about half the cost of Opus.

- System prompt : what "matters" means to you. "Flag anything from a client or due today. Skip newsletters." This is the judgment step's rulebook.

- MCP servers : every server on the list.

- Skills : morning-briefing is attached, with its script.

 🧩

Why a skill, not a long prompt: the agent loads it only when it's needed, and the script runs as code, so only its output reaches Claude . Want a different brief later? Change the skill; the agent and the schedule stay.

Next class you'll build an agent through Create agent , field by field. Today, Quickstart is enough.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Quickstart fills in the agent's fields; the student checks each rather than trusting the draft: model (a Sonnet model is plenty and cheaper than Opus), system prompt (what "matters" means to them; the judgment step's rulebook, equivalent to Cowork project instructions), MCP servers (every one on the list; their permissions are set after the test run, on Step 7 (permissions)), and the morning-briefing skill attached with its script. Why a skill rather than a long prompt: it loads only when needed, and the script runs as code with only its output entering context. Changing the brief later means changing the skill; the agent and deployment stay. If a field is wrong, they edit the agent. Create agent, the field-by-field form, is Class 2's opener; don't teach it in depth today.

## Slide 12 · Step 3 · The environment

**What the student sees on this slide:**

_The computer each run borrows_

## Step 3: Set the packages and websites each run gets.

Every run gets a fresh cloud computer, called the environment . Two settings matter, and both come straight from the list:

_📦 Packages_

Add the ones the script needs. They're installed before the run starts, and kept ready for the next one.

_🌐 Networking_

Choose limited , add only the websites on the list, and allow access to your MCP servers. The script can reach what you named and nothing else.

Nothing on that computer survives the run. That's why the brief is saved to Drive or Dropbox, not left behind.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Each run gets a fresh cloud sandbox configured by the environment. Two settings: packages (pip and others) the script needs, installed before the run and cached; networking, where limited means only listed hosts plus an allow-MCP-servers switch and an allow-package-managers switch. Environments made in the Console may default to limited, which is the usual cause of "host blocked" errors: add the host, or enable MCP server access. Nothing in the sandbox survives the run, which is why the brief is saved to Drive or Dropbox.

## Slide 13 · Step 4 · The vault

**What the student sees on this slide:**

_Access to your apps, kept out of sight_

## Step 4: Connect each app; the vault holds its login.

For each MCP server, the Console asks: Authorization required · Add credential for [app] . The login is saved in a credential vault (Managed Agents → Credential vaults), where the agent can use it without ever seeing it.

_✅ Most apps: just Connect_

Both fields are optional . Leave them empty, tick the acknowledgment, click Connect , and sign in on the app's own page.

_🔧 Only if Connect fails_

Access token: one you get from the app; it expires, so it's a stopgap. Client ID and secret: from an app you register with the provider (for Google, in Google Cloud Console). Ask Claude to walk you through it.

_🔑 An app with no MCP server_

Add its API token as a secret, under the name the script expects. The real key is swapped in only as the request leaves.

 🛡️

The vault is shared across your workspace. Anyone with an API key for it can use these logins, so keep the workspace to yourself. And keys go in the vault only: never in a chat, a skill, or a prompt.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

When an agent has an MCP server that needs a login, the Console shows "Authorization required to use this MCP · Add credential for [app]" with two OPTIONAL sections, Access token and OAuth client credentials (Client ID, Client secret), a workspace-sharing warning with an acknowledgment checkbox, and Connect / Skip for now. The default path: leave both fields empty, tick the acknowledgment, click Connect, and sign in on the app's own page; Anthropic stores the result in a credential vault (also reachable under Managed Agents → Credential vaults) and refreshes OAuth tokens. Only if Connect fails: an access token is one issued by the app itself, pasted in, and it expires, so it's a stopgap; OAuth client credentials come from registering your own OAuth app with the provider (for Google: Google Cloud Console → APIs & Services → Credentials → OAuth client ID, with the relevant APIs enabled; Google's Workspace MCP servers are a Developer Preview and may require this). Walk them through it step by step if needed, searching the provider's current docs. For an app with no MCP server, the script's API token is added as an environment-variable secret under the name the script expects; the run holds only a placeholder and the real secret is substituted as the request leaves the sandbox, so the agent never sees it (the script must send the token as-is in a header; Console-created credentials inject into headers only unless body injection is enabled; the credential's allowed hosts and the environment's networking must both allow the host). The warning matters: credentials are shared across the workspace, and anyone with an API key for that workspace can use them to read data and act as the credential owner. Advise a workspace only they use, and never sharing its API keys. Hold the line firmly: keys go only in the vault. If a student starts to paste a key into a chat (including to you), stop them and redirect to the vault.

## Slide 14 · Step 5 · Prove it

**What the student sees on this slide:**

_Don't assume: run it, read it, fix it_

## Step 5: Test-run it in the panel and debug it.

Once the logins are in, a test run opens in the panel next to your agent. Watch it, change the config where something's off, and run it again until it's right. This is the part Cowork doesn't show you.

- 1. Watch the transcript → the skill loads, the script runs, each tool call goes out and comes back.

- 2. Check the judgment → does "needs you today" look right? Fix the system prompt, not the brief.

- 3. Open Drive or Dropbox → is today's brief really there? "Saved" in a transcript isn't a file you can open.

- 4. Read the cost → the session shows what this run cost. Multiply by 22 weekdays: that's your monthly bill.

 ✅

A brief in your folder, and a transcript that shows every step. Now put it on a schedule.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

After the logins are added in Step 4, a test run opens in the panel beside the agent's configuration: they can watch it live, change the config (system prompt, tools, skill, permissions) and run it again. Treat it as a debugging loop, not a one-shot check. Four checks: the transcript shows the dictated steps in order (skill loads, script runs, each tool call goes out and comes back); "needs you today" looks right (fix the system prompt, not the brief); the file is really in Drive or Dropbox (a tool call that says "saved" isn't the same as a file existing); and the run's cost, shown on the session, times about 22 weekdays is roughly their monthly bill. If that number surprises them, fix it now (model, how much it reads) before it's on a schedule. MCP tools still on always ask will pause the test run for approval; that's fine while they're watching. After scheduling, Step 7 (permissions) sets them so an unattended run never pauses. Common failures to read for in the transcript: a blocked host, a missing package, or a vault credential that doesn't match the server URL.

## Slide 15 · Step 6 · Schedule it

**What the student sees on this slide:**

_The timer that pulls the trigger_

## Step 6: Deploy it on a schedule, with a cap .

Managed Agents → Deployments → new deployment. Fill it in:

- Agent, environment, vault : the ones you just made.

- Schedule : 0 7 * * 1-5 (weekdays at 7:00) and your time zone.

- Prompt : "Run the morning-briefing skill exactly as written."

- Budget : Quickstart sets $5 per run. Lower it to $1 on the deployment's page. At the cap, the run pauses instead of spending more.

 ▶️

Check the upcoming runs are the ones you meant. The Console shows the next few; a scheduled run can start up to 9 minutes late. Don't click Run now yet: one setting first.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Deployments (Managed Agents → Deployments) bind agent, environment and vault to a cron schedule and time zone, with a prompt sent at each run and an optional budget copied onto every run. Quickstart sets the per-run budget at $5.00; have them lower it to $1 on the deployment's page. Cron is five fields: minute, hour, day of month, month, day of week; `0 7 * * 1-5` is weekdays at 7:00. The Console validates it and shows upcoming runs. Runs can start up to 9 minutes late (jitter). Avoid 1 to 3am because of daylight-saving changes. The budget is a hard cap: at the cap the run pauses (budget reached) rather than being killed, and raising the cap resumes it. Have them read the upcoming runs to confirm the schedule means what they think (the cost-control slide's cron typo). Hold Run now until the next slide: with MCP tools still on always ask, an unattended run would pause and never finish. Confirm the current form fields in the Console before directing them.

## Slide 16 · Step 7 · Permissions

**What the student sees on this slide:**

_Permissions for a run nobody attends_

## Step 7: Set the permissions for unattended runs.

Every tool the agent can use gets a permission policy. Built-in tools start at always allow . Tools from your MCP servers start at always ask , and a scheduled run that asks waits forever. The brief never arrives. In the test run you were there to approve each one; at 7am you won't be.

_🔒 The three policies_

Always allow: it just runs. Always ask: it pauses for you. Auto: Claude decides call by call, and can still pause.

_✋ What to set today_

Always allow for the reading tools your skill names, plus the one tool that saves the brief. Turn off every other tool that writes, sends, or deletes.

 🛡️

Turning a tool off is the lock: the agent can't call it at all. Then go back to your deployment and click Run now once, to prove a run finishes with nobody watching.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

The permission teach, specific to unattended runs. Built-in tools default to always allow; MCP toolsets default to always ask; an always-ask call in a scheduled run pauses the session indefinitely (idle, requires action), so the brief never arrives. Auto lets the server decide per call and can still pause, so it isn't safe unattended either. What to set: always allow for the reading tools the skill names and the one save tool; turn off every other write, send or delete tool. There is no "never" policy: turning a tool off (disabling it on the agent) is the lock, and the agent can't call it at all. Contrast with a prompt instruction, which is a request. Finish with Run now on the deployment: the first run with nobody approving anything, which proves the settings hold. If it stalls, look in the session for a tool call waiting on approval.

## Slide 17 · When it breaks

**What the student sees on this slide:**

_Your best debugging tool_

## When a brief breaks, the session shows you where.

Managed Agents → Sessions keeps every run: its status, its cost, and a full transcript, step by step. Every tool call with what went in and what came back, every error, and Claude's reasoning in between. It's a stack trace for your agent: find the step that went wrong, and you know what to edit.

_❌ A tool call errored_

Check the vault login for that app, or a website the environment is blocking.

_⏳ A tool call is waiting_

That tool is still on always ask. Set it in Step 7 .

_🧠 Right data, wrong call_

The judgment was off. Edit the system prompt , not the brief.

_🧩 A step skipped or done differently_

The skill wasn't exact enough. Tighten that step, or move it into the script.

 📣

The brief points you there: it names any source it couldn't reach at the top, and writes "all clear" on quiet days, so no brief means open Sessions. A run that hits its cap pauses; raise the cap to resume it.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Sessions are the most useful debugging tool in Managed Agents, so make this land. Managed Agents → Sessions lists every run with its status, agent, token usage, cost and creation time; opening one shows a timeline and the full transcript, including Claude's thinking, every tool call with its inputs and results, errors, and message text, with an inspector for cost and budget, events, tools and resources (downloadable as JSON). It works like a stack trace: find the step where it went wrong, and that tells you which part to edit. Map symptoms to fixes: a tool call that errored → the vault credential for that app (expired, or not matching the server URL) or a host the environment's networking blocks; a tool call waiting on approval → that tool is still always ask, fix in Step 7; the right data but the wrong call about what matters → the system prompt; a step skipped or done differently → the skill wasn't exact enough, so tighten the step or move it into the script. Coach them to read the run before changing anything, and to change one thing and run again. The brief's own honesty rules point them to Sessions: a source it couldn't reach is named at the top, and it writes "all clear" on quiet days, so a missing brief means something broke. A run that hits its budget pauses (budget reached) and resumes if the cap is raised; a deployment whose run can't start (for example an archived vault or environment) pauses itself, and missed runs aren't made up. Viewing sessions needs the Developer or Admin role in the workspace.

## Slide 18 · Homework

**What the student sees on this slide:**

_Your homework · do it this week_

## Add a source, and tune the brief until you'd read it daily.

_➕ Add at least one source_

The one that makes the brief genuinely yours. Same pattern as today: add its MCP server to the agent, connect it in the vault, add its step to the skill, set its permission, then test-run it.

_🎯 Make it useful_

Read it every morning. When it flags the wrong thing, fix the system prompt . When it misses something or reads badly, fix the skill . Check the session first so you fix the right part.

 🎓

Next class, an agent acts on this brief, so it's worth getting right. The calls are yours: which sources matter, and what "needs me today" means. Claude handles the how.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Two goals for the week, both about making the brief genuinely useful to them. Add at least one source that makes it theirs, using the same pattern as class: add its MCP server to the agent, connect it in the vault (Connect, sign in), add its step to the skill, set its tool permission to always allow, then test-run it. And tune it by reading it every morning: when it flags the wrong things, the fix is the system prompt (what matters); when it misses something, pulls the wrong thing or reads badly, the fix is the skill (what it pulls, the brief's sections and format). Have them open the session before changing anything, so they fix the right part. Why it matters: in Class 2 an agent acts on this brief, so a brief they trust is the foundation. Help fully with the mechanics; the choices (which sources, what "needs me today" means) are theirs.

## Slide 19 · You shipped it

**What the student sees on this slide:**

_That's the class — here's what now runs_

## Your brief: dictated, scheduled, capped, on the record.

- A skill : dictated steps, code for the computing, one judgment call.

- Logins in a vault the agent uses but never sees.

- Tools allowed or turned off , so no run waits on a click.

- A deployment on an exact schedule, with a record of every run.

- Spend capped per run, per month, and by the credits you loaded .

 🧠

Next class, an agent acts on this brief. This automation keeps running as it is. You build a second part, an agent, that picks up the brief each morning and does what it allows.

An automation has its steps dictated. An agent chooses its own. Keeping them as separate parts means you can change one without touching the other.

**Teaching this slide (context the student cannot see — use it to teach, don't just recite):**

Recap: a skill with dictated steps (tool calls to reach apps, code for the computing, one judgment call), logins in a vault the agent never sees, tools set to always allow or turned off so unattended runs never stall, a deployment with an exact schedule and a record of every run, and spend capped at three levels: per run, per month on the workspace, and by the prepaid credits. The bridge to Class 2: this automation keeps running as it is, and they build a second part, an agent in Create agent, that picks up the brief each morning and acts within limits they set. The line to leave them with: an automation has its steps dictated; an agent chooses its own; keeping them separate means each can be changed without touching the other.
