สร้าง AI Agent ด้วย Docker Agent: รันเอเจนท์ให้เหมือนคอนเทนเนอร์

Docker สร้างชื่อเสียงจากแนวคิดเดียวคือ: แพ็กเกจซอฟต์แวร์ครั้งเดียว รันได้ทุกที่ ในรูปแบบเดิมเสมอทุกครั้ง Docker Agent นำแนวคิดเดียวกันนั้นมาใช้กับ AI agents: โดยการอธิบายพวกมันในรูปแบบ declarative config แทนการเขียนโค้ด, รันผ่าน CLI plugin และเผยแพร่ผ่าน OCI registries แบบเดียวกับที่ใช้เก็บ container images ของคุณ หากคุณเคยปรารถนาให้ AI agent สามารถถูกกำหนดค่า, ทำ versioning และแชร์ได้เหมือนคอนเทนเนอร์ นี่คือเครื่องมือที่จะมาเติมเต็มช่องว่างนั้น

นี่คือบทช่วยสอนแบบลงมือทำจริง ตั้งแต่การติดตั้งใหม่ทั้งหมดไปจนถึงการสร้างทีม multi-agent ที่ใช้งานได้จริง

Docker Agent คืออะไร?

Docker Agent เป็น CLI plugin แบบ open-source ภายใต้สัญญาอนุญาต Apache 2.0-licensed ที่สร้างโดย Docker Engineering ติดตั้งและรันในชื่อ docker agent สโลแกนของมันระบุเป้าหมายอย่างชัดเจนว่า: รัน AI agents ให้เหมือนกับคอนเทนเนอร์

ประวัติ Go module บน pkg.go.dev แสดงให้เห็นการเปิดตัวเวอร์ชันแรกๆ ตั้งแต่เดือนมีนาคม 2026 และเติบโตอย่างรวดเร็วตั้งแต่นั้นมา โดยโปรเจกต์นี้มียอด GitHub stars เกิน 3,300 ดวง และมีการ commit เกือบ 10,000 ครั้งแล้ว

มันไม่ได้ปรากฏขึ้นมาลอยๆ Docker ใช้เวลาตลอดปี 2025 ในการสร้างสิ่งนี้: การประกาศเมื่อเดือนกรกฎาคม 2025 ได้ขยายความสามารถของ Docker Compose ให้รองรับ agent และโมเดล AI โดยตรง และ Docker Model Runner ถูกส่งออกมาเพื่อเป็นวิธีรันโมเดลในเครื่องโดยไม่ต้องใช้ cloud API key ซึ่ง Docker Agent คือผลผลิตของการวางรากฐานเหล่านั้นให้อยู่ในเครื่องมือเฉพาะหนึ่งเดียว แทนที่จะเป็นเพียงฟีเจอร์เสริมใน Compose

สิ่งที่ทำให้มันโดดเด่นจริงๆ คือ: agent ถูกกำหนดค่าในรูปแบบ YAML (หรือ HCL หากคุณชอบ syntax นั้น) ไม่ใช่โค้ด ซึ่งหมายความว่าไม่จำเป็นต้องมีพื้นฐานด้านวิศวกรรมซอฟต์แวร์ก็สร้างได้ มันเป็นแบบ provider-agnostic สามารถทำงานร่วมกับ OpenAI, Anthropic, Gemini, AWS Bedrock, Mistral, xAI และโมเดลในเครื่องผ่าน Docker Model Runner ดังนั้นการตั้งค่าจึงไม่ผูกติดกับผู้ให้บริการรายเดียว

ระบบยังรองรับ multi-agent orchestration อย่างแท้จริง ซึ่งเป็นทีมของ agent เฉพาะทางที่มอบหมายงานให้กันและกัน ระบบนิเวศประกอบด้วยเครื่องมือในตัวรวมถึง MCP server ใดๆ ก็ตาม ไม่ว่าจะรันในเครื่อง, ทางไกล หรือภายใน Docker container ของตัวเองเพื่อการแยกส่วน (isolation) และเมื่อเชื่อมโยงกลับไปยังการเปรียบเทียบกับคอนเทนเนอร์ agent ที่สร้างเสร็จแล้วสามารถถูก push ไปยังและ pull จาก OCI-compatible registry ใดๆ ก็ได้ ซึ่งเป็นกลไกการกระจายแบบเดียวกับที่ Docker image ใช้อยู่แล้ว

