Devops Monk

import anthropic
import json

client = anthropic.Anthropic()

# Create an agent session
session = client.beta.managed_agents.sessions.create(
    model="claude-sonnet-4-6",
    max_tokens=8192,
    tools=[
        {"type": "web_search"},
        {"type": "code_execution"}
    ],
    messages=[
        {
            "role": "user",
            "content": """
            Research the top 5 Kubernetes security vulnerabilities reported in 2026,
            write a concise summary for each, and produce a markdown report
            with a risk rating and recommended mitigations.
            Save the final report as 'k8s-security-2026.md'.
            """
        }
    ],
    betas=["managed-agents-2026-04-01"]
)

print(f"Session started: {session.id}")
print(f"Status: {session.status}")

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

async function runResearchAgent(task: string): Promise<string> {
  const session = await client.beta.managedAgents.sessions.create({
    model: "claude-sonnet-4-6",
    max_tokens: 8192,
    tools: [
      { type: "web_search" },
      { type: "code_execution" },
      { type: "file_management" }
    ],
    messages: [{ role: "user", content: task }],
    betas: ["managed-agents-2026-04-01"]
  });

  return session.id;
}

import anthropic

client = anthropic.Anthropic()

# Create a session
session = client.beta.managed_agents.sessions.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    tools=[
        {"type": "web_search"},
        {"type": "code_execution"}
    ],
    messages=[
        {
            "role": "user",
            "content": "Analyse our GitHub Actions CI logs from the last 7 days and identify the top 3 most common failure patterns."
        }
    ],
    betas=["managed-agents-2026-04-01"]
)

# Stream the agent's progress
with client.beta.managed_agents.sessions.stream(session.id) as stream:
    for event in stream:
        if event.type == "content_block_delta":
            # Agent is writing a response
            print(event.delta.text, end="", flush=True)
        elif event.type == "tool_use":
            # Agent is using a tool
            print(f"\n[Tool: {event.name}] {json.dumps(event.input)[:100]}...")
        elif event.type == "message_stop":
            print("\n\nAgent completed.")
            break

import anthropic

client = anthropic.Anthropic()

session_id = "session_01ABC..."  # saved from when you created the session

# Check current status
session = client.beta.managed_agents.sessions.retrieve(
    session_id,
    betas=["managed-agents-2026-04-01"]
)

print(f"Status: {session.status}")  # running, completed, failed

# If still running, reconnect to the stream
if session.status == "running":
    with client.beta.managed_agents.sessions.stream(session_id) as stream:
        for event in stream:
            print(event)

import anthropic

client = anthropic.Anthropic()

# First session — Claude learns your environment
session1 = client.beta.managed_agents.sessions.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[{"type": "web_search"}, {"type": "code_execution"}],
    memory={"enabled": True, "scope": "user"},  # persist memory for this user
    messages=[
        {
            "role": "user",
            "content": "Our production cluster runs Kubernetes 1.29 on AWS EKS in eu-west-1. "
                       "Our staging cluster is in us-east-1. Remember this for future sessions."
        }
    ],
    betas=["managed-agents-2026-04-01"]
)

# Later — a separate session, Claude remembers
session2 = client.beta.managed_agents.sessions.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[{"type": "web_search"}],
    memory={"enabled": True, "scope": "user"},
    messages=[
        {
            "role": "user",
            "content": "Is there a known CVE affecting our Kubernetes version?"
        }
        # Claude knows from memory that you run K8s 1.29
    ],
    betas=["managed-agents-2026-04-01"]
)

import anthropic

client = anthropic.Anthropic()

# Run a security scan every Monday at 08:00 UTC
routine = client.beta.managed_agents.routines.create(
    name="weekly-security-scan",
    schedule="0 8 * * 1",  # cron expression
    model="claude-sonnet-4-6",
    max_tokens=8192,
    tools=[
        {"type": "web_search"},
        {"type": "code_execution"}
    ],
    messages=[
        {
            "role": "user",
            "content": """
            Scan our GitHub repository for:
            1. Dependencies with known CVEs published this week
            2. Any new Dependabot alerts
            3. Failed security checks in recent CI runs
            Produce a markdown summary and post it to our Slack webhook.
            """
        }
    ],
    webhook_url="https://your-app.com/webhooks/agent-results",
    betas=["managed-agents-2026-04-01"]
)

