Claude Managed Agents

List agent templates bundled with agentman-claudeagents-mcp-server. Returns a catalog of ready-to-use Claude Managed Agents configurations: Blank, Deep researcher, Structured extractor, Field monitor, Support agent, Incident commander, Feedback miner, Sprint retro facilitator, Support-to-eng escalator, Data analyst. Use this tool to show the user what templates are available before creating an agent — then call claudeagent_get_template to fetch the full YAML/JSON of the chosen template. Args: - category (string, optional): Filter by category, e.g., 'research', 'support', 'ops', 'data' - response_format ('markdown' | 'json'): Output format (default: 'markdown') Returns: Markdown table of templates with slug, name, description, category, and default_model. For JSON format, a structured list. Examples: - List all templates: {} - List data-focused templates: {"category": "data"} - Get as JSON: {"response_format": "json"} Error Handling: - Returns an empty list if no templates match the category filter. - Never errors under normal conditions — templates are bundled with the package.

Retrieve the full YAML or JSON of a specific agent template, ready to be passed to claudeagent_create_agent. Use this tool after claudeagent_list_templates when the user has chosen a template. The returned config can be passed directly (after any customization) to claudeagent_create_agent to create a new Claude Managed Agent based on the template. Args: - template_slug (string, required): The template slug from claudeagent_list_templates, e.g., 'deep-researcher' - format ('yaml' | 'json'): Format for the config body (default: 'yaml') - response_format ('markdown' | 'json'): Output format of the tool response itself (default: 'markdown') Returns: The template's full configuration including name, description, model, system prompt, tools, mcp_servers, and skills. In markdown format, the config is wrapped in a code block; in JSON format, it's a structured object. Examples: - Get the deep researcher template as YAML: {"template_slug": "deep-researcher"} - Get as JSON: {"template_slug": "support-agent", "format": "json"} Error Handling: - Returns NOT_FOUND if template_slug doesn't match any bundled template. Call claudeagent_list_templates first to see valid slugs.

List all agents in the Anthropic workspace. Returns agents with their IDs, names, models, descriptions, versions, and metadata. Use this to discover which agents exist and get their IDs for further operations like claudeagent_get_agent, claudeagent_create_session, or claudeagent_run_task. Args: - limit (number): Max results to return (1-100, default: 20) - page (string): Pagination cursor from a previous response - include_archived (boolean): Include archived agents (default: false) - response_format ('markdown' | 'json'): Output format (default: 'markdown') Returns: Markdown table (or JSON) of agents with: id, name, model, description, version, created_at, archived_at, plus next_page cursor if more results exist. Examples: - List latest 20: {} - List next page: {"page": "eyJhbGci..."} - Include archived: {"include_archived": true} - Get as JSON: {"response_format": "json"} Error Handling: - Returns AUTH_REQUIRED if no API key is configured - Returns API_ERROR on Anthropic API failures

Retrieve a specific agent by ID, including the full configuration. Returns the agent's name, model, system prompt, tools, MCP servers, skills, metadata, and version. Optionally specify a version to retrieve a historical version. Args: - agent_id (string, required): The agent ID, e.g., 'agent_01ab...' - version (number, optional): Specific version to retrieve; omit for latest - response_format ('markdown' | 'json'): Output format (default: 'markdown') Returns: Markdown-formatted agent details showing all fields, including system prompt, tools, and MCP servers. Examples: - Get latest version: {"agent_id": "agent_01abc"} - Get historical version: {"agent_id": "agent_01abc", "version": 2} Error Handling: - Returns NOT_FOUND if agent_id doesn't exist - Returns AUTH_REQUIRED if no API key is configured

List historical versions of a specific agent. Useful for comparing how an agent's configuration has changed over time. Each version is a snapshot of the agent's config at the time it was updated. Agents are automatically versioned by the Anthropic API on every update_agent call. Args: - agent_id (string, required): The agent ID - limit (number): Max results (1-100, default: 20) - page (string): Pagination cursor Returns: Markdown table of versions with version number, created_at, name, and a summary of changes. Examples: - List all versions: {"agent_id": "agent_01abc"}