ข้อกำหนดเบื้องต้นและการติดตั้ง Docker Agent

คุณต้องมีสามสิ่ง: Docker ที่ติดตั้งในเครื่องของคุณ, วิธีที่จะรันมันจริงๆ และการเข้าถึง language model อย่างน้อยหนึ่งโมเดล

การติดตั้ง มีสามเส้นทางหลัก หากคุณรัน Docker Desktop 4.63 หรือใหม่กว่า plugin นี้จะมีอยู่แล้ว แค่รัน docker agent ผ่าน Homebrew ใช้คำสั่ง brew install docker-agent เพื่อติดตั้ง binary โดยตรง; รันด้วย docker-agent หรือสร้าง symlink ไปยัง ~/.docker/cli-plugins/docker-agent เพื่อใช้รูปแบบ docker agent แทน สำหรับ binary release ให้ดาวน์โหลดโดยตรงจาก GitHub Releases และสร้าง symlink ในลักษณะเดียวกัน

ขั้นตอนถัดไปคือการตั้งค่าโมเดล ซึ่งมีสองทางเลือกหลัก ทางที่ง่ายที่สุดคือ API key ของผู้ให้บริการคลาวด์ โดยตั้งค่าเป็น environment variable:

export ANTHROPIC_API_KEY=sk-ant-your-key-here
# หรือ OPENAI_API_KEY, GOOGLE_API_KEY ขึ้นอยู่กับผู้ให้บริการของคุณ

หรือข้ามการใช้ cloud key ไปเลยแล้วรันโมเดลในเครื่องผ่าน Docker Model Runner ซึ่งบทช่วยสอนส่วนที่เหลือจะระบุไว้เป็นทางเลือกในทุกจุดที่มีการระบุโมเดล ยืนยันว่าการติดตั้งสำเร็จด้วยคำสั่ง:

docker agent --help

หากคำสั่งนี้แสดงรายการคำสั่งต่างๆ แทนที่จะเป็นข้อผิดพลาด แสดงว่าคุณพร้อมสำหรับ agent ตัวแรกแล้ว

การสร้าง Agent ตัวแรกของคุณ

Docker Agent ที่ใช้งานได้จริงที่เล็กที่สุดคือไฟล์ YAML ไฟล์เดียว สร้างไฟล์ agent.yaml:

agents:
  root:
    model: anthropic/claude-sonnet-4-5
    description: A helpful coding assistant
    instruction: |
      You are an expert software developer. Help users write
      clean, efficient code. Explain your reasoning step by step.
    toolsets:
      - type: filesystem
      - type: shell
      - type: think

คำอธิบายโค้ด:

• root คือชื่อของ agent นี้ และทุกการตั้งค่าจำเป็นต้องมีอย่างน้อยหนึ่ง agent ที่มีชื่อนี้เป๊ะๆ เป็นจุดเริ่มต้น (entry point)
• model ใช้รูปแบบ provider/model-name ในที่นี้ชี้ไปยัง Claude Sonnet 4.5 ผ่าน Anthropic
• description คือบทสรุปสั้นๆ ที่ runtime ใช้เพื่อระบุตัวตนของ agent ซึ่งจะมีความสำคัญทันทีที่มี agent มากกว่าหนึ่งตัว
• instruction คือ system prompt หรือพฤติกรรมจริงที่คุณกำลังกำหนด โดยเขียนด้วยภาษาทั่วไป
• toolsets คือรายการความสามารถที่ agent นี้ใช้ได้: filesystem ให้สิทธิ์อ่านและเขียนไฟล์; shell อนุญาตให้รันคำสั่งต่างๆ
• think ให้พื้นที่แก่ agent ในการคิดหาเหตุผลเป็นขั้นตอนก่อนที่จะลงมือทำ