print(f"Routine created: {routine.id}")
print(f"Next run: {routine.next_run_at}")

import anthropic
import os

client = anthropic.Anthropic()

def triage_incident(alert_body: str) -> str:
    """
    Given a PagerDuty alert body, spin up an agent to investigate
    and return a preliminary diagnosis.
    """
    session = client.beta.managed_agents.sessions.create(
        model="claude-opus-4-7",
        max_tokens=16384,
        tools=[
            {"type": "web_search"},
            {"type": "code_execution"}
        ],
        system="You are an on-call SRE. Investigate the incident methodically. "
               "Check logs, metrics, and recent deployments. "
               "Produce a diagnosis and recommended immediate actions.",
        messages=[
            {"role": "user", "content": f"Incoming incident alert:\n\n{alert_body}"}
        ],
        betas=["managed-agents-2026-04-01"]
    )

    # Collect the full result
    result_text = ""
    with client.beta.managed_agents.sessions.stream(session.id) as stream:
        for event in stream:
            if event.type == "content_block_delta":
                result_text += event.delta.text

    return result_text


# Called by your PagerDuty webhook handler
incident_alert = """
CRITICAL: High error rate on payment-service
Time: 2026-05-03 14:32 UTC
Error rate: 12.4% (normal: 0.1%)
Affected endpoints: /api/v2/payments/create, /api/v2/payments/confirm
Recent deploy: payment-service v2.3.1 at 14:15 UTC
"""

diagnosis = triage_incident(incident_alert)
print(diagnosis)

import anthropic

client = anthropic.Anthropic()

# Run once; schedule as a routine for weekly automation
session = client.beta.managed_agents.sessions.create(
    model="claude-sonnet-4-6",
    max_tokens=8192,
    tools=[
        {"type": "web_search"},
        {"type": "code_execution"},
        {"type": "file_management"}
    ],
    messages=[
        {
            "role": "user",
            "content": """
            Audit our Node.js dependencies:
            1. Read package.json from the repo root
            2. For each direct dependency, check the npm registry for:
               - Current latest version vs what we pin
               - Known security advisories (npm audit equivalent)
            3. Produce a prioritised list: security issues first, then major version gaps
            4. Write the report to dependency-audit.md
            """
        }
    ],
    betas=["managed-agents-2026-04-01"]
)

print(f"Audit running: {session.id}")

import anthropic

client = anthropic.Anthropic()

session = client.beta.managed_agents.sessions.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    tools=[
        {"type": "code_execution"},
        {"type": "file_management"}
    ],
    messages=[
        {
            "role": "user",
            "content": """
            Generate architecture documentation for our infrastructure:
            1. Read all Terraform files in infra/
            2. Read all Kubernetes manifests in k8s/
            3. Read all GitHub Actions workflows in .github/workflows/
            4. Produce a comprehensive architecture document covering:
               - AWS resources and their purposes
               - Service dependencies and data flows
               - CI/CD pipeline stages
               - Network boundaries and security groups
            5. Save as docs/architecture.md with Mermaid diagrams
            """
        }
    ],
    betas=["managed-agents-2026-04-01"]
)

# Install
npm install -g @anthropic/ant

# Run a one-off agent task
ant run --model claude-sonnet-4-6 --tools web_search,code_execution \
  "Research Kubernetes 1.31 release notes and summarise breaking changes"

# List running sessions
ant sessions list

# Stream output from a running session
ant sessions stream session_01ABC...

# Create a routine
ant routines create --schedule "0 9 * * 1" --name "weekly-audit" \
  "Audit npm dependencies for security issues and write a report"