Create a new Claude Managed Agent. Pass the name, model, system prompt, tools, MCP servers, skills, and metadata. Returns the new agent ID and version. This is a one-time setup operation — store the returned agent_id and reuse it for all future sessions via claudeagent_create_session or claudeagent_run_task. Args: - name (string, required): Human-readable agent name (1-256 chars) - model (string, required): Claude model identifier, e.g., 'claude-sonnet-4-6' - system (string, optional): System prompt (up to 100,000 chars) - description (string, optional): Short description (up to 2048 chars) - tools (array, optional): Tool configurations (max 128). Use [{"type": "agent_toolset_20260401"}] for the default full toolset. - mcp_servers (array, optional): MCP server configurations (max 20) - skills (array, optional): Skill configurations (max 20) - callable_agents (array, optional): For multi-agent: list of agent IDs this one can delegate to - metadata (object, optional): Key-value string metadata - response_format ('markdown' | 'json'): Output format (default: 'markdown') Returns: Markdown with the new agent's ID, version, and suggested next step. Examples: - Minimal agent: {"name": "My Agent", "model": "claude-sonnet-4-6", "tools": [{"type": "agent_toolset_20260401"}]} - With system prompt: {"name": "Research Bot", "model": "claude-sonnet-4-6", "system": "You are a thorough research assistant...", "tools": [{"type": "agent_toolset_20260401"}]} Error Handling: - Returns INVALID_PARAMS if name or model is empty - Returns AUTH_REQUIRED if no API key is configured - Returns API_ERROR on Anthropic API failures

Update an existing agent's configuration. Requires the current version number for optimistic concurrency control — this prevents two concurrent updates from silently overwriting each other. Only pass the fields you want to change; unset fields are preserved. Updates create a new version. To clear a nullable field (description, system), pass null explicitly. Args: - agent_id (string, required): Agent to update - version (number, required): Current version — get it from claudeagent_get_agent first - name (string, optional): New name - description (string | null, optional): New description, or null to clear - system (string | null, optional): New system prompt, or null to clear - model (string, optional): New model - tools (array, optional): New tools array (replaces existing) - mcp_servers (array, optional): New MCP servers array - skills (array, optional): New skills array - metadata (object, optional): Metadata patch (set a key to null to delete it) - response_format ('markdown' | 'json'): Output format Returns: Markdown confirming the update with the new version number. Error Handling: - Returns VERSION_CONFLICT if the provided version doesn't match current — fetch the latest version and retry - Returns NOT_FOUND if agent_id doesn't exist

Archive (soft-delete) an agent. Archived agents cannot be used to create new sessions, but existing sessions continue to work. This is reversible via the Anthropic Console. Use this instead of deleting an agent so you retain the version history. Args: - agent_id (string, required): Agent to archive - response_format ('markdown' | 'json'): Output format Returns: Markdown confirmation with the archive timestamp. Error Handling: - Returns NOT_FOUND if agent_id doesn't exist

List all container environments configured in the workspace. Environments define the container template agents run in — what packages are installed, what hosts the container can reach on the network, and the general compute profile. Before creating a session, you need both an agent_id AND an environment_id. Args: - limit (number): Max results (1-100, default: 20) - page (string): Pagination cursor - include_archived (boolean): Include archived environments (default: false) - response_format ('markdown' | 'json'): Output format Returns: Markdown table of environments with id, name, networking type, and package count.

Retrieve a specific environment's full configuration. Returns the environment's name, description, networking policy (unrestricted or limited with allowlist), installed packages across all package managers, and metadata. Args: - environment_id (string, required) - response_format ('markdown' | 'json') Error Handling: - Returns NOT_FOUND if environment_id doesn't exist

