วิธีสร้าง Claude Managed Agents ด้วย Claude Sonnet 5

เคยอยากรันเวิร์กโฟลว์สไตล์ Claude Code จากสคริปต์ Python ไหม ที่ซึ่งโมเดลทำงานในสภาพแวดล้อมที่มีการจัดการ พร้อมเข้าถึงเครื่องมือ ไฟล์ สกิล และคำสั่งได้?

Claude Managed Agents ถูกออกแบบมาสำหรับเวิร์กโฟลว์แบบนี้ ช่วยให้สร้างเอเจนต์ที่ทำงานหลายขั้นตอนได้ในสภาพแวดล้อมที่ควบคุมได้

ในบทช่วยสอนนี้ จะสาธิตการใช้ Claude Sonnet 5 โมเดลล่าสุดจาก Anthropic ที่ออกแบบมาสำหรับการให้เหตุผลขั้นสูง การเขียนโค้ด และงานวิเคราะห์ข้อมูล ช่วยให้เอเจนต์ตรวจสอบข้อมูล ใช้เครื่องมือ เขียนและรันโค้ด และสร้างผลลัพธ์แบบมีโครงสร้างได้

คุณจะสร้าง Managed Agent กำหนดค่าสภาพแวดล้อม อัปโหลดไฟล์ CSV และให้เอเจนต์เข้าถึงเครื่องมือและสกิล XLSX

เอเจนต์จะวิเคราะห์ข้อมูล สร้างไฟล์ Python, JSON และ Excel ตรวจสอบผลลัพธ์ และเตรียมไฟล์ที่เสร็จสิ้นให้ดาวน์โหลดได้

หากยังใหม่กับ Claude แนะนำให้ดู คอร์ส Claude Code 101 ก่อน

Claude Managed Agents คืออะไร

Claude Managed Agents คือเฟรมเวิร์กแบบจัดการของ Anthropic สำหรับรัน Claude ให้ทำงานแบบเอเจนต์อัตโนมัติ

แทนที่จะต้องเขียนลูปเองเพื่อส่งพรอมป์ต์ เรียกใช้เครื่องมือ บันทึกผล และจัดการรันไทม์ เพียงกำหนดเอเจนต์แล้วให้ Anthropic จัดการอินฟราสตรักเจอร์เหล่านั้นแทน

เหมาะกับงานยาวหลายขั้นตอนที่โมเดลอาจต้องใช้หลายเครื่องมือก่อนจะทำงานเสร็จ

Managed Agents มีองค์ประกอบหลัก 4 ส่วน:

• Agent: การกำหนดค่าที่ใช้ซ้ำได้ ซึ่งประกอบด้วยโมเดล system prompt เครื่องมือ เซิร์ฟเวอร์ MCP และสกิล
• Environment: ที่ที่เอเจนต์ทำงาน จะเป็น cloud sandbox ของ Anthropic หรือ sandbox แบบโฮสต์เองก็ได้
• Session: อินสแตนซ์ที่กำลังรันของเอเจนต์สำหรับงานเฉพาะ
• Events: ข้อความ การเรียกใช้เครื่องมือ ผลลัพธ์ และการอัปเดตสถานะที่แลกเปลี่ยนกันระหว่างที่เซสชันทำงาน

1. ข้อกำหนดเบื้องต้นสำหรับพื้นที่ทำงานของ Claude Agent

เพื่อทำตามบทช่วยสอนนี้ ให้ติดตั้ง Python 3.12 ขึ้นไปและ Jupyter Notebook บนคอมพิวเตอร์ เราจะใช้ Jupyter Notebook เพื่อสร้าง รัน และตรวจสอบ Managed Agent แบบทีละขั้น

ต้องมีบัญชี Anthropic Console ด้วย

สร้างคีย์ API ใหม่ใน Console เติมเครดิต API อย่างน้อย $5 และเก็บคีย์ไว้อย่างปลอดภัย

Managed Agents อาจเรียกใช้โมเดลและเครื่องมือหลายครั้งในหนึ่งเซสชัน จึงอาจมีค่าใช้จ่ายสูงกว่าการเรียก API แบบมาตรฐาน

จัดเก็บคีย์เป็นตัวแปรสภาพแวดล้อม ANTHROPIC_API_KEY แทนการวางไว้ในโน้ตบุ๊กโดยตรงหรือคอมมิตขึ้น GitHub