รันด้วย interactive terminal UI:

docker agent run agent.yaml

หรือรันแบบ non-interactive สำหรับงานเดียว ซึ่งมีประโยชน์ใน script หรือ CI:

docker agent run --exec agent.yaml "Create a Dockerfile for a Node.js app"

คำอธิบายโค้ด: คำสั่งแรกจะพาคุณเข้าสู่เซสชันแชทสดกับ agent ส่วน flag --exec จะข้ามวงจรโต้ตอบไปเลย โดยจะส่งคำสั่งเดียว พิมพ์ผลลัพธ์ แล้วจบการทำงาน ซึ่งเหมาะสำหรับการเรียกใช้จาก script

การมอบเครื่องมือจริงให้ Agent ของคุณ

filesystem และ shell นั้นมีประโยชน์ แต่ agent ที่มีความสามารถจริงๆ มักต้องการการเข้าถึงภายนอกเครื่องของคุณด้วย การรองรับ MCP ของ Docker Agent คือวิธีที่ทำให้สิ่งนั้นเกิดขึ้น

สิ่งที่แนะนำโดยเฉพาะคือการรัน MCP server ภายใน Docker container ของตัวเอง แยกจากระบบโฮสต์ แทนที่จะรันเป็น local process ปกติ:

agents:
  root:
    model: anthropic/claude-sonnet-4-5
    description: Research assistant with memory and web search
    instruction: |
      You are a research assistant. Search the web for information,
      remember important findings, and provide thorough analysis.
    toolsets:
      - type: think
      - type: memory
        path: ./research.db
      - type: mcp
        ref: docker:duckduckgo

คำอธิบายโค้ด: toolset memory ให้ที่เก็บข้อมูลถาวรเพื่อให้มันสามารถจดจำข้อเท็จจริงข้ามรอบได้ ส่วน toolset mcp พร้อม ref: docker:duckduckgo นั้น prefix docker: จะบอกให้ Docker Agent รัน DuckDuckGo MCP server ภายในคอนเทนเนอร์ของตัวเอง ซึ่งเป็นวิธีที่ปลอดภัยและถูกแยกส่วนโดยเริ่มต้น

การสร้างทีม Multi-Agent

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

agents:
  root:
    model: anthropic/claude-sonnet-4-5
    description: Coordinator for a content research team
    instruction: |
      You are a content lead coordinating a small research team.
      When given a topic, delegate web research to the researcher,
      then pass the findings to the writer to produce a short,
      well-organized report. Review the final output before
      presenting it to the user.
    sub_agents: [researcher, writer]
    toolsets:
      - type: think
 
researcher:
    model: openai/gpt-5
    description: Web researcher who gathers and summarizes findings
    instruction: |
      Search the web for current, credible information on the
      given topic. Summarize the key findings in a structured list,
      noting the source for each claim.
    toolsets:
      - type: mcp
        ref: docker:duckduckgo
      - type: memory
        path: ./research.db
 
writer:
    model: anthropic/claude-sonnet-4-5
    description: Turns research findings into a clear, organized report
    instruction: |
      Take the research findings you're given and write a short,
      well-structured report a general reader could follow, with
      clear section headings and no unexplained jargon.
    toolsets:
      - type: filesystem

คำอธิบายโค้ด: บรรทัด sub_agents: [researcher, writer] ใน agent root คือสิ่งที่เปลี่ยนจาก agent แยกส่วนให้กลายเป็นทีมที่ประสานงานกัน โดยมันให้สิทธิ์การเข้าถึงเครื่องมือ transfer_task ในตัวโดยอัตโนมัติ