Create a new cloud environment for running agents. Specify packages to install across apt/pip/npm/go/cargo/gem and the network access policy ('unrestricted' or 'limited' with an allowlist). If networking_type is 'limited', you can optionally allow_package_managers (PyPI, npm, etc.) and/or allow_mcp_servers (the MCP servers configured on agents) beyond the allowed_hosts list. Args: - name (string, required) - description (string, optional) - networking_type ('unrestricted' | 'limited', default: 'unrestricted') - allowed_hosts (string[], required if networking_type is 'limited') - allow_package_managers (boolean, default: false) - allow_mcp_servers (boolean, default: false) - apt_packages, pip_packages, npm_packages, go_packages, cargo_packages, gem_packages (string[], optional) - metadata (object, optional) - response_format ('markdown' | 'json') Examples: - Minimal unrestricted env: {"name": "my-env"} - Limited env with Python: {"name": "python-analytics", "networking_type": "limited", "allow_package_managers": true, "pip_packages": ["pandas", "numpy"]} - Strict sandbox: {"name": "sandbox", "networking_type": "limited", "allowed_hosts": ["api.internal.example.com"]}

Update an environment's configuration. Any field omitted from the input is preserved. Package lists are fully replaced by whatever is passed. To clear the description, pass null explicitly. Args: same shape as claudeagent_create_environment, plus environment_id

Archive an environment (soft-delete). Archived environments cannot be used to create new sessions. Prefer this over delete_environment unless you specifically need to remove the environment from the API. Archive is reversible via the Anthropic Console; delete is not.

Permanently delete an environment. ⚠️ WARNING: This is destructive and non-reversible. Prefer claudeagent_archive_environment unless you specifically need to remove the environment from the API. Error Handling: - Returns CONFLICT if the environment is still in use by active sessions

List agent sessions with filters. A session is a running or completed agent instance working on a specific task. Filter by agent, status, or date range. Use this to find sessions you want to inspect, summarize, or resume. Args: - agent_id (string, optional): Filter to a specific agent - agent_version (number, optional): Filter to a specific version - status ('running' | 'idle' | 'terminated' | 'rescheduling', optional) - created_after / created_before (ISO 8601 timestamp, optional) - include_archived (boolean, default: false) - limit (number, 1-100, default: 20) - page (string): Pagination cursor - order ('asc' | 'desc', default: 'desc') - response_format ('markdown' | 'json') Returns: Markdown table of sessions with id, agent name, status, created_at, duration, cost, token usage, plus next_page cursor. Examples: - List latest 20: {} - Failed sessions from yesterday: {"status": "terminated", "created_after": "2026-04-09T00:00:00Z"} - All sessions of one agent: {"agent_id": "agent_01abc"}

Check a session's current status and metadata. Returns in <2 seconds. This is the recommended polling tool for checking if a long-running agent has finished. After starting a task with claudeagent_run_task or claudeagent_send_user_message, poll this every ~30 seconds until status changes from "running" to "idle", then call claudeagent_get_session_output to retrieve the agent's response. Key status values: - "running": agent is still working - "idle": agent finished — call get_session_output to get the result - "terminated": session ended with an error - "rescheduling": transient error, will auto-retry Note: token usage fields show zero while status is "running" and only populate once the session reaches "idle". Args: - session_id (string, required) - response_format ('markdown' | 'json') Returns: Session status, agent info, duration stats, token usage (when complete), and outcome evaluations. Error Handling: - Returns NOT_FOUND if session_id doesn't exist

Create a new session for an existing agent. The session is created empty — no work happens until you send the first user message with claudeagent_send_user_message. Store the returned session_id to send messages and check status. Recommended workflow (polling pattern — reliable for all session durations): 1. claudeagent_create_session → get session_id 2. claudeagent_send_user_message(session_id, text) → kick off work 3. Wait ~30 seconds, then claudeagent_get_session(session_id) → check if status is "idle" 4. If still "running", wait and check again 5. When "idle", call claudeagent_get_session_output(session_id) to get the agent's response Alternative: claudeagent_run_task does steps 1-2 in one call and returns the session_id immediately (async by default). Args: - agent_id (string, required): ID of an existing agent - environment_id (string, required): ID of an existing environment - title (string, optional): Human-readable title - metadata (object, optional): Key-value string metadata - vault_ids (string[], optional): Credential vault IDs for MCP servers that require auth - response_format ('markdown' | 'json') Returns: Markdown with the new session ID and the recommended next steps.