สำหรับ macOS, Linux หรือ WSL ให้รันในเทอร์มินัลว่า:

export ANTHROPIC_API_KEY="your-api-key-here"

สำหรับ Windows PowerShell ให้ใช้:

$env:ANTHROPIC_API_KEY="your-api-key-here"

2. ตั้งค่า Anthropic Python SDK

ก่อนสร้าง Managed Agent ให้ติดตั้ง Anthropic Python SDK อย่างเป็นทางการและนำเข้าโมดูลที่ต้องใช้ในโน้ตบุ๊กนี้

SDK มีไคลเอนต์ Anthropic ซึ่งจะใช้สร้างเอเจนต์ สภาพแวดล้อม ไฟล์ และเซสชัน

%pip install -q --upgrade anthropic

จากนั้น โหลดคีย์ Anthropic API ของคุณจากตัวแปรสภาพแวดล้อม

การเก็บคีย์ไว้นอกโน้ตบุ๊กปลอดภัยกว่าการฝังคีย์ในโค้ดโดยตรง โดยเฉพาะหากจะเผยแพร่โปรเจกต์หรือดันขึ้น GitHub

import os
from anthropic import Anthropic

api_key = os.environ.get("ANTHROPIC_API_KEY")
assert api_key, "Set ANTHROPIC_API_KEY in your environment or in a local .env file."

ขณะนี้ Managed Agents เข้าถึงได้ผ่าน beta API ของ Anthropic ธงเบต้า managed-agents-2026-04-01 จะเปิดใช้งานฟีเจอร์นี้ แม้ว่า SDK อย่างเป็นทางการจะส่งเฮดเดอร์เบต้าที่ต้องใช้สำหรับคำขอ Managed Agents ให้อัตโนมัติอยู่แล้ว

เราคงธงนี้ไว้ในโน้ตบุ๊กเพราะภายหลังจะต้องใช้เมื่อลิสต์และดาวน์โหลดไฟล์ของเซสชัน

BETA_FLAG = "managed-agents-2026-04-01"

client = Anthropic(api_key=api_key)

สุดท้าย สร้างดิกชันนารีเพื่อเก็บ ID ของทรัพยากรทุกอย่างที่สร้างในบทช่วยสอนนี้

รวมถึงเอเจนต์ สภาพแวดล้อม ไฟล์ที่อัปโหลด และเซสชัน การบันทึก ID เหล่านี้ช่วยให้ลบทำความสะอาดได้ง่ายในตอนท้าย แม้ว่าขั้นตอนถัดไปจะล้มเหลวก็ตาม

created = {"agent": None, "environment": None, "file": None, "session": None}
print("✓ Anthropic client initialized.")

ขณะนี้ไคลเอนต์พร้อมแล้ว

3. สร้าง Managed Agent

Managed Agent คือการกำหนดค่าที่ใช้ซ้ำได้สำหรับเวิร์กโฟลว์ของคุณ

เมื่อสร้าง คุณจะเลือกโมเดล Claude เขียน system prompt เพื่อกำหนดบทบาทและคำสั่ง และผูกเครื่องมือกับสกิลที่เอเจนต์ใช้ได้

จากนั้นสามารถใช้เอเจนต์เดิมซ้ำได้ข้ามหลายเซสชัน แทนการสร้างค่ากำหนดใหม่ทุกครั้ง

เราจะตั้งชื่อเอเจนต์ว่า Sonnet 5 Data Analyst และใช้ claude-sonnet-5

system prompt บอกให้ทำตัวเหมือนนักวิเคราะห์ข้อมูลที่รอบคอบ: อ่านไฟล์ที่เมานต์ไว้ใน /workspace ใช้เครื่องมือรันโค้ดเพื่อวิเคราะห์ รายงานผลลัพธ์เชิงตัวเลขอย่างกระชับ และบันทึกไฟล์สุดท้ายไปที่ /mnt/session/outputs

agent = client.beta.agents.create(
    name="Sonnet 5 Data Analyst",
    model="claude-sonnet-5",
    system=(
        "You are a meticulous data analyst. When asked about data, always read the "
        "file mounted at /workspace, analyse it with the code execution tool, and "
        "report concise, numeric results. Use the XLSX skill for spreadsheet work. "
        "Save final artifacts to /mnt/session/outputs."
    ),
    tools=[
        {"type": "agent_toolset_20260401"},
    ],
    skills=[{"type": "anthropic", "skill_id": "xlsx"}],
)

