diff --git a/authors.yaml b/authors.yaml index 55759e7b..f12c7268 100644 --- a/authors.yaml +++ b/authors.yaml @@ -21,10 +21,17 @@ benlehrburger-ant: Briiick: name: Alexander Bricken avatar: https://avatars.githubusercontent.com/u/44481408?v=4 +charmaine: + name: Charmaine Lee + website: https://github.com/charmaine + avatar: https://avatars.githubusercontent.com/u/16736130?v=4 davidhershey: name: David Hershey website: https://github.com/davidhershey avatar: https://avatars.githubusercontent.com/u/11651858?v=4 +gaganb-ant: + name: Gagan Bhat + avatar: https://avatars.githubusercontent.com/u/235440171?v=4 GarvanD: name: Garvan Doyle website: https://garvandoyle.com @@ -55,13 +62,25 @@ jsham042: name: Joe Shamon website: https://github.com/jsham042 avatar: https://github.com/jsham042.png +jyan-anthropic: + name: Jess Yan + website: https://github.com/jyan-anthropic + avatar: https://avatars.githubusercontent.com/u/235391680?v=4 maheshmurag: name: Mahesh Murag website: https://github.com/maheshmurag avatar: https://avatars.githubusercontent.com/u/5667029?v=4 +markn-ant: + name: Mark Nowicki + website: https://github.com/markn-ant + avatar: https://avatars.githubusercontent.com/markn-ant nadine-anthropic: name: Nadine Yasser avatar: https://avatars.githubusercontent.com/u/238355370?v=4 +pauly-ant: + name: Paul Yang + website: https://github.com/pauly-ant + avatar: https://avatars.githubusercontent.com/u/269031447?v=4 PedramNavid: name: Pedram Navid website: http://x.com/pdrmnvd diff --git a/managed_agents/.env.example b/managed_agents/.env.example new file mode 100644 index 00000000..63ed6f4d --- /dev/null +++ b/managed_agents/.env.example @@ -0,0 +1,21 @@ +ANTHROPIC_API_KEY=sk-ant-... + +# Populated from data_analyst_agent.ipynb output; consumed by slack_data_bot.ipynb +ANALYST_ENV_ID=env_... +ANALYST_AGENT_ID=agent_... +ANALYST_AGENT_VERSION=... + +# For slack_data_bot.ipynb +SLACK_BOT_TOKEN=xoxb-... +SLACK_APP_TOKEN=xapp-... + +# Required for the GitHub MCP sidebar in CMA_orchestrate_issue_to_pr.ipynb +# and the vault-backed MCP credentials in CMA_operate_in_production.ipynb +GITHUB_TOKEN=ghp_... + +# Optional — override the default model used by the CMA_ tutorials +COOKBOOK_MODEL=claude-sonnet-4-6 + +# For sre_incident_responder.ipynb (production wiring only) +DD_API_KEY= +DD_APP_KEY= diff --git a/managed_agents/.gitignore b/managed_agents/.gitignore new file mode 100644 index 00000000..900aab5e --- /dev/null +++ b/managed_agents/.gitignore @@ -0,0 +1,4 @@ +report.html +__pycache__/ +*.pyc +.env diff --git a/managed_agents/CMA_explore_unfamiliar_codebase.ipynb b/managed_agents/CMA_explore_unfamiliar_codebase.ipynb new file mode 100644 index 00000000..73651383 --- /dev/null +++ b/managed_agents/CMA_explore_unfamiliar_codebase.ipynb @@ -0,0 +1,304 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1ff5d825", + "metadata": {}, + "source": [ + "# Explore: grounding in an unfamiliar codebase\n", + "\n", + "This notebook drops the agent into a repository it's never seen\n", + "before and asks it to figure out the real architecture. The\n", + "filesystem is the agent's only workspace, and only the files it\n", + "chooses to read end up in its context window, so exploration with\n", + "`ls`, `grep`, and `read` is how it builds up a mental model.\n", + "\n", + "The interesting part is a trap we've planted in the fixture.\n", + "`ARCHITECTURE.md` describes a layout that the code no longer\n", + "follows, so an agent that trusts the docs without checking the\n", + "code will confidently give the wrong answer. Grounding, in this\n", + "context, means verifying what you read against what's actually\n", + "there rather than treating documentation as authoritative.\n", + "\n", + "What this teaches beyond the iterate notebook:\n", + "\n", + "- **Exploration before action.** A good agent reads enough of the\n", + " tree to understand it, then answers, not the other way around.\n", + "- **Adding resources mid-session.** The sidebar at the end shows\n", + " how to push more files into a running session via\n", + " `sessions.resources.add` rather than re-creating the session.\n", + " Useful when exploration uncovers something the agent should\n", + " look at next." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b36209d4", + "metadata": {}, + "outputs": [], + "source": [ + "import io\n", + "import os\n", + "\n", + "from anthropic import Anthropic\n", + "from utilities import (\n", + " make_unfamiliar_repo_zip,\n", + " stream_until_end_turn,\n", + " wait_for_idle_status,\n", + ")\n", + "\n", + "MODEL = os.environ.get(\"COOKBOOK_MODEL\", \"claude-sonnet-4-6\")\n", + "\n", + "client = Anthropic()" + ] + }, + { + "cell_type": "markdown", + "id": "98ab21e5", + "metadata": {}, + "source": [ + "## 1. Generate the repo fixture\n", + "\n", + "The repo is small enough that we build it in memory with a helper\n", + "rather than keeping a disk fixture alongside the notebook. The\n", + "helper plants a `services/` microservices layout and a stale\n", + "`ARCHITECTURE.md` that still describes the old monolithic layout." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "108bd220", + "metadata": {}, + "outputs": [], + "source": [ + "buf = make_unfamiliar_repo_zip()\n", + "fixture_zip = client.beta.files.upload(file=(\"repo.zip\", buf, \"application/zip\"))\n", + "print(f\"fixture: {fixture_zip.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1c2ba40f", + "metadata": {}, + "source": [ + "## 2. Agent + environment + session" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "faf4808b", + "metadata": {}, + "outputs": [], + "source": [ + "agent = client.beta.agents.create(\n", + " name=\"cookbook-explore\",\n", + " model=MODEL,\n", + " system=(\n", + " \"You are onboarding to an unfamiliar codebase. Explore before \"\n", + " \"answering, docs can be stale. Verify what you read against \"\n", + " \"actual code structure. Write notes to /tmp/NOTES.md as you go.\"\n", + " ),\n", + " tools=[\n", + " {\n", + " \"type\": \"agent_toolset_20260401\",\n", + " \"default_config\": {\n", + " \"enabled\": True,\n", + " \"permission_policy\": {\"type\": \"always_allow\"},\n", + " },\n", + " }\n", + " ],\n", + ")\n", + "\n", + "env = client.beta.environments.create(\n", + " name=\"cookbook-explore-env\",\n", + " config={\"type\": \"cloud\", \"networking\": {\"type\": \"limited\"}},\n", + ")\n", + "\n", + "session = client.beta.sessions.create(\n", + " environment_id=env.id,\n", + " agent={\"type\": \"agent\", \"id\": agent.id, \"version\": agent.version},\n", + " resources=[{\"type\": \"file\", \"file_id\": fixture_zip.id, \"mount_path\": \"repo.zip\"}],\n", + " title=\"Onboard to repo\",\n", + ")\n", + "print(f\"session: {session.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2710d8a0", + "metadata": {}, + "source": [ + "## 3. Explore and watch for the stale-doc trap\n", + "\n", + "A grounded answer mentions the real `services/` layout and flags\n", + "`ARCHITECTURE.md` as out of date. An ungrounded answer parrots\n", + "the monolith layout the stale doc describes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a8acee26", + "metadata": {}, + "outputs": [], + "source": [ + "client.beta.sessions.events.send(\n", + " session_id=session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.message\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": (\n", + " \"Unzip /mnt/session/uploads/repo.zip to /tmp/repo/. \"\n", + " \"Then: what is the actual architecture of this \"\n", + " \"codebase? Be specific about directory structure. \"\n", + " \"Check if the docs are accurate.\"\n", + " ),\n", + " }\n", + " ],\n", + " }\n", + " ],\n", + ")\n", + "\n", + "print(\"=== exploration ===\")\n", + "stream_until_end_turn(client, session.id)" + ] + }, + { + "cell_type": "markdown", + "id": "28aea9a1", + "metadata": {}, + "source": [ + "## 4. Read back the agent's notes\n", + "\n", + "The agent was told to keep notes in `/tmp/NOTES.md` as it worked.\n", + "Printing that file is a useful way to see how its understanding\n", + "of the codebase developed during exploration." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "90943a95", + "metadata": {}, + "outputs": [], + "source": [ + "client.beta.sessions.events.send(\n", + " session_id=session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.message\",\n", + " \"content\": [{\"type\": \"text\", \"text\": \"cat /tmp/NOTES.md\"}],\n", + " }\n", + " ],\n", + ")\n", + "stream_until_end_turn(client, session.id)" + ] + }, + { + "cell_type": "markdown", + "id": "31d28889", + "metadata": {}, + "source": [ + "## Sidebar: adding more context to a running session\n", + "\n", + "The `resources=` argument on `sessions.create` is the most common\n", + "way to mount files, but the API also exposes a\n", + "`/v1/sessions//resources` sub-resource for managing mounts on\n", + "an existing session. This is useful here: if exploration uncovers\n", + "a question that needs additional context (a config file, a\n", + "changelog, an external schema), you can drop it in without\n", + "tearing down the session.\n", + "\n", + "The pattern is the same upload-then-attach loop you already know,\n", + "just split across two calls instead of one:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eeec2815", + "metadata": {}, + "outputs": [], + "source": [ + "hints = b\"# DEPLOY HISTORY\\n2026-03-01: monolith -> microservices migration complete\\n\"\n", + "hints_file = client.beta.files.upload(\n", + " file=(\"DEPLOY_HISTORY.md\", io.BytesIO(hints), \"text/markdown\")\n", + ")\n", + "\n", + "added = client.beta.sessions.resources.add(\n", + " session_id=session.id,\n", + " type=\"file\",\n", + " file_id=hints_file.id,\n", + " mount_path=\"DEPLOY_HISTORY.md\",\n", + ")\n", + "print(f\"added resource {added.id} to session {session.id}\")\n", + "\n", + "attached = client.beta.sessions.resources.list(session_id=session.id)\n", + "print(f\"{len(attached.data)} resources attached now\")\n", + "\n", + "client.beta.sessions.events.send(\n", + " session_id=session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.message\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": (\n", + " \"There's a DEPLOY_HISTORY.md in your workspace now. \"\n", + " \"Read it and tell me whether it changes anything in \"\n", + " \"your earlier answer.\"\n", + " ),\n", + " }\n", + " ],\n", + " }\n", + " ],\n", + ")\n", + "print(\"\\n--- follow-up with deploy history ---\")\n", + "stream_until_end_turn(client, session.id)\n", + "\n", + "# Detach the file now that the agent is done with it. `delete` here\n", + "# is the resource-detach verb, not the cookbook-wide archive.\n", + "client.beta.sessions.resources.delete(session_id=session.id, resource_id=added.id)\n", + "print(\"detached follow-up resource\")" + ] + }, + { + "cell_type": "markdown", + "id": "50363d78", + "metadata": {}, + "source": [ + "## Cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "358e0a02", + "metadata": {}, + "outputs": [], + "source": [ + "wait_for_idle_status(client, session.id)\n", + "client.beta.sessions.archive(session.id)\n", + "client.beta.environments.archive(env.id)\n", + "client.beta.agents.archive(agent.id)\n", + "print(\"archived\")" + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/managed_agents/CMA_gate_human_in_the_loop.ipynb b/managed_agents/CMA_gate_human_in_the_loop.ipynb new file mode 100644 index 00000000..c1012ee4 --- /dev/null +++ b/managed_agents/CMA_gate_human_in_the_loop.ipynb @@ -0,0 +1,365 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b2104434", + "metadata": {}, + "source": [ + "# Gate: human-in-the-loop with custom tools\n", + "\n", + "Many workflows sit in the gap between \"fully automate\" and\n", + "\"always ask a human.\" Expense approval is a classic example: the\n", + "agent can handle the clear cases on its own, but it should know\n", + "when to escalate ambiguous ones for human review. Calibration\n", + "matters here, an agent that escalates everything is exhausting\n", + "to work with, and an agent that escalates nothing is dangerous.\n", + "\n", + "This notebook builds an expense approver around two **custom\n", + "tools**: `decide()` for clear-cut cases and `escalate()` for\n", + "ambiguous ones. Both round-trip through your application, which\n", + "is where you either log the outcome (decide) or put it in front\n", + "of a reviewer (escalate).\n", + "\n", + "## What custom tools are\n", + "\n", + "Up until now the cookbook has used the built-in `agent_toolset`\n", + "(bash, read, write, etc.), all of which run inside the sandbox\n", + "container. **Custom tools** are different: when the agent calls\n", + "one, the session pauses and emits an `agent.custom_tool_use`\n", + "event, your application sees the call, runs whatever code you\n", + "want, and POSTs back a `user.custom_tool_result` event. The\n", + "session resumes with that result in the agent's context.\n", + "\n", + "This is the right shape for two situations:\n", + "\n", + "1. **The data lives somewhere the sandbox can't reach.** Anything\n", + " behind your own network boundary. The agent calls back into\n", + " your application via the round-trip.\n", + "2. **You want a human in the loop, or your own audit and approval\n", + " layer in front of every call.** That's what this notebook does:\n", + " `decide` and `escalate` aren't just \"tools\" in the abstract,\n", + " they're the seam where your business logic and human reviewers\n", + " take over from the agent.\n", + "\n", + "(The other extension patterns, MCP toolsets and `resources=`\n", + "repo mounts, are covered in the operate notebook and the orchestrate notebook\n", + "respectively.)\n", + "\n", + "The notebook has two parts. Part A drives the session by\n", + "streaming events locally and responding to each custom tool call\n", + "as it arrives, convenient during development because everything\n", + "happens in one process and you can see the behavior live. Part B\n", + "is a short pointer to the production webhook pattern, which is\n", + "walked through end-to-end in the operate notebook.\n", + "\n", + "The fixture lives in `example_data/gate/` and contains a\n", + "`policy.yaml` plus twelve receipts that exercise every branch of\n", + "the policy." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7049f033", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "from collections import Counter\n", + "from pathlib import Path\n", + "\n", + "from anthropic import Anthropic\n", + "from utilities import wait_for_idle_status\n", + "\n", + "MODEL = os.environ.get(\"COOKBOOK_MODEL\", \"claude-sonnet-4-6\")\n", + "\n", + "client = Anthropic()\n", + "FIXTURE = Path(\"example_data\") / \"gate\"" + ] + }, + { + "cell_type": "markdown", + "id": "9744e40d", + "metadata": {}, + "source": [ + "## 1. Upload policy and receipts" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65e3620e", + "metadata": {}, + "outputs": [], + "source": [ + "policy = client.beta.files.upload(\n", + " file=(\"policy.yaml\", (FIXTURE / \"policy.yaml\").read_bytes(), \"text/yaml\")\n", + ")\n", + "receipts = client.beta.files.upload(\n", + " file=(\n", + " \"receipts.jsonl\",\n", + " (FIXTURE / \"inbox\" / \"receipts.jsonl\").read_bytes(),\n", + " \"application/jsonl\",\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "cf82321c", + "metadata": {}, + "source": [ + "## 2. Define the agent with two custom tools\n", + "\n", + "Custom tools are declared in the same `tools=` array as the\n", + "built-in toolset, with `\"type\": \"custom\"` and a JSON schema for\n", + "the input. Each declaration tells the model what the tool is for\n", + "(`description`), what to call it with (`input_schema`), and what\n", + "its name is. The agent decides when to call them; your code\n", + "decides what they do when called.\n", + "\n", + "Here we keep the built-in `agent_toolset_20260401` enabled too,\n", + "so the agent can read the policy file and the receipts inline.\n", + "`decide` and `escalate` are the two custom tools that make every\n", + "decision a round-trip." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6a2e173f", + "metadata": {}, + "outputs": [], + "source": [ + "agent = client.beta.agents.create(\n", + " name=\"cookbook-gate\",\n", + " model=MODEL,\n", + " system=(\n", + " \"You are an expense approver. Read each receipt in \"\n", + " \"receipts.jsonl against the policy in policy.yaml and make \"\n", + " \"exactly ONE tool call per receipt. Call decide(receipt_id, \"\n", + " \"action, reason) for clear cases, or escalate(receipt_id, \"\n", + " \"question) for ambiguous ones (near thresholds, unclear \"\n", + " \"categories, suspicious notes). Once you've called decide \"\n", + " \"or escalate for a given receipt, that receipt is finalized \"\n", + " \"— do not call either tool for it again. After processing \"\n", + " \"all receipts exactly once, stop.\"\n", + " ),\n", + " tools=[\n", + " {\n", + " \"type\": \"agent_toolset_20260401\",\n", + " \"default_config\": {\n", + " \"enabled\": True,\n", + " \"permission_policy\": {\"type\": \"always_allow\"},\n", + " },\n", + " },\n", + " {\n", + " \"type\": \"custom\",\n", + " \"name\": \"decide\",\n", + " \"description\": \"Record a final approve/reject for a clear-cut receipt.\",\n", + " \"input_schema\": {\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"receipt_id\": {\"type\": \"string\"},\n", + " \"action\": {\"type\": \"string\", \"enum\": [\"approve\", \"reject\"]},\n", + " \"reason\": {\"type\": \"string\"},\n", + " },\n", + " \"required\": [\"receipt_id\", \"action\", \"reason\"],\n", + " },\n", + " },\n", + " {\n", + " \"type\": \"custom\",\n", + " \"name\": \"escalate\",\n", + " \"description\": \"Surface an ambiguous receipt for human review.\",\n", + " \"input_schema\": {\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"receipt_id\": {\"type\": \"string\"},\n", + " \"question\": {\"type\": \"string\"},\n", + " },\n", + " \"required\": [\"receipt_id\", \"question\"],\n", + " },\n", + " },\n", + " ],\n", + ")\n", + "\n", + "env = client.beta.environments.create(\n", + " name=\"cookbook-gate-env\",\n", + " config={\"type\": \"cloud\", \"networking\": {\"type\": \"limited\"}},\n", + ")\n", + "\n", + "session = client.beta.sessions.create(\n", + " environment_id=env.id,\n", + " agent={\"type\": \"agent\", \"id\": agent.id, \"version\": agent.version},\n", + " resources=[\n", + " {\"type\": \"file\", \"file_id\": policy.id, \"mount_path\": \"policy.yaml\"},\n", + " {\"type\": \"file\", \"file_id\": receipts.id, \"mount_path\": \"receipts.jsonl\"},\n", + " ],\n", + " title=\"Expense gate\",\n", + ")\n", + "print(f\"session: {session.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "af3c8d86", + "metadata": { + "lines_to_next_cell": 2 + }, + "source": [ + "## Part A: streaming locally during development\n", + "\n", + "The simplest way to drive a custom-tool agent is to stream the\n", + "session's events and react to each tool call as it arrives.\n", + "`decide` calls get logged and `escalate` calls get a simulated\n", + "human decision inline. In production you would queue the\n", + "escalation and have a real reviewer come back to it later, which\n", + "is what the operate notebook covers." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1e35af6", + "metadata": {}, + "outputs": [], + "source": [ + "def simulate_human_review(receipt_id: str, question: str) -> str:\n", + " # Real implementation would show this in a UI and await input.\n", + " # Here: reject anything the agent flags as suspicious.\n", + " return \"reject\" if \"suspicious\" in question.lower() else \"approve\"\n", + "\n", + "\n", + "# The iterate notebook factored its streaming loop out into\n", + "# `stream_until_end_turn`, and most other notebooks just import it.\n", + "# This one doesn't, because every decision the agent makes is a\n", + "# custom tool call, which means the session keeps going idle with\n", + "# `stop_reason.type == \"requires_action\"` and\n", + "# `stop_reason.event_ids` pointing at the `agent.custom_tool_use`\n", + "# events waiting for a response. We POST a `user.custom_tool_result`\n", + "# for each, let the session resume, and eventually break on a\n", + "# `session.status_idle` that arrives with `end_turn`. The helper\n", + "# only knows how to exit on `end_turn`, so we need the full loop\n", + "# here.\n", + "decisions = {} # receipt_id -> final decision record\n", + "tool_use_events = {}\n", + "responded_to = set() # event_ids we've already replied to\n", + "print(\"=== Part A: streaming ===\")\n", + "with client.beta.sessions.events.stream(session.id) as stream:\n", + " client.beta.sessions.events.send(\n", + " session_id=session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.message\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": (\n", + " \"Read /mnt/session/uploads/policy.yaml and \"\n", + " \"/mnt/session/uploads/receipts.jsonl. Process \"\n", + " \"all 12 receipts. For each receipt, make \"\n", + " \"exactly one decide() or escalate() call and \"\n", + " \"then move on to the next. When every receipt \"\n", + " \"has been processed once, stop.\"\n", + " ),\n", + " }\n", + " ],\n", + " }\n", + " ],\n", + " )\n", + " # Note on the responded_to set: when an agent emits more than 5\n", + " # parallel custom tool calls, the server returns\n", + " # `stop_reason.event_ids` as a sliding window of the next 5\n", + " # pending. Each status_idle we observe in the stream has that\n", + " # window pinned at the moment the event was emitted, but by the\n", + " # time we iterate to the next status_idle event, the server has\n", + " # already advanced past the events we just responded to. So we\n", + " # need to dedupe across status_idle events to avoid double-\n", + " # responding to the same custom tool call (which 400s).\n", + " for ev in stream:\n", + " if ev.type == \"agent.custom_tool_use\":\n", + " tool_use_events[ev.id] = ev\n", + " elif ev.type == \"session.status_idle\" and ev.stop_reason:\n", + " if ev.stop_reason.type == \"requires_action\":\n", + " for event_id in ev.stop_reason.event_ids:\n", + " if event_id in responded_to:\n", + " continue\n", + " tool_ev = tool_use_events[event_id]\n", + " name, args = tool_ev.name, tool_ev.input\n", + " receipt_id = args[\"receipt_id\"]\n", + " if name == \"decide\":\n", + " decisions[receipt_id] = {\"lane\": args[\"action\"], **args}\n", + " result = {\"recorded\": True}\n", + " elif name == \"escalate\":\n", + " human = simulate_human_review(receipt_id, args[\"question\"])\n", + " decisions[receipt_id] = {\n", + " \"lane\": \"escalated\",\n", + " \"human_decision\": human,\n", + " **args,\n", + " }\n", + " result = {\"human_decision\": human}\n", + " else:\n", + " result = {\"error\": f\"unknown tool {name}\"}\n", + " client.beta.sessions.events.send(\n", + " session_id=session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.custom_tool_result\",\n", + " \"custom_tool_use_id\": event_id,\n", + " \"content\": [{\"type\": \"text\", \"text\": json.dumps(result)}],\n", + " }\n", + " ],\n", + " )\n", + " responded_to.add(event_id)\n", + " elif ev.stop_reason.type == \"end_turn\":\n", + " break\n", + " elif ev.type == \"session.status_terminated\":\n", + " break\n", + "\n", + "wait_for_idle_status(client, session.id)\n", + "\n", + "lanes = Counter(d[\"lane\"] for d in decisions.values())\n", + "print(f\"\\n{len(decisions)} decisions: {dict(lanes)}\")\n", + "\n", + "client.beta.sessions.archive(session.id)\n", + "client.beta.environments.archive(env.id)\n", + "client.beta.agents.archive(agent.id)\n", + "print(\"archived\")" + ] + }, + { + "cell_type": "markdown", + "id": "5cd20516", + "metadata": {}, + "source": [ + "## Part B: webhooks for production\n", + "\n", + "The local streaming pattern works fine during development, but\n", + "it holds an HTTP connection open while humans think, which\n", + "doesn't scale well. The production pattern instead registers a\n", + "webhook in the Console that fires on `session.status_idled`,\n", + "which is the signal that the agent is either done or waiting on\n", + "a tool result. Your server inspects the events, puts any pending\n", + "escalation in front of a reviewer, and POSTs the\n", + "`user.custom_tool_result` back whenever the human finishes, no\n", + "long-lived connection on your side.\n", + "\n", + "The operate notebook walks through the full webhook setup end-to-end:\n", + "Console registration, HMAC signature verification, the FastAPI\n", + "handler, and the round-trip back to `events.send`. The code that\n", + "responds to the agent is identical to Part A above; only the\n", + "trigger changes (webhook push instead of streaming pull)." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/managed_agents/CMA_iterate_fix_failing_tests.ipynb b/managed_agents/CMA_iterate_fix_failing_tests.ipynb new file mode 100644 index 00000000..14e1f839 --- /dev/null +++ b/managed_agents/CMA_iterate_fix_failing_tests.ipynb @@ -0,0 +1,469 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "23aa785b", + "metadata": {}, + "source": [ + "# Iterate: do → observe → fix\n", + "\n", + "This is the entry-point notebook. You'll learn the Managed Agents\n", + "API surface by doing the most universal thing an agent does: try\n", + "something, read what happened, try again. We upload a tiny package\n", + "with two planted bugs, tell the agent to make the tests pass,\n", + "and watch it work the loop, run the tests, read the traceback,\n", + "edit the code, rerun, repeat until green.\n", + "\n", + "Along the way you'll see every API shape the rest of the cookbook\n", + "builds on: agent / environment / session, the file mount, the\n", + "event stream, and the archive call. By the end of this notebook\n", + "you'll have done everything you need to drive an agent end-to-end.\n", + "\n", + "## Concepts\n", + "\n", + "Three resources to know about:\n", + "\n", + "- **Agent**, a reusable config (model, system prompt, tools)\n", + "- **Environment**, a container template (packages, networking)\n", + "- **Session**, binds an agent and an environment, mounts any\n", + " files the agent needs, and produces an event stream\n", + "\n", + "You create an agent and an environment once and reuse them across\n", + "many sessions. Each session is one self-contained run." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "00e84e9c", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from pathlib import Path\n", + "\n", + "from anthropic import Anthropic\n", + "\n", + "MODEL = os.environ.get(\"COOKBOOK_MODEL\", \"claude-sonnet-4-6\")\n", + "\n", + "client = Anthropic()\n", + "FIXTURE = Path(\"example_data\") / \"iterate\"" + ] + }, + { + "cell_type": "markdown", + "id": "cad06d57", + "metadata": {}, + "source": [ + "## 1. Create the agent\n", + "\n", + "The system prompt is deliberately sparse. We want the agent to\n", + "figure out the iterate loop for itself rather than follow a\n", + "step-by-step script, the test output makes the task obvious\n", + "enough without further hand-holding.\n", + "\n", + "`agent_toolset_20260401` is the built-in toolset: bash, read,\n", + "write, edit, glob, grep, web_fetch, and web_search. Setting\n", + "`permission_policy` to `always_allow` lets the agent run them\n", + "without round-tripping for confirmation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d052b33a", + "metadata": {}, + "outputs": [], + "source": [ + "agent = client.beta.agents.create(\n", + " name=\"cookbook-iterate\",\n", + " model=MODEL,\n", + " system=(\n", + " \"You are a debugging agent. Your job is to make failing tests pass. \"\n", + " \"Run the tests, read the failures, fix the code, repeat until green. \"\n", + " \"Stop when every assertion passes.\"\n", + " ),\n", + " tools=[\n", + " {\n", + " \"type\": \"agent_toolset_20260401\",\n", + " \"default_config\": {\n", + " \"enabled\": True,\n", + " \"permission_policy\": {\"type\": \"always_allow\"},\n", + " },\n", + " }\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c3cc79a7", + "metadata": {}, + "source": [ + "## 2. Create the environment\n", + "\n", + "An environment is a container template. `type: cloud` runs in\n", + "Anthropic's hosted sandbox. `networking: limited` blocks\n", + "arbitrary outbound traffic, this notebook doesn't need network\n", + "access at all, so we keep it locked down." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b6ff4b8c", + "metadata": {}, + "outputs": [], + "source": [ + "env = client.beta.environments.create(\n", + " name=\"cookbook-iterate-env\",\n", + " config={\"type\": \"cloud\", \"networking\": {\"type\": \"limited\"}},\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "147d6f02", + "metadata": {}, + "source": [ + "## 3. Upload the failing tests\n", + "\n", + "Upload files through the Files API to get back IDs. We'll mount\n", + "them on the session in step 4.\n", + "\n", + "`calc.py` has two planted bugs and `test_calc.py` has three\n", + "assertions that catch them. One of the failures (`test_mean`)\n", + "is downstream of the other two, which quietly teaches the agent\n", + "not to over-fix: `mean()` calls `add` and `divide` internally,\n", + "so once those are fixed `test_mean` starts passing on its own\n", + "without any direct edit to `mean()`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c3d7642", + "metadata": {}, + "outputs": [], + "source": [ + "calc_file = client.beta.files.upload(\n", + " file=(\"calc.py\", (FIXTURE / \"calc.py\").read_bytes(), \"text/x-python\")\n", + ")\n", + "test_file = client.beta.files.upload(\n", + " file=(\"test_calc.py\", (FIXTURE / \"test_calc.py\").read_bytes(), \"text/x-python\")\n", + ")\n", + "print(f\"uploaded: {calc_file.id}, {test_file.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4e4dbf31", + "metadata": {}, + "source": [ + "## 4. Create the session\n", + "\n", + "A session binds the agent and the environment, mounts any files\n", + "the agent needs, and starts a fresh container. `resources=` is\n", + "how you put data into the container before the agent starts —\n", + "the orchestrate notebook shows how to use the same field to\n", + "clone a GitHub repo instead of mounting individual files.\n", + "\n", + "Files mount under `/mnt/session/uploads/`, which is\n", + "read-only. The agent has to copy files into a writable directory\n", + "like `/mnt/user` or `/tmp` before it can edit them, and anything\n", + "you want to retrieve later goes in `/mnt/session/outputs/`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d734dbd", + "metadata": {}, + "outputs": [], + "source": [ + "session = client.beta.sessions.create(\n", + " environment_id=env.id,\n", + " agent={\"type\": \"agent\", \"id\": agent.id, \"version\": agent.version},\n", + " resources=[\n", + " {\"type\": \"file\", \"file_id\": calc_file.id, \"mount_path\": \"calc.py\"},\n", + " {\"type\": \"file\", \"file_id\": test_file.id, \"mount_path\": \"test_calc.py\"},\n", + " ],\n", + " title=\"Get the tests green\",\n", + ")\n", + "print(f\"session: {session.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "a281c429", + "metadata": {}, + "source": [ + "## 5. Drive the agent and watch it work\n", + "\n", + "Two steps: send a `user.message` event with the task, then read\n", + "the event stream until the agent reaches `end_turn`.\n", + "\n", + "The stream is a server-sent event connection. We use it (rather\n", + "than polling, see the sidebar at the end) because the agent will\n", + "spend ~30 seconds iterating and we want to see each round live.\n", + "\n", + "Two patterns to internalize:\n", + "\n", + "1. **Open the stream first, then send.** The `with` block opens\n", + " the SSE connection; anything you `send` inside the block is\n", + " guaranteed to be observable. Sending before opening risks\n", + " losing events that fire in the race window.\n", + "2. **Exit on `session.status_idle` with `stop_reason.type ==\n", + " \"end_turn\"`.** The session goes idle any time it's waiting for\n", + " input, both at end of turn AND when a custom tool call needs\n", + " a response. `stop_reason.type` disambiguates; `end_turn` is\n", + " our exit signal. The gate notebook shows the\n", + " `requires_action` side of the same loop." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "77011c86", + "metadata": {}, + "outputs": [], + "source": [ + "with client.beta.sessions.events.stream(session.id) as stream:\n", + " client.beta.sessions.events.send(\n", + " session_id=session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.message\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": (\n", + " \"The tests in /mnt/session/uploads/test_calc.py are \"\n", + " \"failing. Copy both files into /mnt/user, iterate \"\n", + " \"on calc.py until every test passes, then write the \"\n", + " \"final calc.py to /mnt/session/outputs/calc.py. \"\n", + " \"pytest isn't installed here, run the assertions \"\n", + " \"directly with `python3 -c ...` instead.\"\n", + " ),\n", + " }\n", + " ],\n", + " }\n", + " ],\n", + " )\n", + " print(\"--- iterate loop ---\")\n", + " for ev in stream:\n", + " match ev.type:\n", + " case \"agent.message\":\n", + " for b in ev.content:\n", + " if b.type == \"text\":\n", + " print(b.text, end=\"\")\n", + " case \"agent.tool_use\":\n", + " print(f\"\\n[{ev.name}]\")\n", + " case \"session.status_idle\" if ev.stop_reason and ev.stop_reason.type == \"end_turn\":\n", + " break\n", + " case \"session.status_terminated\":\n", + " break" + ] + }, + { + "cell_type": "markdown", + "id": "f17c3bb8", + "metadata": {}, + "source": [ + "That `match ev.type:` block is the canonical streaming pattern.\n", + "Every other notebook in this cookbook imports it as\n", + "`stream_until_end_turn` from `utilities.py` instead of repeating\n", + "the loop. We use it for the verify step below.\n", + "\n", + "`wait_for_idle_status` is the second helper from `utilities.py`.\n", + "It absorbs the race described in the callout in step 7: even\n", + "after a stream has yielded `session.status_idle`, the server-side\n", + "`status` field on the session record can briefly still read\n", + "`running`, and an immediate `archive()` call would 400. The\n", + "helper just polls `sessions.retrieve` until the field settles.\n", + "Code that streams and then archives in the next breath needs it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "71a51f06", + "metadata": {}, + "outputs": [], + "source": [ + "from utilities import stream_until_end_turn, wait_for_idle_status" + ] + }, + { + "cell_type": "markdown", + "id": "34680f57", + "metadata": {}, + "source": [ + "## 6. Verify\n", + "\n", + "Don't take the agent's word for it. Re-run every assertion one\n", + "more time independently and print the final `calc.py`. If the\n", + "agent over-fixed or regressed something between the last\n", + "in-loop run and the end of the turn, this catches it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09179d80", + "metadata": {}, + "outputs": [], + "source": [ + "client.beta.sessions.events.send(\n", + " session_id=session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.message\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": (\n", + " \"Re-run every assertion from \"\n", + " \"/mnt/session/uploads/test_calc.py one more time \"\n", + " \"against your final calc.py with `python3 -c ...` \"\n", + " \"to confirm they all pass, then cat the final \"\n", + " \"/mnt/session/outputs/calc.py.\"\n", + " ),\n", + " }\n", + " ],\n", + " }\n", + " ],\n", + ")\n", + "stream_until_end_turn(client, session.id)" + ] + }, + { + "cell_type": "markdown", + "id": "ed315986", + "metadata": {}, + "source": [ + "## 7. Cleanup\n", + "\n", + "Archiving is how you mark a session, environment, or agent as\n", + "finished. It tears down any live container, stops the resource\n", + "from counting against your workspace quotas, and hides it from\n", + "default list views, but it keeps the record, configuration,\n", + "and event history around for audit and for anyone who wants to\n", + "retrieve the resource later by ID. If you want to remove the\n", + "record entirely, most resources also expose a separate `delete`\n", + "endpoint (the operate notebook walks through resource lifecycle\n", + "in detail), but `archive` is almost always what you want at the\n", + "end of a run." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1a61455", + "metadata": {}, + "outputs": [], + "source": [ + "wait_for_idle_status(client, session.id)\n", + "client.beta.sessions.archive(session.id)\n", + "client.beta.environments.archive(env.id)\n", + "client.beta.agents.archive(agent.id)\n", + "print(\"archived\")" + ] + }, + { + "cell_type": "markdown", + "id": "2eeb0ab4", + "metadata": {}, + "source": [ + "## Sidebar: polling instead of streaming\n", + "\n", + "The streaming pattern in step 5 is the right choice when you\n", + "want live progress on something the agent will spend more than a\n", + "few seconds on. For shorter tasks, or for production code where\n", + "you don't want a long-lived HTTP connection, you can do the\n", + "same thing with `events.list` polling instead:\n", + "\n", + "```python\n", + "client.beta.sessions.events.send(session_id=..., events=[...])\n", + "while True:\n", + " time.sleep(2)\n", + " events = client.beta.sessions.events.list(session.id).data\n", + " last = events[-1] if events else None\n", + " if last and last.type == \"session.status_terminated\":\n", + " break\n", + " if (\n", + " last\n", + " and last.type == \"session.status_idle\"\n", + " and last.stop_reason\n", + " and last.stop_reason.type == \"end_turn\"\n", + " ):\n", + " break\n", + "# walk events to print agent.message text\n", + "```\n", + "\n", + "Tradeoffs:\n", + "\n", + "Streaming wins when you want to watch the agent work. Every\n", + "tool call, every partial message, every state transition\n", + "arrives as soon as the server emits it, which is exactly what\n", + "you want while developing a new workflow. The cost is a\n", + "long-lived SSE connection: your process has to stay alive for\n", + "the duration of the turn, it can't pause and resume across\n", + "gaps, and a network blip at the wrong moment can drop you\n", + "mid-stream with no clean way to recover where you left off.\n", + "\n", + "Polling wins in the opposite situation. It's stateless,\n", + "survives process restarts, and composes cleanly with webhook\n", + "handlers and queue workers that don't want to hold connections\n", + "open. The cost is latency and hidden progress: you don't see\n", + "anything until you poll again, so feedback is bounded by your\n", + "poll interval, and a long turn looks like silence until it's\n", + "done.\n", + "\n", + "In production setups where the agent might run for minutes and\n", + "your handler can't hold a connection open, the polling pattern\n", + "(or its production cousin, the `session.status_idled` webhook\n", + "shown in the gate notebook) is what you want." + ] + }, + { + "cell_type": "markdown", + "id": "0e1acb04", + "metadata": {}, + "source": [ + "## Where to go next\n", + "\n", + "The iterate loop is the simplest shape an agent loop takes. Four\n", + "companion notebooks in this directory build on the same API\n", + "shapes and show other workflows you can drive:\n", + "\n", + "- [`CMA_orchestrate_issue_to_pr.ipynb`](CMA_orchestrate_issue_to_pr.ipynb) — multi-turn\n", + " agent that carries state through a longer tool chain: read an\n", + " issue, write a fix, open a PR, recover from a CI failure,\n", + " address a review comment, and merge.\n", + "- [`CMA_explore_unfamiliar_codebase.ipynb`](CMA_explore_unfamiliar_codebase.ipynb) — the\n", + " grounding pattern for an agent dropped into a repo it has\n", + " never seen, with a planted stale-doc trap. Also shows\n", + " `sessions.resources.add` for pushing more context into a\n", + " running session.\n", + "- [`CMA_gate_human_in_the_loop.ipynb`](CMA_gate_human_in_the_loop.ipynb) — custom-tool\n", + " `decide()` and `escalate()` round-trip for human-in-the-loop\n", + " workflows. Covers the `requires_action` idle bounce and\n", + " parallel-tool-call dedupe.\n", + "- [`CMA_operate_in_production.ipynb`](CMA_operate_in_production.ipynb) — production\n", + " setup story: vault-backed MCP credentials, the\n", + " `session.status_idled` webhook for HITL without long-lived\n", + " connections, and the resource lifecycle CRUD verbs." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/managed_agents/CMA_operate_in_production.ipynb b/managed_agents/CMA_operate_in_production.ipynb new file mode 100644 index 00000000..b0d8ed41 --- /dev/null +++ b/managed_agents/CMA_operate_in_production.ipynb @@ -0,0 +1,465 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "08e186d8", + "metadata": {}, + "source": [ + "# Operate: running Managed Agents in production\n", + "\n", + "Most of the other Managed Agents cookbooks focus on the agent\n", + "loop itself, getting an agent to do something useful against a\n", + "fixture. This one is about the machinery around that loop, the\n", + "pieces you need before you can put a Managed Agents app in\n", + "front of real users:\n", + "\n", + "1. **MCP toolsets** instead of custom tools, when your agent\n", + " needs to talk to a SaaS API without round-tripping every call\n", + " through your application.\n", + "2. **Vaults** to hold per-end-user credentials, so each user's\n", + " GitHub / Linear / Slack tokens stay separate from everyone\n", + " else's and your audit trail is clean.\n", + "3. **Webhooks** to drive human-in-the-loop work without holding\n", + " a long-lived HTTP connection open the whole time.\n", + "4. **Resource lifecycle** verbs (list, retrieve, update, archive,\n", + " delete) for managing what your workspace accumulates over time.\n", + "\n", + "We'll build one end-to-end flow that touches all four: create a\n", + "vault for a fictional end user, attach a GitHub MCP credential to\n", + "it, run an agent session that uses the credential server-side,\n", + "show the webhook handler you'd register to drive the same session\n", + "from a real production server, and walk through the management\n", + "verbs you'd use to clean up afterwards.\n", + "\n", + "This notebook needs `GITHUB_TOKEN` in your environment." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "60e59a79", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "from anthropic import Anthropic\n", + "from utilities import stream_until_end_turn, wait_for_idle_status\n", + "\n", + "MODEL = os.environ.get(\"COOKBOOK_MODEL\", \"claude-sonnet-4-6\")\n", + "client = Anthropic()\n", + "\n", + "GH_TOKEN = os.environ.get(\"GITHUB_TOKEN\")\n", + "if not GH_TOKEN:\n", + " raise SystemExit(\"Set GITHUB_TOKEN to run this notebook.\")" + ] + }, + { + "cell_type": "markdown", + "id": "0faa4e0d", + "metadata": {}, + "source": [ + "## Concepts: MCP toolsets and vaults\n", + "\n", + "**MCP toolsets** are the third extension pattern, after custom\n", + "tools (the gate notebook) and `resources=` mounts (the orchestrate notebook).\n", + "An MCP toolset points the agent at an external server that\n", + "implements the [Model Context Protocol](https://modelcontextprotocol.io/).\n", + "The agent calls tools on that server directly from inside the\n", + "sandbox, with no round-trip through your application, Anthropic\n", + "proxies the calls, the server responds, and the agent keeps\n", + "going. The vast majority of public SaaS APIs (GitHub, Slack,\n", + "Linear, Stripe, Notion, Salesforce, Asana...) either already have\n", + "an MCP server or can be wrapped in one in an afternoon, and any\n", + "of them are good MCP candidates.\n", + "\n", + "Rule of thumb: if the service is reachable over the public\n", + "internet with a bearer token, an MCP toolset will work. If\n", + "it's only reachable from inside your own network, use a custom\n", + "tool instead, which is what the gate notebook covers.\n", + "\n", + "**Vaults** are the answer to the question \"where do I put the\n", + "tokens?\" Hard-coding a single token at session creation time\n", + "works for a one-tenant setup, but it falls apart the moment you\n", + "have end users. Each user needs their own GitHub credential, and\n", + "you need to keep them isolated from each other. A vault is a\n", + "per-user container of credentials that you register once and\n", + "then reference by ID on every session you create for that user.\n", + "You don't run your own secret store, you don't pass tokens on\n", + "every request, and the audit trail is tied to the vault so you\n", + "always know which end user an agent was acting for." + ] + }, + { + "cell_type": "markdown", + "id": "077d9eb4", + "metadata": {}, + "source": [ + "## 1. Create a vault for an end user\n", + "\n", + "A vault has a `display_name` that shows up in the Console and a\n", + "`metadata` dict where you'd typically store your internal user\n", + "ID, so you can map the vault back to a record in your own\n", + "database." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f34017f", + "metadata": {}, + "outputs": [], + "source": [ + "vault = client.beta.vaults.create(\n", + " display_name=\"Cookbook demo user\",\n", + " metadata={\"internal_user_id\": \"u_demo_001\", \"team\": \"engineering\"},\n", + ")\n", + "print(f\"vault: {vault.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "36597bfc", + "metadata": {}, + "source": [ + "## 2. Attach an MCP credential\n", + "\n", + "Credentials live under a vault. Each credential pairs an MCP\n", + "server URL with a token the agent uses when calling that server.\n", + "For the GitHub Copilot MCP server, a static bearer token (your\n", + "GitHub PAT) is the simplest form. The API also supports a full\n", + "OAuth flow with refresh for services that require it, both\n", + "shapes are handled through `auth=`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d1c7b9f", + "metadata": {}, + "outputs": [], + "source": [ + "credential = client.beta.vaults.credentials.create(\n", + " vault_id=vault.id,\n", + " display_name=\"GitHub Copilot\",\n", + " auth={\n", + " \"type\": \"static_bearer\",\n", + " \"mcp_server_url\": \"https://api.githubcopilot.com/mcp/\",\n", + " \"token\": GH_TOKEN,\n", + " },\n", + ")\n", + "print(f\"credential: {credential.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "acd5e15a", + "metadata": {}, + "source": [ + "## 3. Reference the vault on a session\n", + "\n", + "Pass `vault_ids=[vault.id]` on `sessions.create` and the API\n", + "looks up the matching MCP server URL on every tool call. The\n", + "agent never sees the token itself, and you don't have to pass\n", + "it on the request. The agent definition just lists the MCP\n", + "server as usual, the credential wiring happens at session\n", + "creation time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e0c54dd", + "metadata": {}, + "outputs": [], + "source": [ + "agent = client.beta.agents.create(\n", + " name=\"cookbook-operate\",\n", + " model=MODEL,\n", + " system=\"You navigate GitHub repositories on behalf of the logged-in user.\",\n", + " mcp_servers=[\n", + " {\n", + " \"type\": \"url\",\n", + " \"name\": \"github\",\n", + " \"url\": \"https://api.githubcopilot.com/mcp/\",\n", + " }\n", + " ],\n", + " tools=[\n", + " {\n", + " \"type\": \"mcp_toolset\",\n", + " \"mcp_server_name\": \"github\",\n", + " \"default_config\": {\n", + " \"enabled\": True,\n", + " \"permission_policy\": {\"type\": \"always_allow\"},\n", + " },\n", + " }\n", + " ],\n", + ")\n", + "\n", + "env = client.beta.environments.create(\n", + " name=\"cookbook-operate-env\",\n", + " config={\"type\": \"cloud\", \"networking\": {\"type\": \"unrestricted\"}},\n", + ")\n", + "\n", + "session = client.beta.sessions.create(\n", + " environment_id=env.id,\n", + " agent={\"type\": \"agent\", \"id\": agent.id, \"version\": agent.version},\n", + " vault_ids=[vault.id],\n", + " title=\"Operate demo\",\n", + ")\n", + "print(f\"session: {session.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "7feba7aa", + "metadata": {}, + "source": [ + "## 4. Run a turn as the end user\n", + "\n", + "Everything the agent does against GitHub now flows through the\n", + "vault's credential. Auditing in your own systems is\n", + "straightforward: you know exactly which end user was acting\n", + "because the vault is tied to them via the metadata you set in\n", + "step 1." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "485e806d", + "metadata": {}, + "outputs": [], + "source": [ + "client.beta.sessions.events.send(\n", + " session_id=session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.message\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": \"List the three most recently updated repos in the anthropics org.\",\n", + " }\n", + " ],\n", + " }\n", + " ],\n", + ")\n", + "print(\"--- vault-backed MCP call ---\")\n", + "stream_until_end_turn(client, session.id)" + ] + }, + { + "cell_type": "markdown", + "id": "9480611b", + "metadata": {}, + "source": [ + "## 5. Webhooks for production HITL\n", + "\n", + "The streaming pattern in the gate notebook is convenient during\n", + "development because everything happens in one process, but it\n", + "holds an HTTP connection open while a human reviews, that\n", + "doesn't scale, and it doesn't survive process restarts. The\n", + "production pattern instead registers a webhook in the Console\n", + "that fires on `session.status_idled`, which is the signal that\n", + "the agent is either done OR waiting on a tool result.\n", + "\n", + "When the webhook fires, your server inspects the events, puts\n", + "any pending escalation in front of a reviewer, and POSTs the\n", + "`user.custom_tool_result` back whenever the human finishes. The\n", + "session simply sits idle until you respond, with no long-lived\n", + "connection on your side.\n", + "\n", + "Webhook registration is a one-time Console step under\n", + "**Settings → Webhooks**. You'll get a `whsec_...` signing\n", + "secret that is shown only once at creation; store it in your\n", + "secrets manager.\n", + "\n", + "**The block below is a reference implementation, not a notebook\n", + "cell.** Copy it into your own server, it depends on FastAPI,\n", + "which the cookbook doesn't install, and it's not run as part of\n", + "this notebook's flow. Paired with the agent definition from\n", + "the gate notebook, it's enough to drive the gate workflow end-to-end\n", + "from a production server.\n", + "\n", + "```python\n", + "import hmac\n", + "import hashlib\n", + "import json\n", + "\n", + "from fastapi import FastAPI, Header, HTTPException, Request\n", + "\n", + "app = FastAPI()\n", + "WEBHOOK_SECRET = \"whsec_...\" # from Console, load from your secrets manager\n", + "\n", + "\n", + "def verify(body: bytes, sig: str) -> bool:\n", + " expected = hmac.new(WEBHOOK_SECRET.encode(), body, hashlib.sha256).hexdigest()\n", + " return hmac.compare_digest(expected, sig)\n", + "\n", + "\n", + "@app.post(\"/webhooks/anthropic\")\n", + "async def receive(req: Request, x_anthropic_signature: str = Header()):\n", + " body = await req.body()\n", + " if not verify(body, x_anthropic_signature):\n", + " raise HTTPException(401)\n", + "\n", + " event = json.loads(body)\n", + " session_id = event[\"resource_id\"]\n", + "\n", + " if event[\"event_type\"] == \"session.status_idled\":\n", + " # Agent went idle. Either it's done OR it called escalate()\n", + " # and is waiting on a user.custom_tool_result. Look at the\n", + " # latest events to decide.\n", + " events = client.beta.sessions.events.list(session_id=session_id)\n", + " pending = [\n", + " e for e in events.data\n", + " if e.type == \"agent.custom_tool_use\" and e.name == \"escalate\"\n", + " and not has_result(events, e.id)\n", + " ]\n", + " if pending:\n", + " for tu in pending:\n", + " enqueue_for_review(session_id, tu.id, tu.input)\n", + " else:\n", + " finalize_run(session_id)\n", + "\n", + " return {\"ok\": True}\n", + "\n", + "\n", + "# Called from your review UI once the human decides\n", + "def submit_review(session_id: str, custom_tool_use_id: str, decision: str):\n", + " client.beta.sessions.events.send(\n", + " session_id=session_id,\n", + " events=[{\n", + " \"type\": \"user.custom_tool_result\",\n", + " \"custom_tool_use_id\": custom_tool_use_id,\n", + " \"content\": [{\"type\": \"text\",\n", + " \"text\": json.dumps({\"human_decision\": decision})}],\n", + " }],\n", + " )\n", + "```\n", + "\n", + "The code that responds to the agent is identical to the Part A\n", + "loop in the gate notebook. The only thing that changes is how your\n", + "server learns there's work to do: instead of a local loop pulling\n", + "events, webhooks push notifications on your schedule." + ] + }, + { + "cell_type": "markdown", + "id": "3ccb13ed", + "metadata": {}, + "source": [ + "## 6. Resource lifecycle: list, retrieve, update, archive\n", + "\n", + "Every resource in the API, agents, environments, sessions,\n", + "vaults, credentials, exposes the same five-verb pattern:\n", + "`list`, `retrieve`, `update`, `archive`, and (for some)\n", + "`delete`. We'll demonstrate the full set on agents, then list\n", + "the verbs available on each other resource as a quick reference.\n", + "\n", + "**archive vs delete:** `archive` keeps the record around for\n", + "audit and retrieval but tears down any live container and stops\n", + "the resource counting against your workspace quotas. `delete`\n", + "removes the record entirely. For most workflows `archive` is the\n", + "right call; reach for `delete` only when you specifically need\n", + "the record gone (e.g. test cleanup)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "03209484", + "metadata": {}, + "outputs": [], + "source": [ + "listed = client.beta.agents.list(limit=5)\n", + "print(f\"workspace has at least {len(listed.data)} agents\")\n", + "\n", + "retrieved = client.beta.agents.retrieve(agent.id)\n", + "print(f\"retrieved agent: name={retrieved.name} version={retrieved.version}\")\n", + "\n", + "# Updating an agent produces a new version. Pass the current\n", + "# version to confirm you're updating from a known state, a\n", + "# concurrent update from another process will reject yours rather\n", + "# than silently overwriting.\n", + "updated = client.beta.agents.update(\n", + " agent.id,\n", + " version=agent.version,\n", + " system=\"You navigate GitHub repositories. Be terse.\",\n", + ")\n", + "print(f\"updated to version {updated.version}\")\n", + "\n", + "# Every historical version is queryable.\n", + "versions = client.beta.agents.versions.list(agent_id=agent.id)\n", + "print(f\"agent has {len(versions.data)} versions\")" + ] + }, + { + "cell_type": "markdown", + "id": "bf02c0db", + "metadata": {}, + "source": [ + "## 7. Cleanup\n", + "\n", + "Credentials and vaults have their own archive endpoints.\n", + "Archiving a vault does NOT automatically archive its\n", + "credentials, so do the credentials first if you want a clean\n", + "sweep." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db7afb1d", + "metadata": {}, + "outputs": [], + "source": [ + "wait_for_idle_status(client, session.id)\n", + "client.beta.sessions.archive(session.id)\n", + "client.beta.environments.archive(env.id)\n", + "client.beta.agents.archive(agent.id)\n", + "client.beta.vaults.credentials.archive(credential.id, vault_id=vault.id)\n", + "client.beta.vaults.archive(vault.id)\n", + "print(\"archived\")" + ] + }, + { + "cell_type": "markdown", + "id": "48e2eb97", + "metadata": {}, + "source": [ + "## The other cookbooks\n", + "\n", + "This notebook is the production-shaped bookend. The workflow\n", + "notebooks it wraps around are worth running first if you\n", + "haven't already:\n", + "\n", + "- [`CMA_iterate_fix_failing_tests.ipynb`](CMA_iterate_fix_failing_tests.ipynb) — the\n", + " entry-point notebook. Introduces agents, environments,\n", + " sessions, file mounts, and the streaming event loop through\n", + " a do-observe-fix loop on a failing test suite.\n", + "- [`CMA_orchestrate_issue_to_pr.ipynb`](CMA_orchestrate_issue_to_pr.ipynb) — multi-turn\n", + " agent that drives an issue all the way to a merged PR through\n", + " a mock gh CLI, with mid-chain recovery from a CI failure and\n", + " a review comment.\n", + "- [`CMA_explore_unfamiliar_codebase.ipynb`](CMA_explore_unfamiliar_codebase.ipynb) — the\n", + " grounding pattern, with a planted stale-doc trap. Also shows\n", + " `sessions.resources.add` for pushing more context into a\n", + " running session.\n", + "- [`CMA_gate_human_in_the_loop.ipynb`](CMA_gate_human_in_the_loop.ipynb) — custom-tool\n", + " `decide()` and `escalate()` round-trip for human-in-the-loop\n", + " workflows, paired with the webhook reference block above." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/managed_agents/CMA_orchestrate_issue_to_pr.ipynb b/managed_agents/CMA_orchestrate_issue_to_pr.ipynb new file mode 100644 index 00000000..26d2eeff --- /dev/null +++ b/managed_agents/CMA_orchestrate_issue_to_pr.ipynb @@ -0,0 +1,306 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "63f7db36", + "metadata": {}, + "source": [ + "# Orchestrate: from issue to merged PR\n", + "\n", + "This notebook walks the agent through a realistic end-to-end loop:\n", + "read a vague bug report, find the bug, fix it, open a PR, survive\n", + "CI, address review feedback, and merge. A real maintainer workflow\n", + "is never linear, and that's the point of the exercise, the agent\n", + "has to carry state across many different tool types (reading JSON,\n", + "grepping code, editing files, running a mock CLI, parsing CI\n", + "output) while recovering from two mid-chain surprises: a CI\n", + "failure and a review bot that demands a docstring.\n", + "\n", + "State flows through the chain as issue body → file paths → fix\n", + "diff → PR number → CI output → review comment → final merge. The\n", + "`gh-mock` CLI in the fixture persists everything in `.gh-state/`\n", + "so each step can see what the previous ones did, mimicking a real\n", + "GitHub workflow without any network access.\n", + "\n", + "What this teaches beyond the iterate notebook:\n", + "\n", + "- **Multi-turn steering across a long chain.** The session\n", + " filesystem and conversation history persist across turns, so\n", + " each user message picks up where the last one left off. We use\n", + " that to verify the final state at the end.\n", + "- **Mid-chain recovery.** The agent has to read a CI failure or a\n", + " review comment and adapt, not just retry blindly.\n", + "\n", + "The fixture lives in `example_data/orchestrate/` and contains a\n", + "mock `gh` CLI, an issue JSON file, and a `src/` + `tests/` layout\n", + "with a planted bug." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8aeea909", + "metadata": {}, + "outputs": [], + "source": [ + "import io\n", + "import os\n", + "import zipfile\n", + "from pathlib import Path\n", + "\n", + "from anthropic import Anthropic\n", + "from utilities import stream_until_end_turn, wait_for_idle_status\n", + "\n", + "MODEL = os.environ.get(\"COOKBOOK_MODEL\", \"claude-sonnet-4-6\")\n", + "GH_TOKEN = os.environ.get(\"GITHUB_TOKEN\") # only needed for the github_repository sidebar\n", + "\n", + "client = Anthropic()\n", + "FIXTURE = Path(\"example_data\") / \"orchestrate\"" + ] + }, + { + "cell_type": "markdown", + "id": "ef87e434", + "metadata": {}, + "source": [ + "## 1. Pack the fixture\n", + "\n", + "The mock repository bundles a handful of files: `src/url_utils.py`\n", + "contains the actual bug, `src/blog.py` is a caller that makes the\n", + "bug easier to observe, `tests/test_urls.py` fails until the bug is\n", + "fixed, and the `gh-mock` CLI plus `issue_42.json` provide the\n", + "GitHub-like workflow the agent will drive. We zip the directory in\n", + "memory and upload it as a single file resource, see the sidebar\n", + "at the end for how to mount a real GitHub repository instead." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29b69624", + "metadata": {}, + "outputs": [], + "source": [ + "buf = io.BytesIO()\n", + "with zipfile.ZipFile(buf, \"w\") as zf:\n", + " for f in FIXTURE.rglob(\"*\"):\n", + " if f.is_file() and f.name != \"README.md\":\n", + " zf.write(f, f.relative_to(FIXTURE))\n", + "buf.seek(0)\n", + "fixture_zip = client.beta.files.upload(file=(\"repo.zip\", buf, \"application/zip\"))\n", + "print(f\"fixture: {fixture_zip.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c0c4e919", + "metadata": {}, + "source": [ + "## 2. Agent + environment + session\n", + "\n", + "The environment declares `pytest` as a pip dependency so the agent\n", + "can actually run the test suite as part of its CI loop. This is\n", + "the first notebook in the cookbook that needs network access for\n", + "package installation, hence the `allow_package_managers: True`\n", + "alongside the otherwise-`limited` networking config." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab6c5c98", + "metadata": {}, + "outputs": [], + "source": [ + "agent = client.beta.agents.create(\n", + " name=\"cookbook-orchestrate\",\n", + " model=MODEL,\n", + " system=(\n", + " \"You are a maintainer bot. You read issues via `./gh-mock`, explore \"\n", + " \"the codebase, write fixes, and shepherd PRs through CI and review. \"\n", + " \"When CI fails or a reviewer requests changes, read what they said \"\n", + " \"and address it, don't just retry blindly.\\n\\n\"\n", + " \"Work in /mnt/user. All gh-mock commands run from there.\"\n", + " ),\n", + " tools=[\n", + " {\n", + " \"type\": \"agent_toolset_20260401\",\n", + " \"default_config\": {\n", + " \"enabled\": True,\n", + " \"permission_policy\": {\"type\": \"always_allow\"},\n", + " },\n", + " }\n", + " ],\n", + ")\n", + "\n", + "env = client.beta.environments.create(\n", + " name=\"cookbook-orchestrate-env\",\n", + " config={\n", + " \"type\": \"cloud\",\n", + " \"networking\": {\"type\": \"limited\", \"allow_package_managers\": True},\n", + " \"packages\": {\"pip\": [\"pytest\"]},\n", + " },\n", + ")\n", + "\n", + "session = client.beta.sessions.create(\n", + " environment_id=env.id,\n", + " agent={\"type\": \"agent\", \"id\": agent.id, \"version\": agent.version},\n", + " resources=[{\"type\": \"file\", \"file_id\": fixture_zip.id, \"mount_path\": \"repo.zip\"}],\n", + " title=\"Issue #42 → PR\",\n", + ")\n", + "print(f\"session: {session.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b038b7ac", + "metadata": {}, + "source": [ + "## 3. Run the full chain\n", + "\n", + "A single instruction kicks off the whole loop. The two recovery\n", + "points to watch for are a CI failure and a review comment. If the\n", + "agent's first fix is incomplete, for example if it only handles\n", + "`é` and misses `ü`, `gh-mock pr checks` will exit non-zero with\n", + "pytest output that the agent needs to read and iterate on. Then,\n", + "once CI is green, the reviewer bot will block the merge if\n", + "`slugify()` is missing a docstring, giving the agent one more\n", + "chance to adapt before the final merge step." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5947170b", + "metadata": {}, + "outputs": [], + "source": [ + "client.beta.sessions.events.send(\n", + " session_id=session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.message\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": (\n", + " \"Unpack /mnt/session/uploads/repo.zip into /mnt/user \"\n", + " \"and ship a fix for issue #42 end-to-end. Read the \"\n", + " \"./gh-mock script first to see what subcommands it \"\n", + " \"supports; use those to view the issue, open a PR, \"\n", + " \"run CI, handle review feedback, and merge. Show me \"\n", + " \"the final PR state when you're done.\"\n", + " ),\n", + " }\n", + " ],\n", + " }\n", + " ],\n", + ")\n", + "\n", + "print(\"=== full orchestrate chain ===\")\n", + "stream_until_end_turn(client, session.id)" + ] + }, + { + "cell_type": "markdown", + "id": "630f5007", + "metadata": {}, + "source": [ + "## 4. Multi-turn verification\n", + "\n", + "Sessions are stateful: the container filesystem and the\n", + "conversation history persist across turns, so a follow-up just\n", + "sends another `user.message`. We use that here to independently\n", + "verify the final state, the mock CLI persists the PR state in\n", + "`.gh-state/pr_101.json`, so printing that file is the simplest\n", + "way to confirm the PR ended up merged with CI green and at least\n", + "one review approved before the merge." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "475509c1", + "metadata": {}, + "outputs": [], + "source": [ + "client.beta.sessions.events.send(\n", + " session_id=session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.message\",\n", + " \"content\": [\n", + " {\n", + " \"type\": \"text\",\n", + " \"text\": (\n", + " \"Print the contents of /mnt/user/.gh-state/pr_101.json so \"\n", + " \"I can see the final state, CI status, and reviews.\"\n", + " ),\n", + " }\n", + " ],\n", + " }\n", + " ],\n", + ")\n", + "stream_until_end_turn(client, session.id)\n", + "\n", + "wait_for_idle_status(client, session.id)\n", + "client.beta.sessions.archive(session.id)\n", + "client.beta.environments.archive(env.id)\n", + "client.beta.agents.archive(agent.id)\n", + "print(\"archived\")" + ] + }, + { + "cell_type": "markdown", + "id": "59e4b0ac", + "metadata": {}, + "source": [ + "## Sidebar: mounting a real GitHub repository\n", + "\n", + "The fixture above is a mock so the notebook can run offline and\n", + "you don't need any GitHub credentials to try it. For real work\n", + "against a real repository, swap the `{\"type\": \"file\", ...}` mount\n", + "above for a `{\"type\": \"github_repository\", ...}` resource and the\n", + "API will clone the repo into the container at session start.\n", + "\n", + "This is the same `resources=` field as the file mount in\n", + "the iterate notebook, the list takes a mix of types, so you could also\n", + "clone the repo AND mount a separate config file in the same call.\n", + "The agent's bash/read/grep tools see the working tree as a normal\n", + "directory; the only difference is that the API handles the clone\n", + "instead of you.\n", + "\n", + "```python\n", + "session = client.beta.sessions.create(\n", + " environment_id=env.id,\n", + " agent={\"type\": \"agent\", \"id\": agent.id, \"version\": agent.version},\n", + " resources=[\n", + " {\n", + " \"type\": \"github_repository\",\n", + " \"url\": \"https://github.com/anthropics/claude-cookbooks\",\n", + " \"mount_path\": \"/workspace/cookbook\",\n", + " \"authorization_token\": GH_TOKEN,\n", + " \"checkout\": {\"type\": \"branch\", \"name\": \"main\"},\n", + " }\n", + " ],\n", + " title=\"Repo explorer\",\n", + ")\n", + "```\n", + "\n", + "A `GITHUB_TOKEN` is required for both private repos and to\n", + "authenticate the clone. The clone happens once at session creation;\n", + "subsequent turns work against the same working tree without\n", + "re-cloning." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all", + "main_language": "python", + "notebook_metadata_filter": "-all" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/managed_agents/CMA_prompt_versioning_and_rollback.ipynb b/managed_agents/CMA_prompt_versioning_and_rollback.ipynb new file mode 100644 index 00000000..01e098f9 --- /dev/null +++ b/managed_agents/CMA_prompt_versioning_and_rollback.ipynb @@ -0,0 +1,439 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5dc7e03a", + "metadata": {}, + "source": [ + "# Prompt Versioning and Rollback\n", + "\n", + "Imagine you're a PM whose product support system uses an LLM to route incoming tickets to the right team. You want to tweak the routing prompt so that more API-related tickets go to the platform team. Previously, the prompt lived in your codebase. Changing it required a PR, a CI run, and deployment. Reverting required the same changes. Managed Agents keeps the prompt server-side instead. Every `agents.update` produces a new immutable version, and sessions choose which version to use by ID. You still review and approve prompt changes, but you're approving a version number in config rather than a code diff, and your running service picks up the change without a rebuild. If something goes wrong, pointing callers back at the old version is all it takes to roll back.\n", + "\n", + "In this cookbook, we'll create a support-ticket triage agent, update the system prompt, and roll it back when the performance degrades.\n", + "\n", + "By the end you'll have:\n", + "- created an agent and seen it come back as `version: 1`\n", + "- scored a specific version against a labelled test set\n", + "- shipped a v2 prompt and watched the version number move\n", + "- rolled a regressed agent back to v1 without a deploy\n", + "\n", + "## Prerequisites\n", + "\n", + "**Required:**\n", + "- Python 3.11+\n", + "- `anthropic>=0.91.0`\n", + "- An Anthropic API key\n", + "- The `example_data/prompt_versioning_and_rollback/support_tickets.jsonl` fixture in this directory\n" + ] + }, + { + "cell_type": "markdown", + "id": "e5566fdb", + "metadata": {}, + "source": [ + "## Setup\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d9398cd3", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "%pip install -q \"anthropic>=0.91.0\" python-dotenv" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "57c25956", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "import time\n", + "from collections import defaultdict\n", + "from pathlib import Path\n", + "\n", + "from anthropic import Anthropic\n", + "from dotenv import load_dotenv\n", + "\n", + "load_dotenv()\n", + "if not os.getenv(\"ANTHROPIC_API_KEY\"):\n", + " raise RuntimeError(\"Set ANTHROPIC_API_KEY in your environment or .env file\")\n", + "\n", + "MODEL = os.environ.get(\"COOKBOOK_MODEL\", \"claude-sonnet-4-6\")\n", + "client = Anthropic()" + ] + }, + { + "cell_type": "markdown", + "id": "516058e5", + "metadata": {}, + "source": [ + "## Create the agent (version 1)\n", + "\n", + "We'll start by creating an Environment (the container template the agent runs in) and the agent itself. The system prompt is short: classify each ticket into a team and priority, and respond with JSON only.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "500d5553", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env=env_017FKqTdU6dFgEe6zbbVQvE5 agent=agent_011CZo6t9Cr6Eg5TeFFPWPpi v1\n" + ] + } + ], + "source": [ + "env = client.beta.environments.create(name=\"ticket-triage-env\")\n", + "ENV_ID = env.id\n", + "\n", + "V1_SYSTEM = \"\"\"You are a support-ticket triage agent for a usage-billed API product.\n", + "Read the ticket and respond with ONLY a single line of raw JSON (no code fences, no prose):\n", + "{\"team\": \"\", \"priority\": \"\"}\n", + "Route based on the customer's actual problem, not surface keywords.\"\"\"\n", + "\n", + "agent = client.beta.agents.create(name=\"ticket-triage\", model=MODEL, system=V1_SYSTEM)\n", + "AGENT_ID = agent.id\n", + "print(f\"env={ENV_ID} agent={AGENT_ID} v{agent.version}\")" + ] + }, + { + "cell_type": "markdown", + "id": "66a5d506", + "metadata": {}, + "source": [ + "`agents.create` handed us back `version: 1` without us asking for it. Every update we make later will produce a new version with the same `id`, and that number is what we'll use to pin sessions and roll back.\n" + ] + }, + { + "cell_type": "markdown", + "id": "31b40ccc", + "metadata": {}, + "source": [ + "## Load the labelled test set\n", + "\n", + "Below we have twenty tickets, five per team, with the correct routing already labelled. These are the ground truth we'll score against.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "94852141", + "metadata": { + "lines_to_next_cell": 1 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20 tickets across 4 teams: ['api-platform', 'auth', 'billing', 'dashboard']\n" + ] + } + ], + "source": [ + "fixture = Path(\"example_data/prompt_versioning_and_rollback/support_tickets.jsonl\")\n", + "tickets = [json.loads(line) for line in fixture.read_text().splitlines()]\n", + "teams = sorted({t[\"team\"] for t in tickets})\n", + "print(f\"{len(tickets)} tickets across {len(teams)} teams: {teams}\")" + ] + }, + { + "cell_type": "markdown", + "id": "3c067d74", + "metadata": {}, + "source": [ + "## Score version 1\n", + "\n", + "Let's run every ticket through v1 and see how it does. The `triage` helper below opens a session pinned to a specific version, sends one ticket, polls `events.list` until the session goes idle, and parses the JSON verdict out of the `agent.message` events.\n", + "\n", + "The part that matters for this cookbook is the `agent=` argument on `sessions.create`. Passing a plain string (`agent=AGENT_ID`) gets you whatever the latest version is. Passing `{\"type\": \"agent\", \"id\": ..., \"version\": ...}` pins to an exact version, which is what we want for a controlled comparison.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7c0c6308", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " api-platform 5/5\n", + " auth 5/5\n", + " billing 4/5\n", + " dashboard 5/5\n" + ] + } + ], + "source": [ + "def triage(version: int, ticket: dict) -> dict:\n", + " \"\"\"Run one ticket through a pinned agent version and return its verdict.\"\"\"\n", + " session = client.beta.sessions.create(\n", + " agent={\"type\": \"agent\", \"id\": AGENT_ID, \"version\": version},\n", + " environment_id=ENV_ID,\n", + " )\n", + " try:\n", + " prompt = \"Subject: \" + ticket[\"subject\"] + \"\\n\\n\" + ticket[\"body\"]\n", + " client.beta.sessions.events.send(\n", + " session.id,\n", + " events=[{\"type\": \"user.message\", \"content\": [{\"type\": \"text\", \"text\": prompt}]}],\n", + " )\n", + " deadline = time.time() + 60\n", + " while time.time() < deadline:\n", + " events = client.beta.sessions.events.list(session.id).data\n", + " if events and events[-1].type == \"session.status_idle\":\n", + " break\n", + " time.sleep(1)\n", + " else:\n", + " raise TimeoutError(f\"session {session.id} did not idle within 60s\")\n", + " agent_events = [e for e in events if e.type == \"agent.message\"]\n", + " reply = \"\".join(b.text for e in agent_events for b in e.content)\n", + " return json.loads(reply)\n", + " finally:\n", + " try:\n", + " client.beta.sessions.archive(session.id)\n", + " except Exception: # noqa: S110\n", + " pass\n", + "\n", + "\n", + "def score(version: int) -> dict:\n", + " \"\"\"Evaluate all tickets against the given version and return per-team accuracy.\"\"\"\n", + " hits = defaultdict(lambda: [0, 0])\n", + " for t in tickets:\n", + " pred = triage(version, t)\n", + " hits[t[\"team\"]][1] += 1\n", + " if pred.get(\"team\") == t[\"team\"]:\n", + " hits[t[\"team\"]][0] += 1\n", + " return dict(hits)\n", + "\n", + "\n", + "v1_scores = score(version=1)\n", + "for team, (correct, total) in sorted(v1_scores.items()):\n", + " print(f\" {team:14s} {correct}/{total}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5b792ac1", + "metadata": {}, + "source": [ + "The model did well and got almost all routing correct." + ] + }, + { + "cell_type": "markdown", + "id": "89b662eb", + "metadata": {}, + "source": [ + "## Ship version 2\n", + "\n", + "Now the PM ships her change: a routing rule telling the agent that anything about API usage or rate limits belongs to the platform team. `agents.update` updates the agent to the new system prompt.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bacd6d64", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "agent agent_011CZo6t9Cr6Eg5TeFFPWPpi now at v2\n" + ] + } + ], + "source": [ + "V2_SYSTEM = V1_SYSTEM + (\n", + " \"\\n\\nROUTING RULE: If the ticket text mentions API usage, rate limits, quotas, \"\n", + " \"or request volume, route to api-platform. Apply this rule before any other \"\n", + " \"consideration; do not second-guess it based on the rest of the ticket.\"\n", + ")\n", + "agent = client.beta.agents.update(AGENT_ID, version=agent.version, system=V2_SYSTEM)\n", + "print(f\"agent {AGENT_ID} now at v{agent.version}\")" + ] + }, + { + "cell_type": "markdown", + "id": "governance", + "metadata": {}, + "source": [ + "### Where did code review go?\n", + "\n", + "We just changed the agent with one API call. In this notebook that happened with no review at all, which is fine for a demo but not how you'd run production.\n", + "\n", + "There's no built-in approval workflow on `agents.update`. Any key in the workspace can call it. If callers are passing the bare agent ID instead of a pinned version, they'll start using the new prompt on their very next session. That's the tradeoff for not needing a deploy, the same one you make with feature flags or any other config you manage through an API instead of through code.\n", + "\n", + "The pattern that puts the review step back: production callers always pin to an explicit version, and *that pinned number* is the thing under change control. Anyone can create v2, v3, v10; those versions sit on the server with no traffic. Promotion means updating whatever config tells production callers which version to pass, and that update goes through your normal review process. This process makes creating versions cheap and keeps your SDLC intact. It's still a win, because instead of updating production code, you only need to update config values and the change gets picked up across all runners.\n" + ] + }, + { + "cell_type": "markdown", + "id": "3095edf2", + "metadata": {}, + "source": [ + "## Score version 2\n", + "\n", + "Same evaluation, pinned to v2. The new rule is broad, and on a usage-billed API product the billing tickets talk about API usage too.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "01ce8ac2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "api-platform\n", + " v1: 5/5\n", + " v2: 5/5\n", + "auth\n", + " v1: 5/5\n", + " v2: 5/5\n", + "billing\n", + " v1: 4/5\n", + " v2: 2/5 <-- regressed\n", + "dashboard\n", + " v1: 5/5\n", + " v2: 5/5\n" + ] + } + ], + "source": [ + "v2_scores = score(version=agent.version)\n", + "\n", + "for team in sorted(v1_scores):\n", + " c1, n1 = v1_scores[team]\n", + " c2, n2 = v2_scores[team]\n", + " flag = \" <-- regressed\" if c2 < c1 else \"\"\n", + " print(team)\n", + " print(f\" v1: {c1}/{n1}\")\n", + " print(f\" v2: {c2}/{n2}{flag}\")" + ] + }, + { + "cell_type": "markdown", + "id": "359a6d8d", + "metadata": {}, + "source": [ + "## Roll back\n", + "\n", + "Billing regressed. Version 1 is still sitting on the server. Rolling back isn't a deploy; callers just go back to passing `version: 1`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9d980370", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "billing tickets via version=1: 4/5 correct\n" + ] + } + ], + "source": [ + "billing = [t for t in tickets if t[\"team\"] == \"billing\"]\n", + "rerun = [triage(version=1, ticket=t).get(\"team\") for t in billing]\n", + "print(f\"billing tickets via version=1: {rerun.count('billing')}/{len(billing)} correct\")" + ] + }, + { + "cell_type": "markdown", + "id": "a17fb502", + "metadata": {}, + "source": [ + "Since versions live server-side, v2 is still there if the PM wants to keep iterating on it while production stays on v1, or route a small slice of traffic to it as a canary. When a fix is ready, she can create v3 and run through the same process to promote it.\n" + ] + }, + { + "cell_type": "markdown", + "id": "dc8d8fcc", + "metadata": {}, + "source": [ + "## Clean up\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e6ef6c6e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "archived\n" + ] + } + ], + "source": [ + "client.beta.agents.archive(AGENT_ID)\n", + "client.beta.environments.archive(ENV_ID)\n", + "print(\"archived\")" + ] + }, + { + "cell_type": "markdown", + "id": "72755855", + "metadata": {}, + "source": [ + "## Recap\n", + "\n", + "The mechanics here are small (create, update, pin, re-pin), but prompts becoming a versioned server-side resource allows you to evaluate and promote prompts independently of application code, either through `update` runs as shown above or through changing the version in config.\n", + "\n", + "A few things worth carrying into your workflow:\n", + "\n", + "- Have production callers pin to an explicit version, not the bare agent ID. New versions stay invisible until you promote one.\n", + "- Treat the pinned version number as the gate for changing prompts. Creating versions is exploratory; updating the production pin is what goes through review.\n", + "- For higher-stakes agents, route a fraction of traffic to a new version and compare (as this notebook does) before promoting fully. You can effectively use this versioning as a feature flag.\n", + "\n", + "### Next steps\n", + "\n", + "- `client.beta.agents.versions.list(AGENT_ID)` returns every version of an agent.\n", + "- The other notebooks in `managed_agents/` cover sessions, custom tools, and end-to-end patterns.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/managed_agents/README.md b/managed_agents/README.md new file mode 100644 index 00000000..0877bf47 --- /dev/null +++ b/managed_agents/README.md @@ -0,0 +1,62 @@ +# Claude Managed Agents cookbooks + +Claude Managed Agents is Anthropic's hosted runtime for stateful, tool-using +agents. You define an agent and a sandboxed environment once, then run +them in sessions that persist files, tool state, and conversation +across turns. These tutorials show it end to end. + +## Applied cookbooks + +- **[data_analyst_agent.ipynb](data_analyst_agent.ipynb)** builds an + analyst that turns a CSV into a narrative HTML report using pandas + and plotly. You'll configure an environment and agent, mount a + dataset, stream the run, and retrieve the generated artifacts. +- **[slack_data_bot.ipynb](slack_data_bot.ipynb)** wraps that agent in + a Slack bot. Mention it with a CSV to get the report in-thread; + replies continue the same session. +- **[sre_incident_responder.ipynb](sre_incident_responder.ipynb)** puts + Managed Agents on the on-call path: a pager alert starts a session, + the agent investigates and opens a PR, then pauses for human + approval before merging. You'll wire the alert webhook, attach a + Skill and custom tools, and review the full run in the Console. + +## Guided tutorials + +End-to-end tutorials that teach the Managed Agents API surface +through realistic workflows. There's no strict reading order, +but `CMA_iterate_fix_failing_tests.ipynb` is a good entry point, +it introduces every API shape the others build on. + +| Notebook | What it teaches | +|----------|-----------------| +| [`CMA_iterate_fix_failing_tests.ipynb`](CMA_iterate_fix_failing_tests.ipynb) | Do → observe → fix loop on a failing test suite. The entry-point notebook: introduces agent / environment / session, file mounts, and the streaming event loop through the lens of getting a buggy package to green. | +| [`CMA_orchestrate_issue_to_pr.ipynb`](CMA_orchestrate_issue_to_pr.ipynb) | Issue → fix → PR → CI → review → merge through a mock `gh` CLI. Multi-turn steering, mid-chain recovery from a CI failure and a review comment. Sidebar shows how to swap the file mount for a `github_repository` resource against a real repo. | +| [`CMA_explore_unfamiliar_codebase.ipynb`](CMA_explore_unfamiliar_codebase.ipynb) | Grounding in an unfamiliar codebase, with a planted stale-doc trap. Sidebar shows how to add resources to a running session via `sessions.resources.add`. | +| [`CMA_gate_human_in_the_loop.ipynb`](CMA_gate_human_in_the_loop.ipynb) | Human-in-the-loop expense approval via custom-tool `decide()` / `escalate()`. Covers the custom-tool round-trip pattern, the `requires_action` idle bounce, and parallel-tool-call dedupe. | +| [`CMA_prompt_versioning_and_rollback.ipynb`](CMA_prompt_versioning_and_rollback.ipynb) | Server-side prompt versioning: create v1, evaluate against a labelled test set, ship v2, detect a regression, roll back by pinning sessions to version 1. Covers `agents.update`, version pinning on `sessions.create`, and where the review gate moves when prompts are not code. | +| [`CMA_operate_in_production.ipynb`](CMA_operate_in_production.ipynb) | Production setup: MCP toolsets, vaults for per-end-user credentials, the `session.status_idled` webhook pattern for HITL without long-lived connections, and the resource lifecycle CRUD verbs. | + +The streaming event loop is walked through line by line in the +iterate notebook and then factored into +`utilities.stream_until_end_turn` so the other notebooks can +import it instead of repeating the `match ev.type:` block. The +gate notebook is the exception: it keeps the loop inline because +custom-tool agents need to handle `requires_action` idle bounces +in addition to `end_turn`, which the helper doesn't cover. + +## Getting started + +Set `ANTHROPIC_API_KEY` in your environment, then open +`data_analyst_agent.ipynb` in Jupyter and run the cells top to +bottom. Each notebook installs its own dependencies and prompts +for any credentials it needs. The orchestrate-to-PR sidebar in +`CMA_orchestrate_issue_to_pr.ipynb` and the vault-backed MCP +example in `CMA_operate_in_production.ipynb` additionally need +`GITHUB_TOKEN` set (a fine-grained PAT with public-repo read is +enough). + +All cookbook fixture data — input CSVs and supporting assets for +the applied cookbooks, plus the planted-trap fixtures the guided +tutorials read from — lives under `example_data/`. See +[`example_data/OVERVIEW.md`](example_data/OVERVIEW.md) for the +directory map. diff --git a/managed_agents/data_analyst_agent.ipynb b/managed_agents/data_analyst_agent.ipynb new file mode 100644 index 00000000..9c47db5b --- /dev/null +++ b/managed_agents/data_analyst_agent.ipynb @@ -0,0 +1,468 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-0", + "metadata": {}, + "source": [ + "# Build a data analyst agent with Claude Managed Agents\n", + "\n", + "## Introduction\n", + "\n", + "Every team has someone who gets handed a CSV and asked \"what's\n", + "interesting in here?\" In this cookbook you'll build an agent that\n", + "answers for them: upload a CSV, get back a narrative HTML report\n", + "with interactive charts.\n", + "\n", + "You'll run it on\n", + "[Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview),\n", + "Anthropic's hosted runtime for stateful, tool-using agents, built on\n", + "four core concepts:\n", + "\n", + "- **Agent**: the model, system prompt, tools, MCP servers, and skills\n", + "- **Environment**: a configured container template (packages, network\n", + " access)\n", + "- **Session**: a running agent instance within an environment,\n", + " performing a specific task and generating outputs\n", + "- **Events**: messages exchanged between your application and the\n", + " agent (user turns, tool results, status updates)\n", + "\n", + "An agent plus an environment gives you a session. You attach your\n", + "data to it as resources, then drive it by sending events and reading\n", + "back the stream.\n", + "\n", + "Anthropic handles the sandbox, tool execution, and context\n", + "management for you. If you need full control over the agent loop and\n", + "deployment, try the\n", + "[Claude Agent SDK](https://platform.claude.com/docs/en/api/agent-sdk/overview)\n", + "instead.\n", + "\n", + "### What you'll learn\n", + "\n", + "By the end of this cookbook you'll be able to:\n", + "\n", + "- Set up a reusable environment and agent for data analysis\n", + "- Hand the agent a dataset to work with\n", + "- Watch the agent's progress as it runs\n", + "- Download the report and any other files it produced\n", + "\n", + "### Prerequisites\n", + "\n", + "- Python 3.11+\n", + "- An Anthropic API key from the\n", + " [Console](https://platform.claude.com/settings/keys), set as\n", + " `ANTHROPIC_API_KEY`\n", + "\n", + "Install dependencies:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cell-1", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "%pip install -q \"anthropic>=0.91.0\" python-dotenv" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cell-2", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "\n", + "from anthropic import Anthropic\n", + "from dotenv import load_dotenv, set_key\n", + "\n", + "load_dotenv()\n", + "client = Anthropic()\n", + "MODEL = \"claude-sonnet-4-6\"" + ] + }, + { + "cell_type": "markdown", + "id": "cell-3", + "metadata": {}, + "source": [ + "## 1. Create an environment\n", + "\n", + "An **environment** is a reusable container spec. Declaring `pandas`\n", + "and `plotly` here means every session starts with them preinstalled,\n", + "so the agent can begin analyzing immediately instead of running\n", + "`pip install` first.\n", + "\n", + "Networking is `unrestricted` here so the agent can load plotly from\n", + "its CDN – but that lets it reach anywhere on the internet, so for\n", + "production use a\n", + "[host allowlist](https://platform.claude.com/docs/en/managed-agents/environments)\n", + "instead." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cell-4", + "metadata": {}, + "outputs": [], + "source": [ + "env = client.beta.environments.create(\n", + " name=\"cookbook-data-analyst-env\",\n", + " config={\n", + " \"type\": \"cloud\",\n", + " \"networking\": {\"type\": \"unrestricted\"},\n", + " \"packages\": {\n", + " \"type\": \"packages\",\n", + " \"pip\": [\"pandas\", \"plotly\"],\n", + " },\n", + " },\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-5", + "metadata": {}, + "source": [ + "## 2. Create the agent\n", + "\n", + "An **agent** pairs a model with a system prompt and a set of tools.\n", + "Most of the output quality comes from the system prompt; this one\n", + "pushes for narrative structure, findings backed by specific figures,\n", + "and the right pattern for embedding multiple plotly charts in one\n", + "HTML file.\n", + "\n", + "[`agent_toolset_20260401`](https://platform.claude.com/docs/en/managed-agents/tools)\n", + "provides eight tools: `bash`, `read`, `write`, `edit`, `glob`,\n", + "`grep`, `web_fetch`, and `web_search`. Here they all run under\n", + "`always_allow`, with the two web tools disabled because this\n", + "analysis is offline." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cell-6", + "metadata": {}, + "outputs": [], + "source": [ + "ANALYST_SYSTEM_PROMPT = \"\"\"\\\n", + "You are a senior data analyst producing a publication-quality report.\n", + "\n", + "## Style\n", + "- Professional and precise. Let the data speak with concrete numbers.\n", + "- Short paragraphs (2-3 sentences) between charts.\n", + "- Lead with the most actionable finding.\n", + "\n", + "## Execution\n", + "- Write .py scripts and run them with `python3 script.py`.\n", + "- Sample large tables (`nrows=` / `.sample()`) instead of loading everything.\n", + "- Sanity-check key metrics before building narrative around them.\n", + "\n", + "## Charts\n", + "- Build each chart as its own `go.Figure()`, embed with\n", + " `fig.to_html(include_plotlyjs=False, full_html=False)`, and load plotly\n", + " from the CDN once in .\n", + "- Always set `marker_color` and `template='simple_white'`.\n", + "\n", + "## Output\n", + "Write a single self-contained `report.html` to /mnt/session/outputs/\n", + "with inline CSS, 3+ embedded plotly charts, and a closing section of\n", + "actionable recommendations. Confirm \"Saved: report.html\" when done.\n", + "\"\"\"\n", + "\n", + "agent = client.beta.agents.create(\n", + " name=\"cookbook-data-analyst\",\n", + " model=MODEL,\n", + " system=ANALYST_SYSTEM_PROMPT,\n", + " tools=[\n", + " {\n", + " \"type\": \"agent_toolset_20260401\",\n", + " # default_config applies to every tool in the set;\n", + " # entries in configs override specific tools.\n", + " \"default_config\": {\n", + " \"enabled\": True,\n", + " \"permission_policy\": {\"type\": \"always_allow\"},\n", + " },\n", + " \"configs\": [\n", + " {\"name\": \"web_search\", \"enabled\": False},\n", + " {\"name\": \"web_fetch\", \"enabled\": False},\n", + " ],\n", + " }\n", + " ],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-7", + "metadata": {}, + "source": [ + "## 3. Upload the dataset\n", + "\n", + "The included sample CSV has 50 rows, so the analysis completes in a\n", + "few minutes. Swap in any CSV (or a zip of CSVs) here; the rest of\n", + "the flow is identical." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "cell-8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Uploaded sales_data.csv (2833 bytes) as file_011CZqKKomgL45BLo2J8K5X9\n" + ] + } + ], + "source": [ + "DATA_PATH = Path(\"example_data/data_analyst_agent/sales_data.csv\")\n", + "\n", + "with DATA_PATH.open(\"rb\") as f:\n", + " dataset = client.beta.files.upload(file=(DATA_PATH.name, f, \"text/csv\"))\n", + "\n", + "print(f\"Uploaded {DATA_PATH.name} ({dataset.size_bytes} bytes) as {dataset.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-9", + "metadata": {}, + "source": [ + "## 4. Create a session and send the task\n", + "\n", + "A **session** binds the agent to the environment and any mounted\n", + "files. Passing `{\"type\": \"agent\", \"id\": ..., \"version\": ...}` reuses\n", + "the versioned agent you created above. `resources` mounts the\n", + "uploaded file at the given absolute path inside the container.\n", + "\n", + "After creating the session, send a `user.message` event with the\n", + "task. The agent will start working immediately." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "cell-10", + "metadata": { + "lines_to_next_cell": 1 + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Session sesn_011CZqKKqyPRph9J5khKLn6u running\n" + ] + } + ], + "source": [ + "MOUNT_PATH = f\"/mnt/session/uploads/{DATA_PATH.name}\"\n", + "\n", + "session = client.beta.sessions.create(\n", + " environment_id=env.id,\n", + " agent={\"type\": \"agent\", \"id\": agent.id, \"version\": agent.version},\n", + " resources=[{\"type\": \"file\", \"file_id\": dataset.id, \"mount_path\": MOUNT_PATH}],\n", + " title=\"Sales analysis\",\n", + ")\n", + "\n", + "ANALYSIS_PROMPT = f\"\"\"\\\n", + "Analyze the e-commerce orders in {MOUNT_PATH}.\n", + "\n", + "Columns: order_id, customer_id, product, category, price, quantity,\n", + "order_date, region.\n", + "\n", + "Focus on revenue by category and region, repeat-customer behavior, and\n", + "one surprising pattern. Produce report.html per your system instructions.\n", + "\"\"\"\n", + "\n", + "client.beta.sessions.events.send(\n", + " session.id,\n", + " events=[\n", + " {\"type\": \"user.message\", \"content\": [{\"type\": \"text\", \"text\": ANALYSIS_PROMPT}]},\n", + " ],\n", + ")\n", + "print(f\"Session {session.id} running\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-11", + "metadata": {}, + "source": [ + "## 5. Stream the run\n", + "\n", + "Open the session in the [Console](https://platform.claude.com/)\n", + "under **Sessions** to watch every event, tool call, and token count\n", + "live:\n", + "\n", + "\"Session\n", + "\n", + "The helper below tails the same event stream, printing\n", + "`agent.message` text and `agent.tool_use` calls as they arrive, and\n", + "returns on `session.status_idle`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-12", + "metadata": {}, + "outputs": [], + "source": [ + "def wait_for_idle(session_id: str) -> None:\n", + " for ev in client.beta.sessions.events.stream(session_id):\n", + " t = ev.type\n", + " if t == \"agent.message\":\n", + " for block in ev.content:\n", + " if block.type == \"text\":\n", + " text = block.text\n", + " print(text[:300] + (\"...\" if len(text) > 300 else \"\"))\n", + " elif t in (\"agent.tool_use\", \"agent.mcp_tool_use\"):\n", + " print(f\" [{ev.name}]\")\n", + " elif t == \"session.status_idle\":\n", + " return\n", + " elif t == \"session.status_terminated\":\n", + " raise RuntimeError(\n", + " \"Session terminated before going idle. \"\n", + " f\"Trace: https://platform.claude.com/sessions/{session_id}\"\n", + " )\n", + "\n", + "\n", + "wait_for_idle(session.id)" + ] + }, + { + "cell_type": "markdown", + "id": "cell-13", + "metadata": {}, + "source": [ + "## 6. Retrieve the report\n", + "\n", + "Anything the agent writes to `/mnt/session/outputs/` is persisted\n", + "and surfaced via the Files API with `scope_id=`. Files\n", + "written elsewhere in the container are not persisted.\n", + "\n", + "The [Files API](https://platform.claude.com/docs/en/api/beta/files/list)\n", + "is a separate feature in beta, so to use `scope_id` here you also\n", + "need to pass the Managed Agents beta header." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "cell-14", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "report.html 53728\n", + "sales_data.csv 2833\n", + "Downloaded report.html\n" + ] + } + ], + "source": [ + "outputs = client.beta.files.list(scope_id=session.id, betas=[\"managed-agents-2026-04-01\"])\n", + "for f in outputs.data:\n", + " print(f.filename, f.size_bytes)\n", + "\n", + "# The list also includes the mounted input CSV; pick out the report.\n", + "report = next((f for f in outputs.data if f.filename == \"report.html\"), None)\n", + "if report is None:\n", + " raise RuntimeError(f\"report.html not found. Files: {[f.filename for f in outputs.data]}\")\n", + "content = client.beta.files.download(report.id)\n", + "Path(\"report.html\").write_bytes(content.read())\n", + "print(\"Downloaded report.html\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-15", + "metadata": {}, + "source": [ + "## 7. Clean up and next steps\n", + "\n", + "You create the agent and environment once and reuse them across\n", + "runs; you create a new session for each conversation. Now that you\n", + "have the report, archive this session to release its container. The\n", + "lines below save the agent and environment IDs to `.env` so\n", + "[`slack_data_bot.ipynb`](slack_data_bot.ipynb) can start new\n", + "sessions with them.\n", + "\n", + "> **Warning:** make sure `.env` is listed in `.gitignore` before\n", + "> running the next cell – never commit it." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "cell-16", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved ANALYST_ENV_ID, ANALYST_AGENT_ID, ANALYST_AGENT_VERSION to .env\n" + ] + } + ], + "source": [ + "client.beta.sessions.archive(session.id)\n", + "\n", + "set_key(\".env\", \"ANALYST_ENV_ID\", env.id)\n", + "set_key(\".env\", \"ANALYST_AGENT_ID\", agent.id)\n", + "set_key(\".env\", \"ANALYST_AGENT_VERSION\", str(agent.version))\n", + "print(\"Saved ANALYST_ENV_ID, ANALYST_AGENT_ID, ANALYST_AGENT_VERSION to .env\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-17", + "metadata": {}, + "source": [ + "You've built and run a data analyst agent end to end: a reusable\n", + "environment and agent, a session that mounted your CSV, a live event\n", + "stream, and a downloaded HTML report.\n", + "\n", + "From here:\n", + "\n", + "- Open the downloaded `report.html` to see the narrative and charts.\n", + "- Open the session in the\n", + " [Console](https://platform.claude.com/) to inspect token usage\n", + " and the full event log.\n", + "- Continue to [`slack_data_bot.ipynb`](slack_data_bot.ipynb)\n", + " to drive this agent from Slack." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "pygments_lexer": "ipython3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/managed_agents/example_data/OVERVIEW.md b/managed_agents/example_data/OVERVIEW.md new file mode 100644 index 00000000..c68c20b3 --- /dev/null +++ b/managed_agents/example_data/OVERVIEW.md @@ -0,0 +1,15 @@ +# Example data + +This directory holds the small, self-contained inputs that the cookbook notebooks read from. Everything in here is checked in so you can run the cookbook end-to-end without standing up a database, signing up for an API, or wiring credentials beyond your `ANTHROPIC_API_KEY`. Each subdirectory is paired with one notebook and only that notebook touches it. + +The fixtures are deliberately small. They're sized to be read by a human in a couple of minutes, small enough that you can open the files yourself and follow what the agent is reasoning about, but large enough that there's something genuine to figure out. Each one has at least one little trap or wrinkle planted in it: a dependency between two bugs, a stale documentation file that disagrees with the code, a receipt that sits right on the edge of an approval threshold. The goal is to give the agent something to actually grapple with rather than a toy that always succeeds on the first try. + +| Directory | Used by | Notebook focus | What's inside | Approx. runtime | +|-----------|---------|----------------|---------------|-----------------| +| `iterate/` | `CMA_iterate_fix_failing_tests.py` | Do → observe → fix loop on a failing test suite | A tiny `calc.py` package with three planted bugs and the matching test file. One of the failures is downstream of another, so a careful agent fixes the root cause and watches the second test pass on its own. | ~2 min | +| `orchestrate/` | `CMA_orchestrate_issue_to_pr.py` | Driving an issue all the way to a merged PR through a mock `gh` CLI | A mock `gh` script that persists state in `.gh-state/`, an `issue_42.json` describing a vague Unicode bug, and a small `src/` + `tests/` repo with the bug planted. The chain forces the agent to recover from a CI failure mid-flight and to address a docstring nit from the review bot before it can merge. | ~5 min | +| `gate/` | `CMA_gate_human_in_the_loop.py` | Human-in-the-loop approval lanes with custom tools | A `policy.yaml` describing approval rules and twelve receipts that exercise every branch of the policy, clean approves, clean rejects, and a couple of genuinely ambiguous cases the agent should escalate rather than guess about. | ~3 min | + +A fourth notebook, `CMA_explore_unfamiliar_codebase.py`, also runs against fixture data, but its repository fixture is small enough that it gets generated in memory by `utilities.make_unfamiliar_repo_zip()` rather than checked in. The helper is shorter and easier to read than a directory of stub files would be, and it keeps the trap (a stale `ARCHITECTURE.md` describing an old monolithic layout that no longer matches the real microservices code) in one obvious place. + +Everything in this directory runs offline. The mock CLIs read and write local JSON instead of making network calls, the test runners are just `python3 -c` invocations, and nothing here phones home. diff --git a/managed_agents/example_data/data_analyst_agent/console_session.png b/managed_agents/example_data/data_analyst_agent/console_session.png new file mode 100644 index 00000000..40e78fe5 Binary files /dev/null and b/managed_agents/example_data/data_analyst_agent/console_session.png differ diff --git a/managed_agents/example_data/data_analyst_agent/sales_data.csv b/managed_agents/example_data/data_analyst_agent/sales_data.csv new file mode 100644 index 00000000..2cb60f20 --- /dev/null +++ b/managed_agents/example_data/data_analyst_agent/sales_data.csv @@ -0,0 +1,51 @@ +order_id,customer_id,product,category,price,quantity,order_date,region +1001,C001,Wireless Mouse,Electronics,24.99,2,2025-01-03,West +1002,C002,Yoga Mat,Sports,39.99,1,2025-01-03,East +1003,C001,USB-C Cable,Electronics,12.50,3,2025-01-04,West +1004,C003,Coffee Maker,Home,89.00,1,2025-01-05,Midwest +1005,C004,Running Shoes,Sports,119.99,1,2025-01-05,South +1006,C002,Resistance Bands,Sports,18.99,2,2025-01-06,East +1007,C005,Desk Lamp,Home,34.50,1,2025-01-07,West +1008,C006,Bluetooth Speaker,Electronics,59.99,1,2025-01-07,East +1009,C003,Blender,Home,64.99,1,2025-01-08,Midwest +1010,C007,Notebook Set,Office,14.99,4,2025-01-08,South +1011,C001,Mechanical Keyboard,Electronics,129.00,1,2025-01-09,West +1012,C008,Water Bottle,Sports,22.00,2,2025-01-10,East +1013,C004,Tennis Racket,Sports,89.99,1,2025-01-10,South +1014,C009,Standing Desk,Office,299.00,1,2025-01-11,West +1015,C005,Throw Pillow,Home,19.99,3,2025-01-11,West +1016,C010,Webcam,Electronics,79.99,1,2025-01-12,Midwest +1017,C002,Foam Roller,Sports,27.50,1,2025-01-12,East +1018,C006,Smart Plug,Electronics,15.99,4,2025-01-13,East +1019,C011,Desk Organizer,Office,24.00,2,2025-01-14,South +1020,C003,Air Fryer,Home,109.99,1,2025-01-14,Midwest +1021,C012,Dumbbells,Sports,49.99,2,2025-01-15,West +1022,C007,Monitor Stand,Office,45.00,1,2025-01-15,South +1023,C001,HDMI Cable,Electronics,9.99,2,2025-01-16,West +1024,C013,Cutting Board,Home,29.99,1,2025-01-17,East +1025,C008,Jump Rope,Sports,12.99,1,2025-01-17,East +1026,C014,Laptop Stand,Office,54.99,1,2025-01-18,Midwest +1027,C004,Basketball,Sports,34.99,1,2025-01-18,South +1028,C009,Ergonomic Chair,Office,389.00,1,2025-01-19,West +1029,C015,Tablet Case,Electronics,19.99,2,2025-01-20,East +1030,C005,Candle Set,Home,24.99,2,2025-01-20,West +1031,C010,Ring Light,Electronics,39.99,1,2025-01-21,Midwest +1032,C002,Yoga Block,Sports,14.99,2,2025-01-21,East +1033,C016,File Cabinet,Office,149.00,1,2025-01-22,South +1034,C003,Toaster,Home,44.99,1,2025-01-23,Midwest +1035,C011,Whiteboard,Office,69.99,1,2025-01-23,South +1036,C006,Noise-Canceling Headphones,Electronics,199.99,1,2025-01-24,East +1037,C012,Kettlebell,Sports,42.00,1,2025-01-24,West +1038,C017,Picture Frame,Home,16.99,3,2025-01-25,West +1039,C007,Stapler,Office,8.99,2,2025-01-25,South +1040,C001,Power Bank,Electronics,34.99,1,2025-01-26,West +1041,C013,Knife Set,Home,79.99,1,2025-01-27,East +1042,C008,Pull-up Bar,Sports,32.99,1,2025-01-27,East +1043,C018,Printer,Electronics,159.99,1,2025-01-28,Midwest +1044,C014,Desk Pad,Office,29.99,1,2025-01-28,Midwest +1045,C004,Soccer Ball,Sports,27.99,1,2025-01-29,South +1046,C009,Bookshelf,Office,189.00,1,2025-01-29,West +1047,C015,Phone Charger,Electronics,17.99,3,2025-01-30,East +1048,C005,Wall Clock,Home,39.99,1,2025-01-30,West +1049,C019,Exercise Bike,Sports,449.00,1,2025-01-31,Midwest +1050,C010,USB Hub,Electronics,28.99,1,2025-01-31,Midwest diff --git a/managed_agents/example_data/gate/README.md b/managed_agents/example_data/gate/README.md new file mode 100644 index 00000000..bd4cec1d --- /dev/null +++ b/managed_agents/example_data/gate/README.md @@ -0,0 +1,5 @@ +# Gate, expense approver + +A `policy.yaml` and twelve receipts (`inbox/receipts.jsonl`) used by `CMA_gate_human_in_the_loop.py`. The agent classifies each receipt against the policy with two custom tools: `decide()` for clear approves and rejects, `escalate()` for anything ambiguous. + +The twelve receipts are designed to hit every branch of the policy: a handful that should auto-approve cleanly, one with no receipt image where the policy demands one, a couple in the manager-approval band, two over the threshold, one travel charge that always escalates regardless of amount, and one with a deliberately ambiguous category. A healthy run produces a mix of `approve`, `reject`, and `escalated` decisions, never all of one lane. diff --git a/managed_agents/example_data/gate/inbox/receipts.jsonl b/managed_agents/example_data/gate/inbox/receipts.jsonl new file mode 100644 index 00000000..4fe7e480 --- /dev/null +++ b/managed_agents/example_data/gate/inbox/receipts.jsonl @@ -0,0 +1,12 @@ +{"id": "r01", "vendor": "Blue Bottle Coffee", "amount": 18.50, "category": "meals", "has_image": true, "date": "2026-03-01"} +{"id": "r02", "vendor": "Office Depot", "amount": 42.00, "category": "supplies", "has_image": true, "date": "2026-03-02"} +{"id": "r03", "vendor": "Uber", "amount": 31.20, "category": "transport", "has_image": true, "date": "2026-03-03"} +{"id": "r04", "vendor": "Zoom", "amount": 15.99, "category": "software", "has_image": true, "date": "2026-03-04"} +{"id": "r05", "vendor": "Staples", "amount": 38.00, "category": "supplies", "has_image": false, "date": "2026-03-05"} +{"id": "r06", "vendor": "Figma", "amount": 144.00, "category": "software", "has_image": true, "date": "2026-03-06"} +{"id": "r07", "vendor": "AWS", "amount": 287.43, "category": "infrastructure", "has_image": true, "date": "2026-03-07"} +{"id": "r08", "vendor": "LinkedIn Ads", "amount": 450.00, "category": "marketing", "has_image": true, "date": "2026-03-08"} +{"id": "r09", "vendor": "Dell", "amount": 1249.00, "category": "equipment", "has_image": true, "date": "2026-03-09"} +{"id": "r10", "vendor": "Conference Registration", "amount": 899.00, "category": "events", "has_image": true, "date": "2026-03-10"} +{"id": "r11", "vendor": "Delta Airlines", "amount": 80.00, "category": "travel", "has_image": true, "date": "2026-03-11"} +{"id": "r12", "vendor": "Consulting LLC", "amount": 200.00, "category": null, "has_image": true, "date": "2026-03-12", "note": "category unclear — could be legal or marketing"} diff --git a/managed_agents/example_data/gate/policy.yaml b/managed_agents/example_data/gate/policy.yaml new file mode 100644 index 00000000..ecdf9651 --- /dev/null +++ b/managed_agents/example_data/gate/policy.yaml @@ -0,0 +1,5 @@ +--- +auto_approve_under: 50 +manager_approve_under: 500 +always_escalate_categories: [travel, legal] +require_receipt_over: 25 diff --git a/managed_agents/example_data/iterate/README.md b/managed_agents/example_data/iterate/README.md new file mode 100644 index 00000000..f9ec336a --- /dev/null +++ b/managed_agents/example_data/iterate/README.md @@ -0,0 +1,5 @@ +# Iterate, get the tests green + +A `calc.py` with three planted bugs and a `test_calc.py` with three assertions that catch them. Used by `CMA_iterate_fix_failing_tests.py`. + +The interesting bug is `test_mean`: `mean()` calls `add` and `divide` internally, so it goes green on its own once the other two are fixed. An agent that edits `mean()` directly is over-fixing. diff --git a/managed_agents/example_data/iterate/calc.py b/managed_agents/example_data/iterate/calc.py new file mode 100644 index 00000000..a4aee159 --- /dev/null +++ b/managed_agents/example_data/iterate/calc.py @@ -0,0 +1,13 @@ +def add(a, b): + return a + b + 1 # BUG: off by one + + +def divide(a, b): + return a / b # BUG: no zero check + + +def mean(xs): + total = 0 + for x in xs: + total = add(total, x) + return divide(total, len(xs)) diff --git a/managed_agents/example_data/iterate/test_calc.py b/managed_agents/example_data/iterate/test_calc.py new file mode 100644 index 00000000..28c7c470 --- /dev/null +++ b/managed_agents/example_data/iterate/test_calc.py @@ -0,0 +1,16 @@ +import pytest +from calc import add, divide, mean + + +def test_add(): + assert add(2, 3) == 5 + + +def test_divide(): + assert divide(10, 2) == 5 + with pytest.raises(ValueError): + divide(10, 0) + + +def test_mean(): + assert mean([2, 4, 6]) == 4 diff --git a/managed_agents/example_data/orchestrate/README.md b/managed_agents/example_data/orchestrate/README.md new file mode 100644 index 00000000..3dc6dc4e --- /dev/null +++ b/managed_agents/example_data/orchestrate/README.md @@ -0,0 +1,9 @@ +# Orchestrate, drive an issue to a merged PR + +Self-contained mock of a maintainer workflow, used by `CMA_orchestrate_issue_to_pr.py`. The cookbook zips this directory and hands it to the agent. + +- `gh-mock`, bash script that fakes the relevant `gh` subcommands. State persists in `.gh-state/`. +- `issue_42.json`, Unicode bug report (`Café Culture` → `caf-culture`). Vague enough that the agent has to read code. +- `src/url_utils.py` + `src/blog.py` + `tests/test_urls.py`, buggy `slugify()` and the failing tests that catch it. + +Two recovery points are planted: an incomplete first fix fails CI with a pytest traceback, and the mock reviewer-bot blocks the merge if `slugify()` is missing a docstring. A healthy run ends with `.gh-state/pr_101.json` showing `state: merged`, `ci/test: pass`, and an `APPROVED` review. diff --git a/managed_agents/example_data/orchestrate/gh-mock b/managed_agents/example_data/orchestrate/gh-mock new file mode 100755 index 00000000..fe6f4b07 --- /dev/null +++ b/managed_agents/example_data/orchestrate/gh-mock @@ -0,0 +1,89 @@ +#!/usr/bin/env bash +# Mock gh CLI — simulates issues, PRs, CI checks, and review comments. +# State persists in .gh-state/ across calls within a session. +set -e +STATE=.gh-state +mkdir -p $STATE + +case "$1 $2" in + "issue view") + cat issue_$3.json + ;; + + "pr create") + shift 2 + python3 - "$@" <<'PY' +import json, sys, os +args = dict(zip(sys.argv[1::2], sys.argv[2::2])) +args["number"] = 101 +args["state"] = "open" +args["checks"] = {"ci/test": "pending"} +args["reviews"] = [] +os.makedirs(".gh-state", exist_ok=True) +json.dump(args, open(".gh-state/pr_101.json", "w"), indent=2) +print(f"Created PR #101: {args.get('--title', '(no title)')}") +print("View at: https://github.com/mock/repo/pull/101") +PY + ;; + + "pr checks") + # CI runs the actual test suite and updates the check status + python3 - <<'PY' +import json, subprocess, sys +pr = json.load(open(".gh-state/pr_101.json")) +r = subprocess.run(["python3", "-m", "pytest", "tests/", "-q", "--tb=short"], + capture_output=True, text=True) +status = "pass" if r.returncode == 0 else "fail" +pr["checks"]["ci/test"] = status +pr["checks"]["_last_output"] = (r.stdout + r.stderr)[-800:] +json.dump(pr, open(".gh-state/pr_101.json", "w"), indent=2) +print(f"ci/test: {status}") +if status == "fail": + print("---") + print(r.stdout + r.stderr) + sys.exit(1) +PY + ;; + + "pr view") + python3 -c "import json; print(json.dumps(json.load(open('.gh-state/pr_$3.json')), indent=2))" + ;; + + "pr review") + # Mock reviewer: nitpicks if slugify() lacks a docstring + python3 - <<'PY' +import json +pr = json.load(open(".gh-state/pr_101.json")) +with open("src/url_utils.py") as f: + code = f.read() +fn_body = code.split("def slugify")[1].split("\ndef ")[0] +if '"""' not in fn_body: + pr["reviews"].append({ + "author": "reviewer-bot", "state": "CHANGES_REQUESTED", + "body": "Please add a docstring to slugify() explaining the unicode handling." + }) + print("Review: CHANGES_REQUESTED") + print(" > Please add a docstring to slugify() explaining the unicode handling.") +else: + pr["reviews"].append({"author": "reviewer-bot", "state": "APPROVED", "body": "LGTM"}) + print("Review: APPROVED") +json.dump(pr, open(".gh-state/pr_101.json", "w"), indent=2) +PY + ;; + + "pr merge") + python3 - <<'PY' +import json, sys +pr = json.load(open(".gh-state/pr_101.json")) +if pr["checks"].get("ci/test") != "pass": + print("Cannot merge: ci/test is not passing", file=sys.stderr); sys.exit(1) +if not any(r["state"] == "APPROVED" for r in pr.get("reviews", [])): + print("Cannot merge: needs an approving review", file=sys.stderr); sys.exit(1) +pr["state"] = "merged" +json.dump(pr, open(".gh-state/pr_101.json", "w"), indent=2) +print("Merged PR #101 into main") +PY + ;; + + *) echo "gh-mock: unknown command '$*'" >&2; exit 1 ;; +esac diff --git a/managed_agents/example_data/orchestrate/issue_42.json b/managed_agents/example_data/orchestrate/issue_42.json new file mode 100644 index 00000000..2add7345 --- /dev/null +++ b/managed_agents/example_data/orchestrate/issue_42.json @@ -0,0 +1,9 @@ +{ + "number": 42, + "title": "Blog post URLs with accented characters 404", + "body": "## Problem\n\nPosts with accented titles like 'Café Culture' generate broken URLs. The slug becomes `caf-culture` instead of `cafe-culture`, so the route doesn't match.\n\n## Repro\n\n```python\n>>> from src.url_utils import slugify\n>>> slugify('Café Culture')\n'caf-culture' # expected: 'cafe-culture'\n```\n\n## Where it breaks\n\nNot sure if this is in `url_utils.py` or how `blog.py` calls it. The `generate_post_url()` in `blog.py` is what users actually hit.\n\n## Impact\n\nAny post title with é, ñ, ü, etc. produces a 404. We have 23 affected posts in prod.", + "labels": ["bug", "p1", "routing"], + "comments": [ + {"author": "alice", "body": "Pretty sure this is the `.encode('ascii', 'ignore')` call dropping the chars instead of transliterating. unicodedata.normalize might help?"} + ] +} diff --git a/managed_agents/example_data/orchestrate/src/__init__.py b/managed_agents/example_data/orchestrate/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/managed_agents/example_data/orchestrate/src/blog.py b/managed_agents/example_data/orchestrate/src/blog.py new file mode 100644 index 00000000..0b465ca6 --- /dev/null +++ b/managed_agents/example_data/orchestrate/src/blog.py @@ -0,0 +1,12 @@ +from datetime import date + +from .url_utils import normalize_path, slugify + + +def generate_post_url(title: str, published: date) -> str: + slug = slugify(title) + return normalize_path(f"/blog/{published.year}/{published.month:02d}/{slug}") + + +def generate_author_url(name: str) -> str: + return normalize_path(f"/authors/{slugify(name)}") diff --git a/managed_agents/example_data/orchestrate/src/url_utils.py b/managed_agents/example_data/orchestrate/src/url_utils.py new file mode 100644 index 00000000..a0ea3f06 --- /dev/null +++ b/managed_agents/example_data/orchestrate/src/url_utils.py @@ -0,0 +1,11 @@ +import re + + +def slugify(s: str) -> str: + s = s.encode("ascii", "ignore").decode() + s = re.sub(r"[^\w\s-]", "", s).strip().lower() + return re.sub(r"[\s_-]+", "-", s) + + +def normalize_path(path: str) -> str: + return "/" + "/".join(p for p in path.split("/") if p) diff --git a/managed_agents/example_data/orchestrate/tests/__init__.py b/managed_agents/example_data/orchestrate/tests/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/managed_agents/example_data/orchestrate/tests/test_urls.py b/managed_agents/example_data/orchestrate/tests/test_urls.py new file mode 100644 index 00000000..083aaec6 --- /dev/null +++ b/managed_agents/example_data/orchestrate/tests/test_urls.py @@ -0,0 +1,32 @@ +from datetime import date + +from src.blog import generate_author_url, generate_post_url +from src.url_utils import slugify + + +def test_slugify_basic(): + assert slugify("Hello World") == "hello-world" + + +def test_slugify_unicode(): + assert slugify("Café Culture") == "cafe-culture" + assert slugify("Naïve Résumé") == "naive-resume" + + +def test_slugify_special_chars(): + assert slugify("C++ & Python!") == "c-python" + + +def test_post_url_unicode(): + url = generate_post_url("Café Culture", date(2026, 3, 15)) + assert url == "/blog/2026/03/cafe-culture" + + +def test_author_url_unicode(): + assert generate_author_url("François Müller") == "/authors/francois-muller" + + +def test_normalize_path(): + from src.url_utils import normalize_path + + assert normalize_path("//blog///post") == "/blog/post" diff --git a/managed_agents/example_data/prompt_versioning_and_rollback/support_tickets.jsonl b/managed_agents/example_data/prompt_versioning_and_rollback/support_tickets.jsonl new file mode 100644 index 00000000..ae42816b --- /dev/null +++ b/managed_agents/example_data/prompt_versioning_and_rollback/support_tickets.jsonl @@ -0,0 +1,20 @@ +{"id": "TKT-1001", "subject": "API usage doubled on our account in March", "body": "Our API usage metrics show 4.1M requests in March, same as February. But the invoice charged us for 8.2M. Either the usage meter is double-counting or the bill is wrong. We need the duplicate charge reversed.", "priority": "P1", "team": "billing"} +{"id": "TKT-1002", "subject": "Rate limit tier not matching what we are paying for", "body": "We are seeing rate limit headers that indicate the Growth tier (5k rps) even though we upgraded to Scale (20k rps) on Feb 15. The March invoice charged us Scale pricing. So we are paying for limits we are not getting.", "priority": "P2", "team": "billing"} +{"id": "TKT-1003", "subject": "Request quota showing zero but we have prepaid volume", "body": "The API is returning quota-exceeded errors and the dashboard shows 0 remaining requests, but we prepaid for 10M this quarter and have only used 6.2M per our own logs. Either the quota counter is wrong or our prepay was not applied. We are being charged overage on volume we already paid for.", "priority": "P1", "team": "billing"} +{"id": "TKT-1004", "subject": "Need credit memo for unused API request volume", "body": "We prepaid for 10M requests in Q1 and only used 6.2M. Our contract says unused volume rolls into account credit. Please issue the credit memo so it shows on the April statement.", "priority": "P2", "team": "billing"} +{"id": "TKT-1005", "subject": "Cannot download usage report PDF for accounts payable", "body": "The billing portal lets me view the monthly usage breakdown but the Download PDF button returns a zero-byte file. Our AP team needs the PDF to attach to the payment record.", "priority": "P2", "team": "billing"} +{"id": "TKT-1006", "subject": "SSO login redirects to blank page", "body": "Since yesterday our SAML SSO flow completes but lands on a white screen at /auth/callback. Clearing cookies doesn't help. About 40 users affected.", "priority": "P1", "team": "auth"} +{"id": "TKT-1007", "subject": "Password reset email never arrives", "body": "Three of our contractors requested password resets this morning and none received the email. Checked spam. Their addresses are on a custom domain if that matters.", "priority": "P1", "team": "auth"} +{"id": "TKT-1008", "subject": "Service account locked out after key rotation", "body": "We rotated the service account key per your security advisory and now every request returns 401. The new key shows as active in the console but auth is failing in production.", "priority": "P0", "team": "auth"} +{"id": "TKT-1009", "subject": "2FA codes rejected after replacing phone", "body": "I set up a new phone and re-enrolled in the authenticator app but every code I enter says invalid. I'm locked out of the admin console. Backup codes were never saved.", "priority": "P1", "team": "auth"} +{"id": "TKT-1010", "subject": "OAuth consent screen shows wrong application name", "body": "When our end users go through the OAuth flow the consent dialog says 'Untitled App' instead of our registered product name. We updated branding two weeks ago.", "priority": "P2", "team": "auth"} +{"id": "TKT-1011", "subject": "Webhook payloads arriving out of order", "body": "Events fired in sequence A B C are hitting our endpoint as B A C about 5% of the time. We rely on ordering for our state machine. Started roughly 48 hours ago.", "priority": "P1", "team": "api-platform"} +{"id": "TKT-1012", "subject": "429 errors well below documented rate limit", "body": "We're getting 429 Too Many Requests at roughly 180 req/s but our plan allows 500 req/s. No other clients share this key. Reproducible from two regions.", "priority": "P0", "team": "api-platform"} +{"id": "TKT-1013", "subject": "Pagination cursor returns duplicate records", "body": "Walking the /v2/events list endpoint with the next_cursor value gives us the last 3 records of the previous page again at the top of the next page.", "priority": "P1", "team": "api-platform"} +{"id": "TKT-1014", "subject": "POST /ingest returns 500 intermittently", "body": "Roughly 1 in 200 POST requests to /ingest fail with a 500 and an empty body. Retrying the exact same payload succeeds. No pattern in payload size or content.", "priority": "P0", "team": "api-platform"} +{"id": "TKT-1015", "subject": "Response headers missing CORS allow-origin", "body": "Browser requests to /public/config started failing preflight this morning. The Access-Control-Allow-Origin header is absent on the OPTIONS response. Worked yesterday.", "priority": "P1", "team": "api-platform"} +{"id": "TKT-1016", "subject": "Charts not rendering in Safari 17", "body": "The overview dashboard loads but all chart panels are blank in Safari 17.3. Chrome and Firefox are fine. Console shows a canvas context error.", "priority": "P2", "team": "dashboard"} +{"id": "TKT-1017", "subject": "Export to CSV button does nothing", "body": "Clicking Export CSV on the activity log table has no effect. No download, no error toast, no network request in devtools. Tried three browsers.", "priority": "P2", "team": "dashboard"} +{"id": "TKT-1018", "subject": "Date range picker resets on page refresh", "body": "I set a custom 14-day range, the data loads correctly, but refreshing the page snaps back to Last 7 Days. The URL query string isn't updating.", "priority": "P2", "team": "dashboard"} +{"id": "TKT-1019", "subject": "Team member list shows users we removed", "body": "Two engineers we offboarded last month still appear in Settings > Team with active badges. They can't actually log in but it's confusing our compliance audit.", "priority": "P1", "team": "dashboard"} +{"id": "TKT-1020", "subject": "Dark mode toggle not persisting across sessions", "body": "I switch to dark mode, it applies, then logging out and back in reverts to light. Minor but our night-shift ops team asked me to file it.", "priority": "P2", "team": "dashboard"} diff --git a/managed_agents/example_data/slack_data_bot/slack_app_manifest.yaml b/managed_agents/example_data/slack_data_bot/slack_app_manifest.yaml new file mode 100644 index 00000000..cd544170 --- /dev/null +++ b/managed_agents/example_data/slack_data_bot/slack_app_manifest.yaml @@ -0,0 +1,23 @@ +display_information: + name: databot-cookbook + description: Data analyst agent. Mention with a CSV to get a report. +features: + bot_user: + display_name: databot + always_online: true +oauth_config: + scopes: + bot: + - app_mentions:read + - chat:write + - files:read + - files:write + - channels:history +settings: + event_subscriptions: + bot_events: + - app_mention + - message.channels + interactivity: + is_enabled: true + socket_mode_enabled: true diff --git a/managed_agents/example_data/slack_data_bot/slack_thread.png b/managed_agents/example_data/slack_data_bot/slack_thread.png new file mode 100644 index 00000000..024a0634 Binary files /dev/null and b/managed_agents/example_data/slack_data_bot/slack_thread.png differ diff --git a/managed_agents/example_data/sre/alert.json b/managed_agents/example_data/sre/alert.json new file mode 100644 index 00000000..62986495 --- /dev/null +++ b/managed_agents/example_data/sre/alert.json @@ -0,0 +1,24 @@ +{ + "event": { + "id": "01F3K8M2WQXYZ5R7ABCD", + "event_type": "incident.triggered", + "occurred_at": "2026-04-07T03:14:22Z", + "data": { + "id": "Q0ABCXYZ", + "type": "incident", + "title": "checkout-svc pods crash-looping (CrashLoopBackOff)", + "service": { + "id": "P123456", + "summary": "checkout-svc" + }, + "urgency": "high", + "status": "triggered", + "details": { + "cluster": "prod-us-east", + "namespace": "shop", + "deployment": "checkout-svc", + "restarts_5m": 7 + } + } + } +} diff --git a/managed_agents/example_data/sre/console_session.png b/managed_agents/example_data/sre/console_session.png new file mode 100644 index 00000000..8831fcbf Binary files /dev/null and b/managed_agents/example_data/sre/console_session.png differ diff --git a/managed_agents/example_data/sre/infra/k8s/checkout-deploy.yaml b/managed_agents/example_data/sre/infra/k8s/checkout-deploy.yaml new file mode 100644 index 00000000..992afabb --- /dev/null +++ b/managed_agents/example_data/sre/infra/k8s/checkout-deploy.yaml @@ -0,0 +1,32 @@ +apiVersion: apps/v1 +kind: Deployment +metadata: + name: checkout-svc + namespace: shop +spec: + replicas: 3 + selector: + matchLabels: + app: checkout-svc + template: + metadata: + labels: + app: checkout-svc + spec: + containers: + - name: checkout-svc + image: registry.internal/shop/checkout-svc:2026.04.06-r3 + ports: + - containerPort: 8080 + resources: + requests: + cpu: 250m + memory: 128Mi + limits: + cpu: 500m + memory: 128Mi + readinessProbe: + httpGet: + path: /healthz + port: 8080 + initialDelaySeconds: 5 diff --git a/managed_agents/example_data/sre/runbooks/oom.md b/managed_agents/example_data/sre/runbooks/oom.md new file mode 100644 index 00000000..6021795e --- /dev/null +++ b/managed_agents/example_data/sre/runbooks/oom.md @@ -0,0 +1,18 @@ +# Runbook: OOMKilled / OutOfMemoryError + +**Symptom:** container exits 137, `OOMKilled` in pod events, heap-exhausted +errors in application logs. + +**Triage:** + +1. Confirm the kill is the kubelet OOM killer (exit 137) and not an + application-level limit. +2. Open the deployment manifest under `infra/k8s/-deploy.yaml` + and check `spec.template.spec.containers[].resources.limits.memory`. +3. If the limit is below the service's documented working set (checkout-svc + needs ~400Mi after the pricing cache warms), raise the limit. 512Mi is + the standard next tier. +4. Keep `requests.memory` at or below the new limit. + +**Fix:** open a PR against the infra repo with the corrected limit. Do not +hot-patch the live deployment. diff --git a/managed_agents/pyproject.toml b/managed_agents/pyproject.toml new file mode 100644 index 00000000..603bd322 --- /dev/null +++ b/managed_agents/pyproject.toml @@ -0,0 +1,19 @@ +[project] +name = "managed-agents-cookbook" +version = "0.1.0" +description = "Runnable examples for the Claude Managed Agents API" +requires-python = ">=3.11,<3.13" +dependencies = [ + "anthropic>=0.91.0", + "python-dotenv", +] + +[project.optional-dependencies] +slack = [ + "slack_bolt", + "requests", + "markdown-to-mrkdwn", +] +dev = [ + "jupytext", +] diff --git a/managed_agents/slack_data_bot.ipynb b/managed_agents/slack_data_bot.ipynb new file mode 100644 index 00000000..617ccd93 --- /dev/null +++ b/managed_agents/slack_data_bot.ipynb @@ -0,0 +1,413 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-0", + "metadata": {}, + "source": [ + "# Build a Slack data analyst bot with Claude Managed Agents\n", + "\n", + "## Introduction\n", + "\n", + "You'll wrap the agent from\n", + "[`data_analyst_agent.ipynb`](data_analyst_agent.ipynb) in a\n", + "Slack bot built with\n", + "[Bolt for Python](https://docs.slack.dev/tools/bolt-python/), Slack's\n", + "official framework for building apps. Mention the bot with a question\n", + "and a CSV attachment to get a narrative report posted back to the\n", + "thread. Follow-up messages continue the same session.\n", + "\n", + " user: @databot what's driving Q1 revenue? [sales.csv]\n", + " │\n", + " ▼\n", + " bot uploads the CSV and starts an agent session\n", + " │\n", + " ▼\n", + " bot streams the agent's progress back to the thread\n", + " │\n", + " ▼\n", + " bot posts the finished report to the thread\n", + "\n", + "### What you'll learn\n", + "\n", + "- Kick off an agent run from a Slack mention\n", + "- Show the agent's progress as thread updates\n", + "- Post the finished report back to the thread\n", + "- Keep the conversation going with follow-up replies\n", + "\n", + "### Prerequisites\n", + "\n", + "1. Run the install cell below.\n", + "\n", + "2. Create a [Slack app](https://api.slack.com/apps): choose\n", + " **Create New App → From a manifest**, paste\n", + " [`slack_app_manifest.yaml`](example_data/slack_data_bot/slack_app_manifest.yaml), and install\n", + " it to your workspace. The manifest enables Socket Mode (Slack\n", + " delivers events over a WebSocket, so you don't need a public URL)\n", + " and the required scopes. Then grab two tokens:\n", + "\n", + " - **OAuth & Permissions** → copy the Bot User OAuth Token\n", + " (`xoxb-...`)\n", + " - **Basic Information → App-Level Tokens** → generate one with\n", + " scope `connections:write` (`xapp-...`)\n", + "\n", + " In a channel you want the bot in, run `/invite @databot`.\n", + "\n", + "3. Run [`data_analyst_agent.ipynb`](data_analyst_agent.ipynb),\n", + " which saves `ANALYST_ENV_ID`, `ANALYST_AGENT_ID`, and\n", + " `ANALYST_AGENT_VERSION` to `.env`.\n", + "\n", + "The setup cell below prompts for your Slack tokens and saves them to\n", + "`.env` so you don't re-enter them on restart (or add them to `.env`\n", + "beforehand to skip the prompt). `.env` is already in `.gitignore` –\n", + "never commit it to version control. If you don't have a Slack\n", + "workspace handy you can still read through the code – each section\n", + "explains what it does – but you'll need one to run the bot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-1", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "%pip install -q \"anthropic>=0.91.0\" python-dotenv slack_bolt requests markdown-to-mrkdwn" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-2", + "metadata": { + "lines_to_next_cell": 1 + }, + "outputs": [], + "source": [ + "import io\n", + "import os\n", + "import threading\n", + "from getpass import getpass\n", + "\n", + "import requests\n", + "from anthropic import Anthropic\n", + "from dotenv import load_dotenv, set_key\n", + "from markdown_to_mrkdwn import SlackMarkdownConverter\n", + "from slack_bolt import App\n", + "from slack_bolt.adapter.socket_mode import SocketModeHandler\n", + "\n", + "load_dotenv(override=True)\n", + "\n", + "# Prompt for Slack tokens on first run and save them to .env.\n", + "for key in (\"SLACK_BOT_TOKEN\", \"SLACK_APP_TOKEN\"):\n", + " if not os.environ.get(key):\n", + " os.environ[key] = getpass(f\"{key}: \")\n", + " set_key(\".env\", key, os.environ[key])\n", + "\n", + "client = Anthropic()\n", + "app = App(token=os.environ[\"SLACK_BOT_TOKEN\"])\n", + "\n", + "for key in (\"ANALYST_ENV_ID\", \"ANALYST_AGENT_ID\", \"ANALYST_AGENT_VERSION\"):\n", + " if not os.environ.get(key):\n", + " raise RuntimeError(f\"{key} not set. Run data_analyst_agent.ipynb first.\")\n", + "\n", + "# Set these from the IDs saved by the data analyst notebook. Reusing\n", + "# the agent and environment avoids re-provisioning on every bot restart.\n", + "ANALYST_AGENT = {\n", + " \"id\": os.environ[\"ANALYST_AGENT_ID\"],\n", + " \"version\": int(os.environ[\"ANALYST_AGENT_VERSION\"]),\n", + "}\n", + "ANALYST_ENV_ID = os.environ[\"ANALYST_ENV_ID\"]\n", + "\n", + "# thread_ts -> session_id, so follow-ups land in the same session.\n", + "# Sessions stay open for replies. In production, persist this and\n", + "# archive sessions when threads go stale.\n", + "thread_sessions: dict[str, str] = {}\n", + "\n", + "mrkdwn = SlackMarkdownConverter()" + ] + }, + { + "cell_type": "markdown", + "id": "cell-3", + "metadata": {}, + "source": [ + "## 1. Start a session when the bot is mentioned\n", + "\n", + "Bolt passes an `ack` callback into every handler; calling it tells\n", + "Slack the event was received. Slack retries anything not acknowledged\n", + "[within three seconds](https://docs.slack.dev/apis/events-api/#responding),\n", + "so `on_mention` calls `ack()` immediately and hands the slow work\n", + "(file upload, session creation, streaming) to `start_analysis` on a\n", + "background thread.\n", + "\n", + "Each mention creates a session you can open in the\n", + "[Console](https://platform.claude.com/) under **Sessions** to\n", + "watch the full trace." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-4", + "metadata": { + "lines_to_next_cell": 1 + }, + "outputs": [], + "source": [ + "@app.event(\"app_mention\")\n", + "def on_mention(event, say, ack):\n", + " ack()\n", + " channel = event[\"channel\"]\n", + " thread_ts = event.get(\"thread_ts\") or event[\"ts\"]\n", + " # Mention text arrives as \"<@BOTID> question\"; drop the mention prefix.\n", + " question = event[\"text\"].split(\">\", 1)[-1].strip()\n", + " slack_file = (event.get(\"files\") or [None])[0]\n", + "\n", + " say(text=\"On it. Analyzing now.\", thread_ts=thread_ts)\n", + " # Run the slow work in a background thread so this handler\n", + " # returns within Slack's 3s limit.\n", + " threading.Thread(target=start_analysis, args=(channel, thread_ts, question, slack_file)).start()\n", + "\n", + "\n", + "def start_analysis(channel: str, thread_ts: str, question: str, slack_file: dict | None) -> None:\n", + " try:\n", + " # If the mention had a file attached, pull it from Slack and\n", + " # re-upload to the Anthropic Files API so the session can mount it.\n", + " resources = []\n", + " if slack_file:\n", + " resp = requests.get(\n", + " slack_file[\"url_private\"],\n", + " headers={\"Authorization\": f\"Bearer {app.client.token}\"},\n", + " timeout=30,\n", + " )\n", + " resp.raise_for_status()\n", + " mime = slack_file.get(\"mimetype\", \"text/csv\")\n", + " uploaded = client.beta.files.upload(\n", + " file=(slack_file[\"name\"], io.BytesIO(resp.content), mime)\n", + " )\n", + " mount = \"/mnt/session/uploads/data.csv\"\n", + " resources.append({\"type\": \"file\", \"file_id\": uploaded.id, \"mount_path\": mount})\n", + " question += f\"\\n\\nThe data is mounted at {mount}.\"\n", + "\n", + " # One session per Slack thread. Store the thread coordinates in\n", + " # metadata so anyone reading the event stream knows where to reply.\n", + " session = client.beta.sessions.create(\n", + " environment_id=ANALYST_ENV_ID,\n", + " agent={\"type\": \"agent\", **ANALYST_AGENT},\n", + " resources=resources,\n", + " # Titles are capped at 80 chars and can't contain Unicode\n", + " # control/format characters (Slack sometimes inserts them).\n", + " title=\"\".join(c for c in question if c.isprintable())[:80],\n", + " metadata={\"slack_channel\": channel, \"slack_thread_ts\": thread_ts},\n", + " )\n", + " thread_sessions[thread_ts] = session.id\n", + "\n", + " # Send the question as a user.message event. The agent starts\n", + " # working immediately; relay_stream posts its progress to the thread.\n", + " client.beta.sessions.events.send(\n", + " session.id,\n", + " events=[{\"type\": \"user.message\", \"content\": [{\"type\": \"text\", \"text\": question}]}],\n", + " )\n", + " relay_stream(session.id, channel, thread_ts)\n", + " except Exception as e:\n", + " app.client.chat_postMessage(\n", + " channel=channel, thread_ts=thread_ts, text=f\"Analysis failed: {type(e).__name__}: {e}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "cell-5", + "metadata": {}, + "source": [ + "## 2. Relay progress and results to the thread\n", + "\n", + "The `relay_stream` function defined below is the bridge between the\n", + "two APIs: it reads from the Anthropic session event stream and posts\n", + "to Slack. It loops until the agent goes idle, then posts the final\n", + "summary and uploads any files the agent wrote.\n", + "\n", + "`files.list(scope_id=...)` returns every file in the session – both\n", + "the CSV we uploaded and anything the agent wrote. We filter to\n", + "`downloadable == True` so only agent-generated outputs (the report,\n", + "charts) get posted back to Slack, not the user's own input." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-6", + "metadata": { + "lines_to_next_cell": 1 + }, + "outputs": [], + "source": [ + "def relay_stream(session_id: str, channel: str, thread_ts: str) -> None:\n", + " summary = \"\"\n", + " posted_progress = False\n", + " for ev in client.beta.sessions.events.stream(session_id):\n", + " t = ev.type\n", + " if t == \"agent.message\":\n", + " # Keep the latest text block; it becomes the final summary.\n", + " for b in ev.content:\n", + " if b.type == \"text\" and b.text.strip():\n", + " summary = b.text\n", + " elif t == \"agent.tool_use\" and not posted_progress:\n", + " # Post a one-time progress update when the agent starts\n", + " # running commands.\n", + " app.client.chat_postMessage(\n", + " channel=channel, thread_ts=thread_ts, text=\"Running analysis...\"\n", + " )\n", + " posted_progress = True\n", + " elif t == \"session.status_idle\":\n", + " break\n", + " elif t == \"session.status_terminated\":\n", + " trace = f\"https://platform.claude.com/sessions/{session_id}\"\n", + " app.client.chat_postMessage(\n", + " channel=channel,\n", + " thread_ts=thread_ts,\n", + " text=f\"Session terminated unexpectedly. Trace: {trace}\",\n", + " )\n", + " return\n", + "\n", + " # Turn is done. Post the summary, then upload any generated files.\n", + " if summary:\n", + " text = mrkdwn.convert(summary)\n", + " if len(text) > 3900: # Slack text limit ~4000 chars\n", + " text = text[:3900] + \"\\n_(truncated)_\"\n", + " app.client.chat_postMessage(channel=channel, thread_ts=thread_ts, text=text)\n", + " outputs = client.beta.files.list(scope_id=session_id, betas=[\"managed-agents-2026-04-01\"])\n", + " for f in outputs.data:\n", + " if not f.downloadable:\n", + " continue\n", + " content = client.beta.files.download(f.id).read()\n", + " app.client.files_upload_v2(\n", + " channel=channel, thread_ts=thread_ts, filename=f.filename, content=content\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "cell-7", + "metadata": {}, + "source": [ + "## 3. Handle follow-ups in the same session\n", + "\n", + "A reply in the thread becomes another turn in the existing\n", + "session – you don't need to `@mention` the bot again. The container\n", + "filesystem and conversation history persist across turns." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-8", + "metadata": { + "lines_to_next_cell": 1 + }, + "outputs": [], + "source": [ + "def continue_session(session_id: str, channel: str, thread_ts: str, text: str) -> None:\n", + " try:\n", + " client.beta.sessions.events.send(\n", + " session_id,\n", + " events=[{\"type\": \"user.message\", \"content\": [{\"type\": \"text\", \"text\": text}]}],\n", + " )\n", + " relay_stream(session_id, channel, thread_ts)\n", + " except Exception as e:\n", + " app.client.chat_postMessage(\n", + " channel=channel, thread_ts=thread_ts, text=f\"Analysis failed: {type(e).__name__}: {e}\"\n", + " )\n", + "\n", + "\n", + "@app.event(\"message\")\n", + "def on_thread_reply(event, ack):\n", + " ack()\n", + " thread_ts = event.get(\"thread_ts\")\n", + " # Only handle human replies in a thread where we already started\n", + " # a session. Skip edits/deletes and other message subtypes.\n", + " if event.get(\"subtype\"):\n", + " return\n", + " if not thread_ts or event.get(\"bot_id\") or thread_ts not in thread_sessions:\n", + " return\n", + " threading.Thread(\n", + " target=continue_session,\n", + " args=(thread_sessions[thread_ts], event[\"channel\"], thread_ts, event[\"text\"]),\n", + " ).start()" + ] + }, + { + "cell_type": "markdown", + "id": "cell-9", + "metadata": {}, + "source": [ + "## 4. Run the bot\n", + "\n", + "The cell below connects to Slack and starts listening. It blocks\n", + "while the bot runs – stop it with the ■ interrupt button when\n", + "you're done.\n", + "\n", + "In any channel the bot is in, mention it with a CSV attached. It\n", + "posts progress, then the summary and `report.html` in the thread:\n", + "\n", + "\"Slack\n", + "\n", + "Reply in-thread to go deeper on the same data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-10", + "metadata": {}, + "outputs": [], + "source": [ + "SocketModeHandler(app, os.environ[\"SLACK_APP_TOKEN\"]).start()" + ] + }, + { + "cell_type": "markdown", + "id": "cell-11", + "metadata": { + "lines_to_next_cell": 2 + }, + "source": [ + "## Next steps\n", + "\n", + "You've wrapped the analyst agent in a Slack bot: mentions start a\n", + "session, the event stream relays progress to the thread, outputs get\n", + "uploaded, and replies continue the same conversation.\n", + "\n", + "- Swap the agent's system prompt in\n", + " [`data_analyst_agent.ipynb`](data_analyst_agent.ipynb) to\n", + " change its analysis style. Re-running that notebook creates a new\n", + " agent and saves its ID to `.env` for the bot to pick up.\n", + "- Persist `thread_sessions` to a database so conversations survive\n", + " bot restarts.\n", + "- Move the bot out of this notebook: copy the code to a `.py` file\n", + " and deploy it anywhere that can hold a long-lived WebSocket\n", + " connection." + ] + } + ], + "metadata": { + "jupytext": { + "cell_metadata_filter": "-all" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "pygments_lexer": "ipython3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/managed_agents/sre_incident_responder.ipynb b/managed_agents/sre_incident_responder.ipynb new file mode 100644 index 00000000..ee356324 --- /dev/null +++ b/managed_agents/sre_incident_responder.ipynb @@ -0,0 +1,945 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1da146f8", + "metadata": {}, + "source": [ + "# Build an SRE Incident Response Agent with Claude Managed Agents\n", + "\n", + "## Introduction\n", + "\n", + "When a production alert fires at 3 a.m., someone has to pull the\n", + "logs, find the right runbook, trace the misconfiguration, open a PR,\n", + "and get it approved. An agent can take that first pass for you and\n", + "have a fix waiting for review by the time you're at the keyboard \u2014 as\n", + "long as it has the right context and a human makes the final call.\n", + "\n", + "[Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview)\n", + "gives you the scalable infrastructure, sandboxing, & security pieces to build that with ease. In this\n", + "tutorial you'll wire them together:\n", + "\n", + "- A simulated **PagerDuty webhook** triggers your Claude Managed Agent with one API call.\n", + "- A **Skill** teaches the agent your team's runbook conventions, so it\n", + " knows where to look.\n", + "- The built-in `bash`/`read`/`edit` tools let it investigate logs and\n", + " infrastructure code in a sandbox.\n", + "- **Custom tools** let it open a pull request and ask a human to\n", + " approve before merging \u2014 your code handles those calls, so you\n", + " decide what \"open a PR\" actually does.\n", + "- The **Anthropic Console** records every step automatically, providing you complete observability.\n", + "\n", + "Everything below runs with only `ANTHROPIC_API_KEY`. PagerDuty,\n", + "GitHub, and Datadog are mocked with local fixtures so you can focus on\n", + "the Managed Agents pieces; the closing section shows how to swap each\n", + "mock for the real service.\n", + "\n", + "### What you'll learn\n", + "\n", + "- Upload a Skill and attach it to a Claude Managed Agent\n", + "- Mix the built-in toolset with custom tools your application handles\n", + "- Start a session from a webhook payload\n", + "- Gate a destructive action behind human approval\n", + "- Read the full session trace in the Console\n", + "\n", + "### Prerequisites\n", + "\n", + "Set `ANTHROPIC_API_KEY` in your environment, then install\n", + "dependencies:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "aa689574", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-07T19:05:15.765613Z", + "iopub.status.busy": "2026-04-07T19:05:15.765210Z", + "iopub.status.idle": "2026-04-07T19:05:16.038864Z", + "shell.execute_reply": "2026-04-07T19:05:16.038091Z" + } + }, + "outputs": [], + "source": [ + "%pip install -q \"anthropic>=0.91.0\" python-dotenv" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4b666b73", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-07T19:05:16.040759Z", + "iopub.status.busy": "2026-04-07T19:05:16.040601Z", + "iopub.status.idle": "2026-04-07T19:05:16.271925Z", + "shell.execute_reply": "2026-04-07T19:05:16.271430Z" + } + }, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "import time\n", + "from pathlib import Path\n", + "\n", + "from anthropic import Anthropic\n", + "from dotenv import load_dotenv\n", + "from utilities import wait_for_idle_status\n", + "\n", + "load_dotenv()\n", + "client = Anthropic()\n", + "MODEL = os.getenv(\"COOKBOOK_MODEL\", \"claude-opus-4-6\")\n", + "FIXTURE = Path(\"example_data/sre\")" + ] + }, + { + "cell_type": "markdown", + "id": "8e52a81d", + "metadata": {}, + "source": [ + "## 1. Upload a runbook skill\n", + "\n", + "A\n", + "[**Skill**](https://platform.claude.com/docs/en/managed-agents/skills)\n", + "is a small filesystem bundle the platform mounts into the agent's\n", + "context with progressive disclosure: the agent sees a one-line\n", + "description up front and reads the body only when it's relevant. It's\n", + "a good place for team conventions that shouldn't live in the system\n", + "prompt.\n", + "\n", + "The sample skill below encodes one rule \u2014 *consult the runbook before\n", + "touching infrastructure* \u2014 the way a real team playbook would. You\n", + "upload it once via the Skills API and reference it by ID on every\n", + "agent that needs it.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6ec76071", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-07T19:05:16.273225Z", + "iopub.status.busy": "2026-04-07T19:05:16.273157Z", + "iopub.status.idle": "2026-04-07T19:05:17.682427Z", + "shell.execute_reply": "2026-04-07T19:05:17.681789Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "skill: skill_01WPWHALbtEVBUWG6mHa7Tna (version 1775588716519983)\n" + ] + } + ], + "source": [ + "# A real skill is usually a folder on disk (SKILL.md plus any helper\n", + "# scripts or reference docs) that you zip and upload. For this tutorial\n", + "# the SKILL.md is small enough to keep inline.\n", + "RUNBOOK_SKILL = \"\"\"\\\n", + "---\n", + "name: incident-runbooks\n", + "description: How to triage production incidents using the team runbooks.\n", + "---\n", + "\n", + "# Incident runbooks\n", + "\n", + "When an alert references a service, locate that service's recent logs\n", + "and identify the failure signature (the repeating error class, exit\n", + "code, or status pattern).\n", + "\n", + "Consult the team runbooks before proposing any fix. Runbooks are\n", + "organised by failure signature \u2014 for example `oom.md`, `5xx.md`,\n", + "`latency.md`. Each one lists the triage steps for that class of\n", + "failure and the configuration that usually needs to change.\n", + "\n", + "Any fix to infrastructure code must be opened as a pull request that\n", + "cites the runbook you followed. Do not patch live resources directly.\n", + "\"\"\"\n", + "\n", + "skill = client.beta.skills.create(\n", + " display_title=\"incident-runbooks\",\n", + " files=[(\"incident-runbooks/SKILL.md\", RUNBOOK_SKILL.encode(), \"text/markdown\")],\n", + ")\n", + "print(f\"skill: {skill.id} (version {skill.latest_version})\")" + ] + }, + { + "cell_type": "markdown", + "id": "07d87a21", + "metadata": {}, + "source": [ + "## 2. Create the agent\n", + "\n", + "The agent's `tools` list combines three kinds of capability:\n", + "\n", + "- [`agent_toolset_20260401`](https://platform.claude.com/docs/en/managed-agents/tools)\n", + " \u2014 the built-in `bash`, `read`, `grep`, `edit`, \u2026 tools that run\n", + " *inside* the sandbox. The agent uses these to investigate.\n", + "- The runbook **skill** from step 1.\n", + "- Three **custom tools** \u2014 `open_pull_request`, `request_approval`,\n", + " and `merge_pull_request` \u2014 that the agent can call but *your\n", + " application* executes. They're how the agent reaches systems\n", + " outside the sandbox, and how you put a human in the loop.\n", + "\n", + "The system prompt is persona and workflow only. The alert itself\n", + "arrives as the first user event, so the same agent handles any\n", + "incident.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "677be30f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-07T19:05:17.686047Z", + "iopub.status.busy": "2026-04-07T19:05:17.685791Z", + "iopub.status.idle": "2026-04-07T19:05:17.958352Z", + "shell.execute_reply": "2026-04-07T19:05:17.957421Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "agent: agent_011CZpw3Y76Vu4t2j2QEosVa v1\n" + ] + } + ], + "source": [ + "SRE_SYSTEM_PROMPT = \"\"\"\\\n", + "You are an on-call SRE agent. Each user message is a PagerDuty alert\n", + "payload. Triage it to root cause and ship the minimal safe fix.\n", + "\n", + "The session workspace contains the recent logs, the infrastructure\n", + "repo, and the team runbooks for the alerting service. Explore it to\n", + "find what you need.\n", + "\n", + "Workflow for every alert:\n", + "1. Read the logs and identify the failure signature.\n", + "2. Find the root cause in the infrastructure repo, save a copy of the\n", + " original file, edit it in place, then produce a unified diff with\n", + " `diff -u`.\n", + "3. open_pull_request(title, body, diff) with the fix.\n", + "4. request_approval(summary) and wait for the human's decision.\n", + "5. Only if the result is \"approved\", merge_pull_request(pr_number).\n", + " Otherwise stop and report.\n", + "\n", + "Never call merge_pull_request unless request_approval returned\n", + "\"approved\". Keep the fix minimal \u2014 do not refactor unrelated config.\n", + "\"\"\"\n", + "\n", + "agent = client.beta.agents.create(\n", + " name=\"cookbook-sre-responder\",\n", + " model=MODEL,\n", + " system=SRE_SYSTEM_PROMPT,\n", + " skills=[{\"type\": \"custom\", \"skill_id\": skill.id, \"version\": skill.latest_version}],\n", + " tools=[\n", + " {\n", + " \"type\": \"agent_toolset_20260401\",\n", + " \"default_config\": {\n", + " \"enabled\": True,\n", + " \"permission_policy\": {\"type\": \"always_allow\"},\n", + " },\n", + " \"configs\": [\n", + " {\"name\": \"web_search\", \"enabled\": False},\n", + " {\"name\": \"web_fetch\", \"enabled\": False},\n", + " ],\n", + " },\n", + " {\n", + " \"type\": \"custom\",\n", + " \"name\": \"open_pull_request\",\n", + " \"description\": \"Open a pull request against the infra repo with the proposed fix.\",\n", + " \"input_schema\": {\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"title\": {\"type\": \"string\"},\n", + " \"body\": {\"type\": \"string\"},\n", + " \"diff\": {\"type\": \"string\", \"description\": \"Unified diff of the change.\"},\n", + " },\n", + " \"required\": [\"title\", \"body\", \"diff\"],\n", + " },\n", + " },\n", + " {\n", + " \"type\": \"custom\",\n", + " \"name\": \"request_approval\",\n", + " \"description\": \"Ask the on-call human to approve the proposed PR before merging.\",\n", + " \"input_schema\": {\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"summary\": {\"type\": \"string\"},\n", + " },\n", + " \"required\": [\"summary\"],\n", + " },\n", + " },\n", + " {\n", + " \"type\": \"custom\",\n", + " \"name\": \"merge_pull_request\",\n", + " \"description\": \"Merge an approved pull request.\",\n", + " \"input_schema\": {\n", + " \"type\": \"object\",\n", + " \"properties\": {\n", + " \"pr_number\": {\"type\": \"integer\"},\n", + " },\n", + " \"required\": [\"pr_number\"],\n", + " },\n", + " },\n", + " ],\n", + ")\n", + "print(f\"agent: {agent.id} v{agent.version}\")" + ] + }, + { + "cell_type": "markdown", + "id": "172173a2", + "metadata": {}, + "source": [ + "## 3. Create an environment and mount the data\n", + "\n", + "The agent needs three things in its workspace to investigate: the\n", + "recent service logs, the infrastructure repo, and the team runbooks.\n", + "Upload each via the Files API and list them as `resources` so they're\n", + "mounted into every session at the paths the system prompt expects. A\n", + "`limited`-networking cloud environment is enough because the agent\n", + "only needs its own filesystem.\n", + "\n", + "To keep this notebook runnable with only `ANTHROPIC_API_KEY`, the\n", + "infra \"repo\" is a single manifest with a too-low `memory: 128Mi`\n", + "limit. In production you'd replace that upload with a\n", + "`github_repository` resource that clones the real repo straight into\n", + "the sandbox:\n", + "\n", + "```python\n", + "{\n", + " \"type\": \"github_repository\",\n", + " \"url\": \"https://github.com/your-org/infra\",\n", + " \"authorization_token\": os.environ[\"GITHUB_TOKEN\"],\n", + " \"checkout\": {\"type\": \"branch\", \"name\": \"main\"},\n", + " \"mount_path\": \"infra\",\n", + "}\n", + "```\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "176398ab", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-07T19:05:17.961307Z", + "iopub.status.busy": "2026-04-07T19:05:17.961049Z", + "iopub.status.idle": "2026-04-07T19:05:19.659336Z", + "shell.execute_reply": "2026-04-07T19:05:19.655932Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "environment: env_01R6hmJkd6BhpPotXnoC7rqU\n" + ] + } + ], + "source": [ + "env = client.beta.environments.create(\n", + " name=\"cookbook-sre-env\",\n", + " config={\"type\": \"cloud\", \"networking\": {\"type\": \"limited\"}},\n", + ")\n", + "\n", + "\n", + "def upload(path: Path, mime: str) -> str:\n", + " with path.open(\"rb\") as f:\n", + " return client.beta.files.upload(file=(path.name, f, mime)).id\n", + "\n", + "\n", + "log_id = upload(FIXTURE / \"logs/checkout-svc.log\", \"text/plain\")\n", + "manifest_id = upload(FIXTURE / \"infra/k8s/checkout-deploy.yaml\", \"text/yaml\")\n", + "runbook_id = upload(FIXTURE / \"runbooks/oom.md\", \"text/markdown\")\n", + "\n", + "RESOURCES = [\n", + " {\"type\": \"file\", \"file_id\": log_id, \"mount_path\": \"logs/checkout-svc.log\"},\n", + " {\"type\": \"file\", \"file_id\": manifest_id, \"mount_path\": \"infra/k8s/checkout-deploy.yaml\"},\n", + " {\"type\": \"file\", \"file_id\": runbook_id, \"mount_path\": \"runbooks/oom.md\"},\n", + "]\n", + "print(f\"environment: {env.id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "a05047d1", + "metadata": { + "lines_to_next_cell": 2 + }, + "source": [ + "## 4. Handle the incident alert\n", + "\n", + "The handler below is the one function you'd deploy \u2014 a Flask or\n", + "FastAPI route that your alerting system calls when an incident fires.\n", + "It creates a session referencing the agent and environment, mounts\n", + "the data, and sends the alert JSON as the first `user.message` event.\n", + "This example uses a [PagerDuty V3\n", + "webhook](https://developer.pagerduty.com/docs/webhooks-overview)\n", + "payload, but any pager that can POST JSON works the same way; here\n", + "you call the handler directly with the fixture.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9202d90a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-07T19:05:19.665311Z", + "iopub.status.busy": "2026-04-07T19:05:19.663928Z", + "iopub.status.idle": "2026-04-07T19:05:23.375057Z", + "shell.execute_reply": "2026-04-07T19:05:23.373972Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "session: sesn_011CZpw3gtC691y7qmaLNmLM\n" + ] + } + ], + "source": [ + "def handle_pagerduty_webhook(payload: dict) -> str:\n", + " incident = payload[\"event\"][\"data\"]\n", + " session = client.beta.sessions.create(\n", + " environment_id=env.id,\n", + " agent={\"type\": \"agent\", \"id\": agent.id, \"version\": agent.version},\n", + " resources=RESOURCES,\n", + " title=f\"[{incident['service']['summary']}] {incident['title']}\",\n", + " )\n", + " client.beta.sessions.events.send(\n", + " session.id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.message\",\n", + " \"content\": [{\"type\": \"text\", \"text\": json.dumps(payload, indent=2)}],\n", + " }\n", + " ],\n", + " )\n", + " return session.id\n", + "\n", + "\n", + "with (FIXTURE / \"alert.json\").open() as f:\n", + " alert = json.load(f)\n", + "\n", + "session_id = handle_pagerduty_webhook(alert)\n", + "print(f\"session: {session_id}\")" + ] + }, + { + "cell_type": "markdown", + "id": "19308db5", + "metadata": {}, + "source": [ + "## 5. Service the agent's custom tool calls\n", + "\n", + "This is where the built-in tools and your custom tools come together.\n", + "The agent's `read`/`bash`/`edit` calls run on the container and\n", + "appear in the event log as `agent.tool_use` \u2014 that's the\n", + "investigation, and you just print it. But when the agent calls one of\n", + "your custom tools, the session goes `idle` with\n", + "`stop_reason.type == \"requires_action\"` and waits for *your\n", + "application* to respond with a `user.custom_tool_result`.\n", + "\n", + "The loop below polls `events.list`, answers `open_pull_request` and\n", + "`merge_pull_request` inline by writing to a local list \u2014 that's the\n", + "GitHub mock \u2014 but **returns** when `request_approval` arrives,\n", + "because that one needs a human.\n", + "\n", + "In production, \"needs a human\" usually means *post it to Slack*: drop\n", + "the agent's summary into the on-call channel with an **Approve**\n", + "button, and send the result back when someone clicks. The\n", + "[`slack_data_bot` cookbook](slack_data_bot.ipynb) shows the Bolt\n", + "wiring for that; here you'll approve inline in the next cell so the\n", + "notebook stays self-contained.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8e72c668", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-07T19:05:23.377841Z", + "iopub.status.busy": "2026-04-07T19:05:23.377628Z", + "iopub.status.idle": "2026-04-07T19:06:30.124348Z", + "shell.execute_reply": "2026-04-07T19:06:30.123479Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "I'll help you triage this production incident. The alert shows checkout-svc pods are crash-looping with 7 restarts in 5 minutes. Let me start by exploring the workspace to find logs and the infrastructure configuration.\n", + " [bash]\n", + "Let me check the session directory for logs and infrastructure files:\n", + " [bash]\n", + "Perfect! Let me examine the logs first to identify the failure signature:\n", + " [read]\n", + "Perfect! I've identified the failure signature. The logs show a clear **OutOfMemoryError** pattern:\n", + "\n", + "**Failure Signature:**\n", + "- Service starts and warms pricing cache (14,092 entries)\n", + "- Heap memory grows rapidly: 101MB \u2192 118MB \u2192 121MB (against 128MB limit)\n", + "- `pricing.recompute` function attempts allocation during garbage collection pause (412ms GC pause observed)\n", + "- Container gets OOMKilled (exit 137) after ~2 minutes\n", + "- Service restarts and immediately repeats the cycle\n", + "\n", + "Now let me examine the deployment configuration to identify the root cause:\n", + " [read]\n", + "**Root Cause Analysis:**\n", + "\n", + "The deployment has memory limits set to **128Mi** (both request and limit). From the logs, I can see:\n", + "\n", + "1. **Pricing cache loads 14,092 entries** during startup (lines 9, 23, 32)\n", + "2. **Heap pressure builds immediately:**\n", + " - After 90 seconds: 101MB (79% of 128MB)\n", + " - After 110 seconds: 118MB (92% of 128MB) \n", + " - After 120 seconds: 121MB (94% of 128MB)\n", + "3. **Pricing recompute fails** to allocate 8MB (lines 15-16, 26-27, 34)\n", + "4. **Consistent pattern:** OOMKilled every ~2 minutes on all restarts\n", + "\n", + "The memory limit is **insufficient** for:\n", + "- Service startup + dependencies\n", + "- Pricing cache (14k+ entries)\n", + "- Normal operation headroom\n", + "- GC operations (412ms pause observed suggests high memory pressure)\n", + "\n", + "**Fix:** Increase memory limits to provide adequate headroom for the pricing cache workload.\n", + "\n", + "Let me create a backup and apply the fix:\n", + " [bash]\n", + "Now I'll update the memory limits to 512Mi (4x current limit, which is standard practice for memory-pressure issues):\n", + " [edit]\n", + "Let me copy to a writable location and work there:\n", + " [bash]\n", + "Now let me edit the file with the memory increase:\n", + " [edit]\n", + "Now let me create a unified diff:\n", + " [bash]\n", + "Perfect! Now let me open a pull request with this fix:\n", + "\u2192 open_pull_request\n", + "\n", + "\u2500\u2500 PR #1: Fix checkout-svc OOMKilled crash-loop by increasing memory limits \u2500\u2500\n", + "Excellent! PR #1 has been created. Now requesting approval from the on-call engineer:\n", + "\u2192 request_approval\n" + ] + } + ], + "source": [ + "prs: list[dict] = []\n", + "pending_approvals: list[dict] = []\n", + "seen_events: set[str] = set()\n", + "\n", + "\n", + "def handle_custom_tool(name: str, args: dict) -> dict:\n", + " if name == \"open_pull_request\":\n", + " n = len(prs) + 1\n", + " prs.append({\"number\": n, \"merged\": False, **args})\n", + " print(f\"\\n\u2500\u2500 PR #{n}: {args['title']} \u2500\u2500\")\n", + " return {\"pr_number\": n, \"url\": f\"mock://infra/pull/{n}\"}\n", + " if name == \"merge_pull_request\":\n", + " prs[args[\"pr_number\"] - 1][\"merged\"] = True\n", + " return {\"merged\": True}\n", + " raise ValueError(f\"unhandled tool {name}\")\n", + "\n", + "\n", + "def run_until_approval_or_end(session_id: str) -> str | None:\n", + " \"\"\"Poll the session's event log, servicing custom tools, until either\n", + " a request_approval call arrives (return its event_id so the caller\n", + " can respond) or the agent ends its turn (return None).\"\"\"\n", + " custom_calls: dict[str, object] = {}\n", + " responded: set[str] = set()\n", + " while True:\n", + " idle_stop = None\n", + " for ev in client.beta.sessions.events.list(session_id):\n", + " if ev.id in seen_events:\n", + " continue\n", + " seen_events.add(ev.id)\n", + " if ev.type == \"agent.message\":\n", + " for block in ev.content:\n", + " if block.type == \"text\":\n", + " print(block.text, end=\"\")\n", + " elif ev.type == \"agent.tool_use\":\n", + " print(f\"\\n [{ev.name}]\")\n", + " elif ev.type == \"agent.custom_tool_use\":\n", + " custom_calls[ev.id] = ev\n", + " print(f\"\\n\u2192 {ev.name}\")\n", + " elif ev.type == \"session.status_idle\":\n", + " idle_stop = ev.stop_reason\n", + " elif ev.type == \"session.status_terminated\":\n", + " return None\n", + " if idle_stop is None:\n", + " time.sleep(1.0)\n", + " continue\n", + " if idle_stop.type == \"end_turn\":\n", + " return None\n", + " if idle_stop.type == \"requires_action\":\n", + " for event_id in idle_stop.event_ids:\n", + " if event_id in responded:\n", + " continue\n", + " call = custom_calls[event_id]\n", + " if call.name == \"request_approval\":\n", + " pending_approvals.append({\"event_id\": event_id, **call.input})\n", + " return event_id\n", + " result = handle_custom_tool(call.name, call.input)\n", + " client.beta.sessions.events.send(\n", + " session_id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.custom_tool_result\",\n", + " \"custom_tool_use_id\": event_id,\n", + " \"content\": [{\"type\": \"text\", \"text\": json.dumps(result)}],\n", + " }\n", + " ],\n", + " )\n", + " responded.add(event_id)\n", + " time.sleep(1.0)\n", + "\n", + "\n", + "approval_event_id = run_until_approval_or_end(session_id)" + ] + }, + { + "cell_type": "markdown", + "id": "186ea378", + "metadata": {}, + "source": [ + "The agent has read the logs, matched the `OOMKilled` signature to\n", + "`runbooks/oom.md` via the skill, found the 128Mi memory limit in\n", + "`infra/k8s/checkout-deploy.yaml`, edited it, opened a PR, and is now\n", + "waiting on you. This is the message that would land in your `#oncall`\n", + "Slack channel:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0b377ac2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-07T19:06:30.126704Z", + "iopub.status.busy": "2026-04-07T19:06:30.126539Z", + "iopub.status.idle": "2026-04-07T19:06:30.131387Z", + "shell.execute_reply": "2026-04-07T19:06:30.130342Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "## Issue\n", + "checkout-svc pods are in a CrashLoopBackOff state due to OutOfMemoryError. The service consistently crashes after ~2 minutes with 7 restarts in the last 5 minutes.\n", + "\n", + "## Root Cause\n", + "The deployment had memory limits set to 128Mi, which is insufficient for the pricing cache operation:\n", + "- Pricing cache warms with 14,092 entries during startup\n", + "- Heap pressure builds to 118-121MB (92-94% of limit) within 90 seconds\n", + "- pricing.recompute fails to allocate 8MB, causing OOMKilled (exit 137)\n", + "- Service restarts and repeats the cycle\n", + "\n", + "## Fix\n", + "Increase memory allocation to provide adequate headroom:\n", + "- **Memory request:** 128Mi \u2192 256Mi\n", + "- **Memory limit:** 128Mi \u2192 512Mi\n", + "\n", + "This provides 4x headroom for the pricing cache and normal operations while remaining resource-efficient (512Mi limit is standard for Java/similar workloads with caching).\n", + "\n", + "## Verification\n", + "The fix addresses the immediate OOMKilled pattern in logs and aligns memory resources with the actual cache size and operational requirements. \n", + "\n", + "--- a/k8s/checkout-deploy.yaml\n", + "+++ b/k8s/checkout-deploy.yaml\n", + "@@ -21,10 +21,10 @@ spec:\n", + " resources:\n", + " requests:\n", + " cpu: 250m\n", + "- memory: 128Mi\n", + "+ memory: 256Mi\n", + " limits:\n", + " cpu: 500m\n", + "- memory: 128Mi\n", + "+ memory: 512Mi\n", + " readinessProbe:\n", + " httpGet:\n", + " path: /healthz\n", + "\n", + "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n", + "APPROVAL REQUESTED: **Incident:** checkout-svc CrashLoopBackOff with OOMKilled (7 restarts in 5 min)\n", + "\n", + "**Root Cause:** Memory limit (128Mi) insufficient for 14k-entry pricing cache\n", + "\n", + "**Fix:** Increase memory request to 256Mi and limit to 512Mi\n", + "\n", + "**Impact:** Provides 4x headroom while maintaining resource efficiency. No service logic changes.\n" + ] + } + ], + "source": [ + "pr = prs[0]\n", + "print(pr[\"body\"], \"\\n\")\n", + "print(pr[\"diff\"])\n", + "print(\"\\n\" + \"\u2500\" * 60)\n", + "print(\"APPROVAL REQUESTED:\", pending_approvals[0][\"summary\"])" + ] + }, + { + "cell_type": "markdown", + "id": "757863c0", + "metadata": {}, + "source": [ + "## 6. Approve and let the agent merge\n", + "\n", + "Send `\"approved\"` back as the `request_approval` result. The agent\n", + "resumes, calls `merge_pull_request`, and ends its turn. In the Slack\n", + "version this send happens in your button-click handler \u2014 the payload\n", + "is identical.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0fbc34fc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-07T19:06:30.133450Z", + "iopub.status.busy": "2026-04-07T19:06:30.133228Z", + "iopub.status.idle": "2026-04-07T19:06:42.464430Z", + "shell.execute_reply": "2026-04-07T19:06:42.463648Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Great! The fix has been approved. Now merging:\n", + "\u2192 merge_pull_request\n", + "## \u2705 Incident Resolved\n", + "\n", + "**Summary:**\n", + "- **Status:** MERGED (PR #1)\n", + "- **Failure:** checkout-svc crash-loop with OOMKilled (exit 137)\n", + "- **Root Cause:** Memory limit of 128Mi was insufficient for pricing cache (14,092 entries)\n", + "- **Fix Applied:** \n", + " - Memory request: 128Mi \u2192 256Mi\n", + " - Memory limit: 128Mi \u2192 512Mi\n", + "\n", + "**What Happened:**\n", + "1. Service loaded 14k+ pricing cache entries during startup\n", + "2. Heap grew to 118-121MB within ~2 minutes (92-94% of 128Mi limit)\n", + "3. pricing.recompute failed to allocate 8MB, triggering OutOfMemoryError\n", + "4. Container was OOMKilled and restarted, repeating the cycle\n", + "\n", + "**Expected Outcome:**\n", + "With 512Mi limit and 256Mi request, the service will have sufficient memory headroom for:\n", + "- Pricing cache operations\n", + "- Normal request processing\n", + "- JVM garbage collection pauses\n", + "- No more CrashLoopBackOff\n", + "\n", + "The deployment update will trigger a rolling restart of the 3 replicas, allowing pods to spawn with the new memory configuration.\n", + "\n", + "PR #1 merged: True\n" + ] + } + ], + "source": [ + "client.beta.sessions.events.send(\n", + " session_id,\n", + " events=[\n", + " {\n", + " \"type\": \"user.custom_tool_result\",\n", + " \"custom_tool_use_id\": approval_event_id,\n", + " \"content\": [{\"type\": \"text\", \"text\": json.dumps({\"decision\": \"approved\"})}],\n", + " }\n", + " ],\n", + ")\n", + "\n", + "run_until_approval_or_end(session_id)\n", + "print(f\"\\n\\nPR #{pr['number']} merged: {prs[0]['merged']}\")" + ] + }, + { + "cell_type": "markdown", + "id": "861a2fd1", + "metadata": {}, + "source": [ + "## 7. Review the run in the Console\n", + "\n", + "Because the investigation ran as a Managed Agents session, every step\n", + "above \u2014 the file reads, the `bash` diff, the manifest edit, the three\n", + "custom tool calls, and the approval you sent \u2014 is persisted as an\n", + "event on the session. Open it in the\n", + "[Console](https://platform.claude.com/) under **Managed Agents \u2192\n", + "Sessions** for the full audit trail with no extra instrumentation:\n", + "\n", + "![Console session view for the incident-response run](attachment:console_session.png)\n", + "\n", + "### Cleanup\n", + "\n", + "Archive the session and the resources you created.\n" + ], + "attachments": { + "console_session.png": { + "image/png": "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" + } + } + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f02067dc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-04-07T19:06:42.467155Z", + "iopub.status.busy": "2026-04-07T19:06:42.466822Z", + "iopub.status.idle": "2026-04-07T19:06:45.002047Z", + "shell.execute_reply": "2026-04-07T19:06:45.001579Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "archived\n" + ] + } + ], + "source": [ + "wait_for_idle_status(client, session_id)\n", + "client.beta.sessions.archive(session_id)\n", + "client.beta.environments.archive(env.id)\n", + "client.beta.agents.archive(agent.id)\n", + "client.beta.skills.versions.delete(skill.latest_version, skill_id=skill.id)\n", + "client.beta.skills.delete(skill.id)\n", + "print(\"archived\")" + ] + }, + { + "cell_type": "markdown", + "id": "3e6b72f8", + "metadata": {}, + "source": [ + "## Next steps: production wiring\n", + "\n", + "Three swaps take this from notebook to on-call.\n", + "\n", + "**Approve in Slack.** When `request_approval` arrives, post it to the\n", + "on-call channel with Block Kit buttons and send the\n", + "`user.custom_tool_result` back from the action handler. The\n", + "[`slack_data_bot` cookbook](slack_data_bot.ipynb) covers the Bolt app\n", + "setup; the approval-specific bit is small:\n", + "\n", + "```python\n", + "def post_for_approval(session_id, event_id, summary):\n", + " slack.client.chat_postMessage(\n", + " channel=ONCALL_CHANNEL,\n", + " text=summary,\n", + " blocks=[\n", + " {\"type\": \"section\", \"text\": {\"type\": \"mrkdwn\", \"text\": summary}},\n", + " {\"type\": \"actions\", \"elements\": [\n", + " {\"type\": \"button\", \"text\": {\"type\": \"plain_text\", \"text\": \"Approve\"},\n", + " \"action_id\": \"approve\", \"value\": f\"{session_id}:{event_id}\"},\n", + " {\"type\": \"button\", \"text\": {\"type\": \"plain_text\", \"text\": \"Reject\"},\n", + " \"action_id\": \"reject\", \"value\": f\"{session_id}:{event_id}\"},\n", + " ]},\n", + " ],\n", + " )\n", + "\n", + "@slack.action(\"approve\")\n", + "def on_approve(ack, body):\n", + " ack()\n", + " session_id, event_id = body[\"actions\"][0][\"value\"].split(\":\")\n", + " client.beta.sessions.events.send(\n", + " session_id,\n", + " events=[{\"type\": \"user.custom_tool_result\",\n", + " \"custom_tool_use_id\": event_id,\n", + " \"content\": [{\"type\": \"text\",\n", + " \"text\": json.dumps({\"decision\": \"approved\"})}]}],\n", + " )\n", + "```\n", + "\n", + "To drop the polling loop entirely, register a Console webhook on\n", + "`session.requires_action` \u2014 the platform calls your endpoint the\n", + "moment the agent pauses, and you post to Slack from there.\n", + "\n", + "**GitHub instead of the mock.** Drop the `open_pull_request` /\n", + "`merge_pull_request` custom tools and give the agent the GitHub MCP\n", + "server instead, with the token stored in a vault so it never appears\n", + "in your code.\n", + "[`CMA_operate_in_production.ipynb`](CMA_operate_in_production.ipynb)\n", + "walks through per-user credentials.\n", + "\n", + "```python\n", + "agent = client.beta.agents.create(\n", + " ...,\n", + " mcp_servers=[{\"type\": \"url\", \"name\": \"github\",\n", + " \"url\": \"https://api.githubcopilot.com/mcp/\"}],\n", + " tools=[{\"type\": \"agent_toolset_20260401\", ...},\n", + " {\"type\": \"mcp_toolset\", \"server_name\": \"github\"},\n", + " {\"type\": \"custom\", \"name\": \"request_approval\", ...}],\n", + ")\n", + "session = client.beta.sessions.create(..., vault_ids=[github_vault.id])\n", + "```\n", + "\n", + "**Live logs instead of a fixture.** Pass `DD_API_KEY` / `DD_APP_KEY`\n", + "through the environment config and let the agent `curl` the Datadog\n", + "Logs API from `bash` instead of reading a mounted file.\n", + "\n", + "> See also the [Agent SDK site-reliability\n", + "> agent](https://github.com/anthropics/claude-cookbooks/blob/main/claude_agent_sdk/03_The_site_reliability_agent.ipynb)\n", + "> for the same problem solved with the local Agent SDK instead of the\n", + "> hosted Managed Agents runtime.\n" + ] + }, + { + "cell_type": "markdown", + "id": "389d2cd7", + "metadata": {}, + "source": [ + "## What you learned\n", + "\n", + "- Trigger a session from any external event \u2014 one API call from a\n", + " PagerDuty webhook started the whole run.\n", + "- Attach a **Skill** to give the agent your team's conventions.\n", + "- Mount data with **resources**: `github_repository` for code, `file`\n", + " for logs and runbooks.\n", + "- Use **custom tools** to call back into your app and gate actions on\n", + " human approval via `requires_action`.\n", + "- Get the full audit trail for free in the **Console** session view.\n", + "\n", + "Swap the mocks for GitHub MCP, a Slack approval button, and live\n", + "logs, and it's ready for on-call.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/managed_agents/utilities.py b/managed_agents/utilities.py new file mode 100644 index 00000000..b2fb418b --- /dev/null +++ b/managed_agents/utilities.py @@ -0,0 +1,123 @@ +"""Shared helpers for the cookbook notebooks. + +Notebook 00 introduces two ways to consume a session's output: +polling `events.list` after the fact, and streaming events live +through `events.stream`. Both loops are written out inline in 00 so +readers see the literal API shapes the first time they meet them. + +Once that introduction is done, every other notebook imports +`stream_until_end_turn` from this module instead of repeating the +loop. The helper is a direct lift of the streaming pattern shown in +notebook 00, printing `agent.message` text, marking each +`agent.tool_use`, and exiting when `session.status_idle` arrives +with `stop_reason.type == "end_turn"`. + +The helper deliberately does not handle `requires_action`. Custom +tool notebooks (01 Part A and 05) drive the stream directly because +they need to respond to tool calls mid-turn, and their loops stay +inline. +""" + +import io +import textwrap +import time +import zipfile + +from anthropic import Anthropic + + +def wait_for_idle_status(client: Anthropic, session_id: str, max_wait: float = 5.0) -> None: + """Poll until the session's server-side status field is `idle`. + + The `session.status_idle` event in the SSE stream can arrive + slightly before `sessions.retrieve` reports `status == "idle"`, + which causes an `archive()` call issued immediately after the + stream exits to 400 with "cannot be archived while its status + is running." This helper absorbs that race with a short poll. + Call it after `stream_until_end_turn` (or after breaking out of + an inline stream loop) and before `archive()`. + """ + deadline = time.monotonic() + max_wait + while time.monotonic() < deadline: + if client.beta.sessions.retrieve(session_id).status == "idle": + return + time.sleep(0.25) + + +def stream_until_end_turn(client: Anthropic, session_id: str) -> None: + """Stream a session's events and print until the agent finishes its turn. + + This is the streaming pattern from notebook 00, lifted into a + helper so the later notebooks don't repeat it. The session emits + `session.status_idle` any time it's waiting for input, both at + end of turn and when a custom tool call needs a response, so we + disambiguate with `stop_reason.type` and only exit on `end_turn`. + + After the stream exits we also wait for the server-side status + to settle so an immediate `archive()` call doesn't race the + state machine. + """ + with client.beta.sessions.events.stream(session_id) as stream: + for ev in stream: + match ev.type: + case "agent.message": + for block in ev.content: + if block.type == "text": + print(block.text, end="") + case "agent.tool_use": + print(f"\n[{ev.name}]") + case "session.status_idle" if ev.stop_reason and ev.stop_reason.type == "end_turn": + break + case "session.status_terminated": + return + wait_for_idle_status(client, session_id) + + +# Notebook 04 builds its repo fixture in-memory with the helper +# below rather than checking files into `example_data/`; the repo +# is small enough that the helper is more readable than a directory +# of stub files. + + +def make_unfamiliar_repo_zip() -> io.BytesIO: + """Build an in-memory ZIP of a small repository with a stale doc. + + The repo is about 37 files laid out as microservices under + `services/`, but `ARCHITECTURE.md` still describes the older + monolithic layout. The grounding notebook uses this to show how + an agent that trusts documentation without verifying it against + the actual code will produce confidently wrong answers. + """ + buf = io.BytesIO() + with zipfile.ZipFile(buf, "w") as zf: + zf.writestr( + "ARCHITECTURE.md", + textwrap.dedent("""\ + # Architecture (STALE, do not trust) + + The app is a monolith with three layers: + - api/ for REST handlers + - core/ for business logic + - db/ for database access + + [Out of date. The real structure is microservices under + services/. An agent that trusts this without reading the + code will answer wrong.] + """), + ) + zf.writestr( + "README.md", + "# Widget Service\n\nSee ARCHITECTURE.md (possibly outdated).\n", + ) + for svc in ["auth", "billing", "notifications", "widgets"]: + zf.writestr( + f"services/{svc}/main.py", + f"# {svc} service entrypoint\ndef handle(): ...\n", + ) + zf.writestr(f"services/{svc}/models.py", f"class {svc.title()}: ...\n") + for i in range(6): + zf.writestr(f"services/{svc}/util_{i}.py", f"def helper_{i}(): ...\n") + for legacy in ["api", "core", "db"]: + zf.writestr(f"{legacy}/.gitkeep", "") + buf.seek(0) + return buf diff --git a/registry.yaml b/registry.yaml index fd7c2ecf..68551eaf 100644 --- a/registry.yaml +++ b/registry.yaml @@ -1,4 +1,70 @@ # yaml-language-server: $schema=./.github/registry_schema.json +- title: Build a data analyst agent with Claude Managed Agents + description: Build an analyst that turns a CSV into a narrative HTML report with + interactive charts, using a sandboxed environment and file mounting. + path: managed_agents/data_analyst_agent.ipynb + authors: + - charmaine + - jyan-anthropic + date: '2026-04-08' + categories: + - Agent Patterns + - Tools +- title: Build a Slack data analyst bot with Claude Managed Agents + description: Mention the bot with a CSV to get an analysis report in-thread, with + multi-turn follow-ups on the same session. + path: managed_agents/slack_data_bot.ipynb + authors: + - charmaine + date: '2026-04-08' + categories: + - Agent Patterns + - Integrations +- title: 'Managed Agents tutorial: iterate on a failing test suite' + description: Entry-point tutorial for the Claude Managed Agents API. Walks through + agent / environment / session creation, file mounts, and the streaming event + loop by getting an agent to fix three planted bugs in a calc.py package. + path: managed_agents/CMA_iterate_fix_failing_tests.ipynb + authors: + - pauly-ant + date: '2026-04-08' + categories: + - Agent Patterns + - Tools +- title: 'Managed Agents tutorial: production setup' + description: End-to-end production story for Managed Agents — vault-backed MCP + credentials, the session.status_idled webhook pattern for human-in-the-loop + without long-lived connections, and the resource lifecycle CRUD verbs. + path: managed_agents/CMA_operate_in_production.ipynb + authors: + - pauly-ant + date: '2026-04-08' + categories: + - Agent Patterns + - Integrations +- title: Build an SRE incident response agent with Claude Managed Agents + description: A webhook-triggered responder that investigates logs and runbooks + with a custom Skill, fixes infrastructure code, and gates the PR behind a + human-approval custom tool — with the full audit trail in the Console. + path: managed_agents/sre_incident_responder.ipynb + authors: + - gaganb-ant + date: '2026-04-07' + categories: + - Agent Patterns + - Observability +- title: 'Managed Agents tutorial: prompt versioning and rollback' + description: Server-side prompt versioning — create v1, evaluate against a labelled + test set, ship v2, detect a regression, roll back by pinning sessions to version + 1. Covers agents.update, version pinning on sessions.create, and where the review + gate moves when prompts are not code. + path: managed_agents/CMA_prompt_versioning_and_rollback.ipynb + authors: + - markn-ant + date: '2026-04-07' + categories: + - Agent Patterns + - Evals - title: Threat intelligence enrichment agent description: Build an agent that autonomously investigates IOCs by querying multiple threat intel sources, cross-referencing findings, mapping to MITRE ATT&CK, and