Update a session's title or metadata. Use this to rename a session after it's been created, or to attach additional metadata. Does not affect the session's actual state or execution. Args: - session_id (string, required) - title (string, optional) - metadata (object, optional): Metadata patch (set a key to null to delete it) - response_format ('markdown' | 'json')

Archive a session (soft-delete). Archived sessions are hidden from the default list view but are still accessible by ID. Prefer this over delete_session.

Permanently delete a session. ⚠️ WARNING: This is destructive and non-reversible. Prefer claudeagent_archive_session unless you need to remove the session entirely. Error Handling: - Returns CONFLICT if the session is still running

Send a user message to a session. This is what actually kicks off agent work. The agent reads the message, uses its tools, and generates a response. For long-running work, pair this with claudeagent_wait_for_session_idle to block until the agent finishes, then call claudeagent_summarize_session to get the result — OR just call claudeagent_run_task which does all of that in one tool call. Args: - session_id (string, required) - text (string, required): The user message text - files (array, optional): File attachments, each with {name, content_base64, mime_type} - response_format ('markdown' | 'json') Returns: Markdown confirming the message was sent. Examples: - Simple question: {"session_id": "sesn_abc", "text": "What's the weather in Tokyo?"} - With a file: {"session_id": "sesn_abc", "text": "Analyze this CSV", "files": [{"name": "data.csv", "content_base64": "...", "mime_type": "text/csv"}]} Error Handling: - Returns NOT_FOUND if session_id doesn't exist - Returns CONFLICT if the session is already terminated

Define an outcome for a session — a description plus a rubric the grader will evaluate against. The session runs in outcome-oriented mode, iterating until the rubric is satisfied or max_iterations is hit. This is an alternative to claudeagent_send_user_message when you want the agent to self-correct toward a measurable goal. You must provide either rubric_text (inline markdown) or rubric_file_id (from a previously-uploaded file). Not both. Args: - session_id (string, required) - description (string, required): What the session should achieve - rubric_text (string, optional): Inline markdown rubric - rubric_file_id (string, optional): File ID of a previously-uploaded rubric - max_iterations (number, default: 3, max: 20) - response_format ('markdown' | 'json') Examples: - Inline rubric: {"session_id": "sesn_abc", "description": "Build a DCF model for Costco in .xlsx", "rubric_text": "# DCF Model Rubric\n\n## Revenue Projections\n- Uses last 5 years..."} - File-based rubric: {"session_id": "sesn_abc", "description": "...", "rubric_file_id": "file_01..."} Error Handling: - Returns INVALID_PARAMS if neither rubric_text nor rubric_file_id is provided - Returns NOT_FOUND if session_id doesn't exist

Stop a running session mid-execution. The agent halts after its current step and the session transitions to idle. Use this to cancel work that's no longer needed, costing too much, or taking too long. Args: - session_id (string, required) - reason (string, optional): Human-readable reason for the interruption - response_format ('markdown' | 'json') Error Handling: - Returns CONFLICT if the session is already idle or terminated