agent_toolset_20260401 ทำให้เอเจนต์เข้าถึงเครื่องมือในตัวของ Anthropic ภายในเซสชันได้ ส่วนสกิล xlsx ให้แนวทางเฉพาะงานสำหรับการสร้างและวิเคราะห์เวิร์กบุ๊ก Excel

Anthropic ยังมีสกิลสำเร็จรูปสำหรับเวิร์กโฟลว์ PowerPoint, Word และ PDF ด้วย

สุดท้าย บันทึก ID ของเอเจนต์

จะใช้เมื่อต้องสร้างเซสชันต่อไป และช่วยให้ส่วนล้างข้อมูลสามารถเก็บเอเจนต์เข้าคลังหลังจบบทช่วยสอนได้

created["agent"] = agent.id
print(f"✓ Created agent: {agent.id}")

ควรเห็นเอาต์พุตประมาณว่า:

✓ Created agent: agent_01EVcgvQsAkLxNnJFp6aynwm

4. กำหนดค่า Anthropic Cloud Sandbox

ต่อไป เราจะสร้างสภาพแวดล้อมที่ Managed Agent จะรันระหว่างเซสชัน

สภาพแวดล้อมทำหน้าที่เป็น sandbox ที่ปลอดภัย ให้เอเจนต์มีพื้นที่แยกต่างหากสำหรับอ่านไฟล์ที่เมานต์ เขียนโค้ด และรันคำสั่ง

เราจะใช้สภาพแวดล้อมคลาวด์ของ Anthropic ที่มีการจำกัดเครือข่าย เอเจนต์จะใช้ sandbox นี้เพื่อวิเคราะห์ไฟล์ CSV ที่อัปโหลดด้วย Python ในภายหลัง

environment = client.beta.environments.create(
    name="code-exec-sandbox",
    config={"type": "cloud", "networking": {"type": "limited"}},
)

created["environment"] = environment.id
print(f"✓ Created environment: {environment.id}")

หลังรันเซลล์ ควรเห็น ID ของสภาพแวดล้อมคล้ายกับ:

✓ Created environment: env_01FzWACEf9UJDL65ovBPA1zf

5. อัปโหลดข้อมูลด้วย Anthropic Files API

ต่อไป เราจะอัปโหลดชุดข้อมูลที่เอเจนต์จะวิเคราะห์

Managed Agents ใช้ Anthropic Files API เพื่ออัปโหลดไฟล์จากเครื่อง ซึ่งสามารถเมานต์เข้าไปในสภาพแวดล้อมของเซสชันได้

สำหรับคู่มือนี้ เราใช้ชุดข้อมูลตัวอย่าง 12 แถวชื่อ sales_data.csv

ก่อนอัปโหลด เราจะตรวจสอบว่าไฟล์มีอยู่จริงและมีจำนวนแถวข้อมูลตามที่คาดไว้

from pathlib import Path

csv_path = Path("sales_data.csv")
assert csv_path.exists(), f"Missing input file: {csv_path.resolve()}"

row_count = sum(1 for _ in csv_path.open(encoding="utf-8")) - 1
assert row_count == 12, f"Expected 12 data rows, found {row_count}"

จากนั้นอัปโหลดไฟล์และเก็บ ID ไว้เพื่อล้างข้อมูลภายหลัง

uploaded = client.beta.files.upload(file=csv_path)

created["file"] = uploaded.id
print(f"✓ Uploaded {csv_path}: {uploaded.id} ({row_count} rows)")

หลังรันเซลล์ ควรเห็นเอาต์พุตประมาณว่า:

✓ Uploaded sales_data.csv: file_011Cch3EubJkswPdo3gMBvM2 (12 rows)

6. เริ่มต้นเซสชันการทำงานของเอเจนต์

ตอนนี้เราจะสร้างเซสชัน

เซสชันเชื่อมต่อเอเจนต์ สภาพแวดล้อม และทรัพยากรที่ต้องใช้สำหรับงานเฉพาะ ที่นี่ เราจะเมานต์ไฟล์ CSV ที่อัปโหลดไว้ที่ /workspace/sales_data.csv เพื่อให้เอเจนต์เข้าถึงจากภายใน sandbox ได้