เมื่อผู้ประสานงานเรียกใช้ transfer_task ระบบจะเริ่มการทำงานของผู้วิจัยใน sub-session ใหม่ที่สะอาดตา รอจนเสร็จสิ้น และส่งผลกลับมา รูปแบบนี้แตกต่างจาก handoffs ที่ส่งต่อประวัติการสนทนาทั้งหมด ซึ่งแบบแรกเหมาะกับการประสานงานและสังเคราะห์ผลลัพธ์มากกว่า สังเกตว่าคุณสามารถเลือกโมเดลที่ดีที่สุดสำหรับแต่ละบทบาทได้ เช่น ใช้ GPT-5 สำหรับการวิจัย และ Claude สำหรับงานเขียน

การตรวจสอบความถูกต้องและการรันการตั้งค่า

schema จริงของ Docker Agent ทำให้การตรวจสอบความถูกต้องเป็นขั้นตอนที่แน่นอน นี่คือตัวตรวจสอบ (validator) ที่ใช้ตรวจสอบทุกการตั้งค่าในบทความนี้ตาม schema จาก repository ของโปรเจกต์:

import yaml, json, jsonschema
 
with open("agent-schema.json") as f:
    SCHEMA = json.load(f)
 
def validate(yaml_text: str, label: str):
    config = yaml.safe_load(yaml_text)
    try:
        jsonschema.validate(instance=config, schema=SCHEMA)
        print(f"[{label}] VALID against agent-schema.json")
    except jsonschema.ValidationError as e:
        print(f"[{label}] SCHEMA VALIDATION ERROR: {e.message}")

เมื่อยืนยันว่าการตั้งค่าถูกต้องแล้ว คุณสามารถเลือกวิธีรันได้ ทั้งแบบ Interactive หรือแบบอัตโนมัติผ่าน --exec นอกจากนี้การเพิ่ม --yolo จะเป็นการอนุมัติการเรียกใช้เครื่องมือทุกอย่างโดยอัตโนมัติ ซึ่งควรใช้อย่างระมัดระวัง สำหรับผู้ที่ต้องการเริ่มต้นอย่างรวดเร็ว สามารถใช้คำสั่ง docker agent getting-started เพื่อดูการสาธิตในหน้าแชทจริงได้

การแพ็กเกจและแบ่งปัน Agent ของคุณ

เมื่อทีม agent ทำงานได้ตามต้องการแล้ว คุณสามารถใช้กลไกการกระจายตาม OCI เพื่อ push agent ไปยัง registry และ pull ลงมาใช้งานที่ไหนก็ได้โดยไม่จำเป็นต้องมีไฟล์ YAML ในเครื่องปลายทาง:

docker agent run myorg/agent:tag

Agent ยังสามารถอ้างอิงถึงกันผ่านระบบ registry ได้ด้วย:

agents:
  root:
    model: openai/gpt-5
    description: Coordinator that delegates to a shared, pinned research agent
    instruction: |
      Delegate research tasks to the shared researcher agent.
    sub_agents:
      - reviewer:docker.io/myorg/review-agent@sha256:44117e73263afa5c861bdf3730dae7925918ffdd146827eee5bcff20bc55e8fa

คำอธิบายโค้ด: การระบุด้วย immutable digest อย่าง @sha256:... จะช่วยให้ runtime ดึง agent มาจาก local cache โดยตรง ไม่ต้องผ่านเครือข่ายใหม่ทุกครั้ง ทำให้เริ่มต้นได้รวดเร็วและพฤติกรรมของทีมคงที่ (reproducible) เพราะ digest จะไม่มีวันเปลี่ยนแปลง

บทสรุป

สิ่งที่น่าสนใจของ Docker Agent คือการปฏิบัติกับคำจำกัดความของ agent ทั้งโมเดล คำสั่ง และเครื่องมือ ในฐานะ artifact ที่พกพาได้และทำ versioning ได้ ซึ่งจัดเก็บใน source control และส่งผ่านโครงสร้างพื้นฐานเดียวกับ container image ได้ทันที การเริ่มต้นด้วยไฟล์เดี่ยวและค่อยๆ ขยายผลโดยมีการตรวจสอบผ่าน schema จะช่วยให้การสร้าง AI agent มีประสิทธิภาพและแม่นยำยิ่งขึ้น