Respond to a tool confirmation request from an agent. When an agent tries to use a tool that requires confirmation (per the agent's permission policy), the session pauses and emits an event with the tool_use_id. Call this tool to allow or deny the tool call so the session can continue. For multi-agent sessions, pass the session_thread_id from the confirmation request to route the response back to the correct sub-agent thread. Args: - session_id (string, required) - tool_use_id (string, required): From the confirmation request event - result ('allow' | 'deny', required) - session_thread_id (string, optional): For multi-agent sessions

Respond to a custom tool call from an agent. When an agent calls a custom tool, the session pauses waiting for the client to provide the result. Call this tool to return the custom tool's result so the session can continue. Args: - session_id (string, required) - tool_use_id (string, required) - result (any, required): The tool result — must match the tool's expected output schema - session_thread_id (string, optional): For multi-agent sessions

Retrieve the full event history of a session. Events include user messages, agent messages, tool calls, tool results, thinking, session status changes, and errors. This is the primary debugging tool — use it to understand what happened in a session after it finished. For live streaming of events as they arrive (rather than batch retrieval), use claudeagent_stream_session_events. Args: - session_id (string, required) - limit (number, 1-500, default: 100) - page (string): Pagination cursor from a previous response - order ('asc' | 'desc', default: 'asc'): 'asc' shows oldest first (natural timeline), 'desc' shows most recent first - type (string, optional): Comma-separated event types to include. E.g., 'agent.message' or 'agent.message,agent.tool_use'. Filters client-side after fetching. - exclude_type (string, optional): Comma-separated event types to exclude. E.g., 'agent.tool_result,agent.thinking' to skip large payloads. - response_format ('markdown' | 'json') Returns: Markdown timeline of events with type, timestamp, and content (long messages are truncated). Structured JSON in json format. Tip: To get just the agent's text responses without large tool results, use: type='agent.message' Or to see everything except tool results and thinking: exclude_type='agent.tool_result,agent.thinking' For just the agent's final output text, prefer claudeagent_get_session_output instead. Error Handling: - Returns NOT_FOUND if session_id doesn't exist

For multi-agent sessions, list the sub-agent threads spawned by the coordinator. Each thread is an isolated sub-agent working on a delegated task with its own conversation context. Single-agent sessions will return an empty list (or just the primary thread). Args: - session_id (string, required) - response_format ('markdown' | 'json') Returns: Markdown table of threads with id, agent_name, status, created_at.

Retrieve events from a specific sub-agent thread in a multi-agent session. Use this to drill into what a specific sub-agent was doing when the session-level event list is too coarse. For single-agent sessions, use claudeagent_list_session_events instead. Args: - session_id (string, required) - thread_id (string, required) - limit (number, 1-100, default: 20) - page (string): Pagination cursor

Block until a session reaches idle state (agent has finished work) or a timeout expires. Streams agent activity via MCP progress notifications while waiting, so the user sees what the agent is doing in near-real-time. Internally opens an SSE stream to the Anthropic Managed Agents event stream endpoint and forwards each event as a progress notification with a human-readable label. Use this after sending a user message (claudeagent_send_user_message) to wait for the agent to complete before checking results. For a one-shot "create session + send message + wait + summarize" flow, use claudeagent_run_task instead. Args: - session_id (string, required) - timeout_seconds (number, 1-1800, default: 600): Max wait time (default 10 min, max 30 min) - stream_events (boolean, default: true): Emit progress notifications as events arrive - include_thinking (boolean, default: false): Include agent.thinking events in progress output - response_format ('markdown' | 'json') Returns: Markdown confirming the final state: either 'idle' with stop_reason and elapsed time, or 'timeout' if the session was still running when timeout expired (with guidance to call again with a fresh timeout, or call summarize_session for partial results). Error Handling: - Returns NOT_FOUND if session_id doesn't exist - Returns AUTH_REQUIRED if no API key is configured - Returns an intermediate "still running" result on timeout, NOT an error

Stream events from a session in real-time, emitting each as an MCP progress notification and returning a log when the stream closes. Use this for the "tail -f my agent run" use case when you want to watch a slow agent run turn by turn. Unlike claudeagent_wait_for_session_idle, this tool stops at max_events or timeout_seconds even if the session is still running — it doesn't block to completion. Typically called on a session that's already running. Progress notifications render as status updates in claude.ai / Claude Desktop; the final return value contains a markdown log of everything observed. Args: - session_id (string, required) - max_events (number, 1-1000, default: 200): Stop after this many events - timeout_seconds (number, 1-1800, default: 300): Stop after this duration - include_thinking (boolean, default: false): Include agent.thinking events (noisy) - response_format ('markdown' | 'json') Returns: Markdown log of all events observed during the stream, ordered by timestamp, with a footer noting why the stream stopped.

Get the agent's final response text from a completed session. This is the "happy path" tool — it returns what the agent said, nothing else. No event metadata, no tool call logs, no token counts. Use this after the session reaches "idle" status to retrieve the agent's deliverable. Supports pagination for long outputs: if has_more=true in the response, call again with offset=next_offset to get the next chunk. Each chunk is up to ~80K characters. For monitoring data (event counts, tool usage, duration), use claudeagent_summarize_session instead. Args: - session_id (string, required): A completed session - offset (number, default: 0): Character offset for pagination. Pass next_offset from a previous response to continue. - response_format ('markdown' | 'json') Returns: The agent's response text (or a chunk of it), plus total_length, offset, chunk_length, has_more, and next_offset for pagination. Error Handling: - Returns NOT_FOUND if session_id doesn't exist - Returns STILL_RUNNING if the session hasn't finished yet — call get_session first to check status

Summarize a session with metadata AND the agent's final output. Fetches the full event history, usage data, errors, outcome evaluations, and tool call patterns, then generates a concise markdown summary covering: what the session was doing, how it ended, total cost and duration, any errors, key tool calls, and the outcome evaluation verdict if present. Use this when the user wants to understand what happened in a session without reading every raw event. Pair with claudeagent_run_task for a one-shot "run and summarize" flow. Args: - session_id (string, required) - include_tool_details (boolean, default: false): Include per-tool-call breakdown - response_format ('markdown' | 'json') Returns: Markdown summary with: session ID, agent name, status, duration, usage, narrative paragraph, tool call summary, errors, and outcome evaluations if any. Error Handling: - Returns NOT_FOUND if session_id doesn't exist

Find anomalous sessions in the recent history. Fetches recent sessions, computes baseline statistics per agent (typical duration, token usage, error rate), and flags sessions that deviate significantly. Returns a ranked list of anomalies with an explanation of why each was flagged. This is a pure statistical heuristic — no LLM calls, no custom scoring. Good for quick health checks. For deeper analysis, use claudeagent_summarize_session on specific flagged sessions. Args: - agent_id (string, optional): Limit to a specific agent - since (ISO 8601, optional): Default 24 hours ago - limit (number, 1-500, default: 100): Max sessions to analyze - response_format ('markdown' | 'json') Returns: Markdown list of flagged sessions with reason, cost, duration, and session_id.

Start an agent task — creates a session, sends a message, and returns. By default (wait=false), returns immediately after the agent starts working, with the session_id for tracking. Use claudeagent_get_session to poll for completion (status changes to "idle"), then claudeagent_summarize_session to get the result. This async mode is efficient and scalable. With wait=true, blocks until the agent finishes, streaming progress notifications. Only use wait=true in local stdio mode (Claude Desktop/Cursor) where long-lived connections are fine — never in HTTP/cloud mode. Args: - agent_id (string, required): ID of an existing agent - environment_id (string, required): ID of an existing environment - user_message (string, required): What the agent should do - files (array, optional): File attachments, each with {name, content_base64, mime_type} - title (string, optional): Session title - wait (boolean, default: false): If false, returns immediately after starting. If true, blocks until completion. - timeout_seconds (number, 30-1800, default: 600): Max wait time when wait=true. Ignored when wait=false. - include_tool_details (boolean, default: false): Include per-tool-call breakdown (only with wait=true) - response_format ('markdown' | 'json') Returns (wait=false): session_id, status "running", and next_steps with the exact tool calls to check status and get results. Returns (wait=true): Full summary with agent output, tool calls, tokens, and status. Examples: - Start async (recommended): {"agent_id": "agent_01abc", "environment_id": "env_01xyz", "user_message": "Research the 2008 financial crisis"} - Start and wait: {"agent_id": "agent_01abc", "environment_id": "env_01xyz", "user_message": "What is 2+2?", "wait": true} Error Handling: - Returns AUTH_REQUIRED if no API key is configured - Returns NOT_FOUND if agent_id or environment_id doesn't exist