session = client.beta.sessions.create(
    agent=agent.id,
    environment_id=environment.id,
    resources=[
        {
            "type": "file",
            "file_id": uploaded.id,
            "mount_path": "/workspace/sales_data.csv",
        },
    ],
)

created["session"] = session.id
print(f"✓ Created session: {session.id}")

ควรเห็น ID ของเซสชันคล้ายกับ:

✓ Created session: sesn_015mNhrKhqqfe7u8VP6GuFdr

7. สตรีมการตอบกลับของเอเจนต์

ตอนนี้ เราจะส่งงานไปยังเซสชันและสตรีมกิจกรรมของเอเจนต์ระหว่างทำงาน

การสร้างเซสชันเป็นเพียงการเตรียมเอเจนต์และ sandbox; เอเจนต์จะเริ่มทำงานหลังได้รับอีเวนต์ user.message

สตรีมของอีเวนต์ช่วยให้เราเห็นข้อความของเอเจนต์ การเรียกใช้เครื่องมือ และสถานะสุดท้ายของเซสชันแบบเรียลไทม์

พรอมป์ต์บอกให้เอเจนต์วิเคราะห์ไฟล์ CSV ที่เมานต์ เขียนและรันสคริปต์ Python สร้างสรุป JSON และทำรายงาน Excel

เรายังสร้างตัวแปร 3 ตัวเพื่อเก็บข้อความของเอเจนต์ บันทึกเครื่องมือที่ใช้ และยืนยันว่าเซสชันเสร็จสมบูรณ์หรือไม่

agent_text_parts = []
tools_used = []
final_status = None

with client.beta.sessions.events.stream(session.id) as stream:
    # Send the user message once the stream is open.
    client.beta.sessions.events.send(
        session.id,
        events=[
            {
                "type": "user.message",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Use the XLSX skill and analyze /workspace/sales_data.csv. "
                            "Write /mnt/session/outputs/analyze_sales.py, run that Python "
                            "script, and have it create /mnt/session/outputs/summary.json. "
                            "Also create /mnt/session/outputs/sales_report.xlsx with the "
                            "source data, monthly profit, and a summary sheet."
                        ),
                    }
                ],
            }
        ],
    )

    for event in stream:
        etype = getattr(event, "type", None)

        if etype == "agent.message":
            for block in event.content:
                txt = getattr(block, "text", None)
                if txt:
                    print(txt, end="")
                    agent_text_parts.append(txt)

        elif etype == "agent.tool_use":
            name = getattr(event, "name", "<tool>")
            print(f"\n[tool_use] {name}")
            tools_used.append(name)

        elif etype == "session.status_idle":
            final_status = "idle"
            print("\n\n✓ Agent finished; session is idle.")
            break

        elif etype == "session.status_error":
            final_status = "error"
            print("\n✗ Session reported an error.")
            break

print("Tools used:", tools_used)

ระหว่างการรัน ควรเห็นอีเวนต์เครื่องมือเช่น read, bash, write และ edit

ซึ่งแสดงว่าเอเจนต์กำลังตรวจสอบคำสั่งและไฟล์ที่มีอยู่ เขียนสคริปต์วิเคราะห์ รันใน sandbox และแก้ไขปัญหาที่พบ

เซสชันจะเข้าสู่สถานะ idle เมื่อเอเจนต์ไม่มีงานต่อไป ตัวอย่างนี้ session.status_idle บ่งชี้ว่างานเสร็จแล้ว จึงหยุดฟังสตรีม

Anthropic จัดการการรันเครื่องมือในตัวภายใน sandbox ให้เอง คุณต้องจัดการผลลัพธ์ของเครื่องมือเฉพาะเมื่อใช้เครื่องมือแบบกำหนดเองเท่านั้น

8. ดึงไฟล์ที่สร้างและประวัติอีเวนต์

เมื่อเซสชันเสร็จสมบูรณ์ เราสามารถตรวจสอบประวัติอีเวนต์ที่บันทึกไว้และดาวน์โหลดไฟล์ที่เอเจนต์สร้าง

ประวัติอีเวนต์ให้บันทึกเต็มรูปแบบของเซสชัน รวมคำขอโมเดล การเรียกใช้เครื่องมือ ผลลัพธ์จากเครื่องมือ และการเปลี่ยนสถานะ

history = client.beta.sessions.events.list(session.id, order="asc")

print("--- Session event history ---")
for event in history.data:
    print(event.type)

print(f"({len(history.data)} events total)")

ถัดไป เราลิสต์ไฟล์ที่แนบกับเซสชันและดาวน์โหลดไฟล์ที่ระบุว่าสามารถดาวน์โหลดได้ ไฟล์จะถูกบันทึกไว้ภายในโฟลเดอร์ outputs

import os

os.makedirs("outputs", exist_ok=True)

files = client.beta.files.list(scope_id=session.id, betas=[BETA_FLAG])
downloadable = [f for f in files.data if f.downloadable]

print(f"Found {len(downloadable)} downloadable file(s) for this session.")

downloaded_paths = []

for f in downloadable:
    try:
        content = client.beta.files.download(f.id, betas=[BETA_FLAG])
        local_path = os.path.join("outputs", f.filename)

        content.write_to_file(local_path)
        downloaded_paths.append(local_path)

        print(f"  downloaded {f.id} -> {local_path}")
    except Exception as exc:
        print(f"  skip {f.id}: {exc}")

สุดท้าย ตรวจสอบว่าเอาต์พุตที่คาดไว้ดาวน์โหลดมาครบแล้ว:

expected_outputs = {"analyze_sales.py", "summary.json", "sales_report.xlsx"}
downloaded_names = {os.path.basename(path) for path in downloaded_paths}

assert expected_outputs <= downloaded_names, (
    f"Missing expected outputs: {sorted(expected_outputs - downloaded_names)}"
)

สคริปต์ Python ที่สร้างไว้ สรุป JSON และรายงาน Excel พร้อมใช้งานในโฟลเดอร์ outputs ในเครื่องแล้ว

9. วิเคราะห์เอาต์พุต Python, JSON และ Excel

หลังเอเจนต์ทำงานเสร็จ ไฟล์ที่สร้างจะถูกดาวน์โหลดไปยังไดเรกทอรี outputs/ ในเครื่อง

ไฟล์เหล่านี้แสดงว่าเอเจนต์ทำมากกว่าการตอบข้อความ มันเขียนและรันโค้ด สร้างข้อมูลที่มีโครงสร้าง และผลิตรายงานสเปรดชีตที่ตรวจทานได้อย่างอิสระ

ภาพหน้าจอต่อไปนี้แสดงสิ่งประดิษฐ์ทั้งสามที่สร้างขึ้น

ไฟล์นี้มีโค้ดการวิเคราะห์ที่เอเจนต์เขียนและรัน ทำให้เวิร์กโฟลว์ทำซ้ำได้และตรวจสอบได้ง่าย

ไฟล์นี้เก็บผลลัพธ์ในรูปแบบที่มีโครงสร้าง ซึ่งแดชบอร์ด API หรือโปรแกรมอื่น ๆ สามารถนำไปใช้ได้

ไฟล์ Excel นี้แสดงการคำนวณรายเดือนแบบเห็นภาพ พร้อมรายได้ ต้นทุน กำไร มาร์จิน ยอดรวม และชาร์ต

สำหรับ 12 แถวใน sales_data.csv ผลลัพธ์ที่ตรวจสอบแล้วคือ:

• รายได้รวม: $32,900
• ต้นทุนรวม: $14,750
• กำไรรวม: $18,150
• กำไรเฉลี่ยต่อเดือน: $1,512.50
• เดือนที่ดีที่สุด: ธันวาคม (กำไร $2,550)
• เดือนที่แย่ที่สุด: มกราคม (กำไร $400)

เวิร์กบุ๊กขับเคลื่อนด้วยสูตร ไม่ได้พึ่งค่า hardcode เพียงอย่างเดียว

ระหว่างการรัน เอเจนต์อ่านคำสั่งของสกิล XLSX ที่แนบไว้ สร้างเวิร์กบุ๊ก คำนวณใหม่ด้วย LibreOffice ตรวจสอบสูตร และแก้ปัญหาอ้างอิงแบบวนซ้ำ ก่อนทำงานเสร็จ

10. ล้างทรัพยากรของ Managed Agent API

ทรัพยากรของ Managed Agent จะคงอยู่จนกว่าจะลบ ดังนั้นควรล้างเมื่อเสร็จงานแล้ว

ทรัพยากรที่ยังทำงานอยู่ โดยเฉพาะเซสชันและสภาพแวดล้อมที่กำลังรัน อาจก่อให้เกิดค่าใช้จ่ายหากปล่อยทิ้งไว้

เซสชันต้องอยู่ในสถานะ idle ก่อนจึงจะลบได้

ขั้นสุดท้ายนี้ เราจะลบเซสชัน ไฟล์ที่อัปโหลด และสภาพแวดล้อม แล้วเก็บเอเจนต์เข้าคลัง

การล้างแต่ละส่วนถูกห่อด้วยฟังก์ชันผู้ช่วย เพื่อให้การลบที่ล้มเหลวรายการหนึ่งไม่หยุดการลบทรัพยากรอื่น ๆ

def safe(label, fn):
    try:
        fn()
        print(f"✓ deleted {label}")
    except Exception as exc:
        print(f"· could not delete {label}: {exc}")

if created["session"]:
    safe("session", lambda: client.beta.sessions.delete(created["session"]))

if created["file"]:
    safe("file", lambda: client.beta.files.delete(created["file"]))

if created["environment"]:
    safe("environment", lambda: client.beta.environments.delete(created["environment"]))

if created["agent"]:
    safe("agent (archived)", lambda: client.beta.agents.archive(created["agent"]))

print("\n🎉 Cleanup complete. The agent is archived; other resources were deleted.")

ควรเห็นเอาต์พุตประมาณว่า:

✓ deleted session
✓ deleted file
✓ deleted environment
✓ deleted agent (archived)

🎉 Cleanup complete. The agent is archived; other resources were deleted.

โปรเจกต์ฉบับเต็ม รวมโน้ตบุ๊ก ไฟล์ CSV ตัวอย่าง และคำแนะนำการตั้งค่า มีให้บน GitHub

สามารถโคลนรีโพสิทอรีและรันโน้ตบุ๊กซ้ำเพื่อทำซ้ำผลลัพธ์จากคู่มือนี้

ข้อคิดส่งท้าย

ฉันพบว่า Claude Managed Agents ตั้งค่าและใช้งานได้ง่าย

สร้างเอเจนต์ ให้เครื่องมือ สกิล และ sandbox ที่ต้องใช้ แล้วรันผ่านเซสชัน

จากนั้นมันจัดการเวิร์กโฟลว์ครบถ้วนได้ เช่น เขียนโค้ด สร้างไฟล์ ตรวจสอบเอาต์พุตของตัวเอง และส่งคืนผลสุดท้าย

ตอนแรกฉันพยายามใช้ Modal Sandbox เพราะอยากได้สภาพแวดล้อมภายนอกที่ยืดหยุ่นกว่า

อย่างไรก็ตาม การตั้งค่าซับซ้อนเกินขอบเขตของคู่มือนี้ จึงตัดสินใจโฟกัสโปรเจกต์นี้ไว้ที่ cloud sandbox ที่จัดการโดย Anthropic

ข้อเสียหลักสำหรับฉันคือค่าใช้จ่าย ฉันรันตัวอย่างนี้สองครั้งด้วยไฟล์ CSV ขนาดเล็กแค่ 12 แถว และมีค่าใช้จ่ายประมาณ $0.25

แดชบอร์ดแสดงค่าใช้จ่ายภายใต้โมเดล แต่ฉันหาแจกแจงรายละเอียดไม่ได้ สำหรับงานคำนวณและสเปรดชีตง่าย ๆ รู้สึกว่าแพงเมื่อเทียบกับตัวเลือกโอเพ่นซอร์สที่ต้นทุนต่ำกว่า

โดยรวม โปรเจกต์นี้แสดงเวิร์กโฟลว์ Managed Agent แบบครบถ้วน: สร้างเอเจนต์ อัปโหลดไฟล์ CSV รัน Python ใน sandbox ที่มีการจัดการ สร้างรายงาน JSON และ Excel ตรวจสอบเอาต์พุต ดาวน์โหลดไฟล์ และล้างทรัพยากรภายหลัง