วิธีการสร้างและใช้ Subagents ใน Claude Code — คู่มือปฏิบัติ

CometAPI
AnnaOct 22, 2025
วิธีการสร้างและใช้ Subagents ใน Claude Code — คู่มือปฏิบัติ

ตัวแทนย่อยเป็นหนึ่งในส่วนเสริมที่มีประโยชน์มากที่สุดในระบบนิเวศ Claude Code / Claude Agent: ตัวแทนย่อยช่วยให้คุณแบ่งเวิร์กโฟลว์ที่ซับซ้อนออกเป็น "ทีม" AI เฉพาะทางขนาดเล็กลง รักษาบริบทของเธรดหลัก และจำกัดการเข้าถึงเครื่องมืออย่างปลอดภัย บทความนี้จะอธิบาย ตัวแทนย่อยคืออะไร, วิธีการสร้างและเรียกใช้งาน (CLI, ระบบไฟล์ และ SDK) หลักการออกแบบ คุณควรปฏิบัติตามเมื่อสร้างสิ่งเหล่านี้และ รหัสตัวอย่างคอนกรีต คุณสามารถคัดลอกและปรับใช้ได้

Subagents คืออะไร?

A ตัวแทนย่อย เป็นผู้ช่วย AI ที่มีการกำหนดค่าไว้ล่วงหน้าและมีขอบเขตจำกัด ซึ่ง Claude Code (หรือ Claude Agent SDK) สามารถมอบหมายงานให้ แต่ละเอเจนต์ย่อย:

  • มีชื่อที่เป็นเอกลักษณ์และมีคำอธิบายวัตถุประสงค์ที่ชัดเจน
  • วิ่งอยู่ใน หน้าต่างบริบทของตัวเอง แยกจากการสนทนาหลัก (เพื่อไม่ให้รายละเอียดยาวเกินไปจนทำให้บริบทของผู้ประสานงานเสียหาย)
  • สามารถกำหนดค่าด้วยชุดจำกัดได้ เครื่องมือ (การอ่าน/เขียนไฟล์, bash, grep, เครื่องมือ MCP ฯลฯ) และด้วยตัวเลือกโมเดลที่เฉพาะเจาะจง
  • ประกอบด้วยคำเตือนของระบบ (บุคลิกภาพและคำแนะนำของตัวแทนย่อย) ที่จะชี้นำพฤติกรรมและข้อจำกัด

คุณสมบัติเหล่านี้ทำให้ตัวแทนย่อยเหมาะอย่างยิ่งสำหรับงานที่ต้องใช้โทเค็นจำนวนมาก (การวิจัย การค้นหาบันทึกขนาดใหญ่) คำนึงถึงความปลอดภัย (การสแกนหรือเครื่องมือที่อาจก่อให้เกิดความเสียหาย) หรืองานที่ทำซ้ำและมีการระบุรายละเอียดชัดเจน (การตรวจสอบสไตล์ การรันการทดสอบ)

Anthropic ได้ดำเนินการวนซ้ำอย่างรวดเร็ว: Claude Code CLI และ Agent SDK ได้รับการรีแฟกเตอร์และขยายเป็น SDK ตัวแทน Claudeมีการแนะนำการรองรับปลั๊กอินสำหรับการรวมตัวแทนและการปรับแต่งที่เกี่ยวข้อง (คำสั่งสแลช เซิร์ฟเวอร์ MCP ฮุก) และ ทักษะ มอบวิธีการจัดแพ็กเกจเวิร์กโฟลว์โดเมนเพื่อนำกลับมาใช้ใหม่ทั่วทั้ง Claude.ai, Claude Code และ Agent SDK การอัปเดตเหล่านี้ทำให้การใช้งานง่ายขึ้น แบ่งปัน ติดตั้ง และเวอร์ชัน ตัวแทนย่อยข้ามทีมและโครงการ หากคุณวางแผนที่จะสร้างเวิร์กโฟลว์การผลิต คุณควรประเมินการแพ็คเกจปลั๊กอิน/ทักษะ และรูปแบบการปรับใช้ตาม SDK

เหตุใดตัวแทนย่อยจึงมีความสำคัญ

สามเหตุผลที่มันมีประโยชน์ทันที:

  1. การรักษาบริบท — การค้นหา การทดสอบ หรือการสแกนที่ยาวนานหรือมีสัญญาณรบกวน เกิดขึ้นภายในเอเจนต์ย่อยแทนที่จะครอบงำบริบทหลัก ซึ่งช่วยลดการสูญเสียโทเค็นและทำให้สามารถพิจารณาผลลัพธ์ได้ง่ายขึ้น
  2. ความเชี่ยวชาญเฉพาะทาง — คุณสามารถเข้ารหัสความรู้และพฤติกรรมของโดเมนในพรอมต์ระบบที่ปรับแต่งให้เหมาะกับงาน (เช่น security-auditor ซึ่งมุ่งเน้นไปที่ความลับ ปัญหาการอ้างอิง และการใช้งานเชลล์ที่ไม่ปลอดภัย)
  3. การอนุญาตที่ปลอดภัยยิ่งขึ้น — การจำกัดเครื่องมือต่อตัวแทนย่อยจะลดรัศมีการระเบิด (ผู้ตรวจสอบเอกสารอาจมีเครื่องมือแบบอ่านอย่างเดียว ผู้ดำเนินการทดสอบมี Bash แต่ไม่มี Edit).
  4. การขนาน: คุณสามารถสร้างตัวแทนย่อยหลายตัวเพื่อรันพร้อมกันได้ (ตัวอย่างเช่น: style-checker, security-scanner, test-runner) จากนั้นจึงรวบรวมผลลัพธ์สั้นๆ ของพวกเขา — ชัยชนะครั้งใหญ่สำหรับเช็คอิสระราคาแพง

ข้อกำหนดเบื้องต้นสำหรับการใช้ตัวแทนย่อยใน Claude Code

ก่อนที่คุณจะเริ่มสร้าง Subagents โปรดตรวจสอบให้แน่ใจว่าคุณมีสิ่งต่อไปนี้:

1) ติดตั้งและรับรองรหัส Claude แล้ว

ติดตั้ง Claude Code CLI หรือใช้การบูรณาการเว็บ/IDE เอกสารการเริ่มต้นใช้งานและการตั้งค่าด่วนของ CometAPI แสดงรายการวิธีการติดตั้งที่รองรับ (แพ็คเกจ npm ทั่วโลกหรือตัวติดตั้งดั้งเดิม) และแสดงวิธีการตรวจสอบการติดตั้งของคุณด้วย claude --version / claude doctor. คุณจะต้องมี โคเมทเอพีไอ บัญชี (การใช้คีย์ของ CometAPI เพื่อเข้าถึงโค้ด Claude นั้นถูกกว่าและสะดวกกว่ารุ่นอย่างเป็นทางการ) ตามที่ระบุไว้ในการเริ่มต้นอย่างรวดเร็ว

2) โหนด/สภาพแวดล้อม (สำหรับเส้นทางการติดตั้งบางส่วน) และเครื่องมือเชลล์พื้นฐาน

หากคุณติดตั้งผ่านแพ็กเกจ npm คุณควรมี Node.js (Node 18+ เป็นเรื่องปกติในตัวอย่าง) หากคุณต้องการใช้ Agent SDK (JavaScript/TypeScript หรือ Python) คุณจะต้องมีโปรเจ็กต์ที่ติดตั้ง SDK dependency ไว้ บทช่วยสอนหลายบทใช้เครื่องมือสำหรับนักพัฒนามาตรฐาน (git, bash, optional) gh CLI สำหรับเวิร์กโฟลว์ GitHub)

3) โครงร่างโครงการ & CLAUDE.md

แนวทางปฏิบัติที่ดีที่สุดคือการเก็บรักษาเอกสารช่วยเหลือระดับที่เก็บข้อมูล (CLAUDE.md) และใส่ตัวแทนที่มีขอบเขตโครงการใน .claude/agents/ เพื่อให้เพื่อนร่วมทีมสืบทอดไฟล์เหล่านั้น ไฟล์ CLAUDE.md จะถูกดึงเข้าสู่บริบทของ Claude โดยอัตโนมัติและช่วยกำหนดทิศทางการทำงานให้สอดคล้องกันในแต่ละเซสชัน แต่ละเอเจนต์ย่อยจะเป็นไฟล์ Markdown ที่มี YAML frontmatter ตัวอย่างขั้นต่ำ:

---
name: code-reviewer
description: Expert code review specialist. Use PROACTIVELY after code changes to check security, style, and maintainability.
tools: Read, Grep, Glob, Bash
model: inherit
---
You are a senior code reviewer. When invoked:
1. Run `git diff` to identify modified files.
2. Focus review on changed code paths.
3. List security issues, probable false positives, and suggested fixes.
4. Provide a short, prioritized action list.

Return results in JSON with fields: summary, issues.
  • name เป็นตัวระบุตัวพิมพ์เล็ก
  • description ไกด์การเรียกและจับคู่อัตโนมัติ
  • tools จำกัดการเข้าถึงเครื่องมือ (ละเว้นการสืบทอดทุกอย่าง)
  • model เป็นไปได้ sonnet, opus, haikuหรือ inherit.

4) การอนุญาตและเซิร์ฟเวอร์ MCP (ทางเลือกแต่ทั่วไป)

หากเวิร์กโฟลว์ของคุณใช้เซิร์ฟเวอร์ Model Context Protocol (MCP) หรือเครื่องมือภายนอก (Puppeteer, Sentry, เครื่องมือ REST แบบกำหนดเอง) โปรดตรวจสอบให้แน่ใจว่าเซิร์ฟเวอร์ MCP ของคุณได้รับการกำหนดค่าและสามารถเข้าถึงได้ สำหรับการดำเนินการที่ละเอียดอ่อน (write, bash, git commit) ควรพิจารณาอย่างรอบคอบเกี่ยวกับรายการอนุญาตและแต่ละเอเจนต์ tools การกำหนดขอบเขต

วิธีการสร้างตัวแทนย่อยใน Claude Code

คุณสามารถสร้างตัวแทนย่อยได้สามวิธีหลัก: ผ่าน CLI แบบโต้ตอบ (/agents) ในรูปแบบไฟล์มาร์กดาวน์ของระบบไฟล์ หรือผ่านโปรแกรมผ่าน Agent SDK ด้านล่างนี้คือตัวเลือกทีละขั้นตอน:

Claude Code รองรับสามวิธีในทางปฏิบัติในการสร้างตัวแทนย่อย:

  1. CLI . แบบโต้ตอบ /agents UI — เร็วที่สุดสำหรับการสร้างแบบวนซ้ำภายในเซสชัน
  2. ตามระบบไฟล์ — สร้างไฟล์ Markdown ด้วย YAML frontmatter ใน .claude/agents/ (ระดับโครงการ) หรือ ~/.claude/agents/ (ระดับผู้ใช้) ตัวแทนโครงการจะมีความสำคัญสูงกว่า
  3. โปรแกรม (Agent SDK) — กำหนดตัวแทนย่อยในโค้ดผ่านทาง agents พารามิเตอร์เมื่อคุณเรียก query(); แนะนำสำหรับแอปที่ขับเคลื่อนด้วย SDK วิธีนี้เหมาะอย่างยิ่งเมื่อต้องสร้างเอเจนต์ย่อยแบบไดนามิกหรือฝังไว้ในแอปพลิเคชัน

การไหลโต้ตอบอย่างรวดเร็ว (ขั้นตอนแรกที่แนะนำ)

  1. เริ่มต้น Claude Code ในเทอร์มินัลของคุณหรือเปิดจานคำสั่งใน VS Code
  2. รันอินเทอร์เฟซตัวแทนย่อยด้วยคำสั่งเครื่องหมายทับ:
/agents
  1. Choose สร้างตัวแทนใหม่เลือกขอบเขตระดับโครงการหรือระดับผู้ใช้ กรอกชื่อ/คำอธิบาย/เครื่องมือ/ระบบแจ้งเตือน แล้วบันทึก คุณสามารถสร้างแบบร่างด้วย Claude แล้วปรับแต่งได้ เมื่อบันทึกแล้ว ตัวแทนจะพร้อมใช้งานใน /agents และสามารถเรียกได้อย่างชัดแจ้งหรือโดยอัตโนมัติ

ตัวแทนย่อยตามระบบไฟล์ (Markdown + YAML frontmatter)

ตัวแทนย่อยจะถูกจัดเก็บเป็นไฟล์ Markdown พร้อม YAML frontmatter วางไว้ใน:

  • ขอบเขตโครงการ: .claude/agents/*.md (ลำดับความสำคัญสูงสุด)
  • ขอบเขตผู้ใช้: ~/.claude/agents/*.md

โครงสร้างไฟล์พื้นฐาน:

---
name: code-reviewer
description: "Review recent code changes for security and style."
tools: Read, Grep, Glob, Bash  # optional; omit to inherit

model: sonnet  # optional; or 'inherit'

---
You are a senior code reviewer with expertise in security, performance, and best practices.
When reviewing:
- Identify security vulnerabilities
- Prioritize clarity and maintainability
- Always provide concise examples and suggested fixes
- If unsure, ask for the minimal reproducible snippet

หมายเหตุการใช้งานบางประการ:

  • name ต้องเป็นตัวพิมพ์เล็กและมีเครื่องหมายยัติภังค์
  • ละเว้น tools จะให้ตัวแทนย่อยสืบทอดเครื่องมือทั้งหมดของเธรดหลัก การแสดงรายการเครื่องมืออย่างชัดเจนจะบังคับใช้โมเดลสิทธิ์น้อยที่สุด
  • ใช้ model: 'inherit' เพื่อให้มีพฤติกรรมที่สอดคล้องกับเธรดหลัก หรือระบุนามแฝงของโมเดล (เช่น sonnet, opus, haiku).

คำจำกัดความ CLI JSON (การใช้งานเฉพาะกิจ/เซสชัน)

คุณสามารถกำหนดตัวแทนย่อยชั่วคราวแบบอินไลน์เมื่อเปิดเซสชันได้:

claude --agents '{
  "code-reviewer": {
    "description": "Expert code reviewer.",
    "prompt": "You are a senior code reviewer. Focus on security and best practices.",
    "tools": ,
    "model": "sonnet"
  }
}'

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

คำจำกัดความของโปรแกรม (Agent SDK — แนะนำสำหรับแอป)

หากคุณกำลังสร้างแอปพลิเคชันหรือระบบอัตโนมัติ ให้กำหนดตัวแทนย่อยด้วยโปรแกรมผ่าน Agent SDK agents พารามิเตอร์ (นี่คือตัวเลือกที่บูรณาการมากที่สุด) ตัวอย่าง (TypeScript):

import { query } from '@anthropic-ai/claude-agent-sdk';

async function runReview() {
  const result = await query({
    prompt: "Assess the authentication module for security issues",
    options: {
      agents: {
        "code-reviewer": {
          description: "Expert code review specialist",
          prompt: `You are a code review specialist...`,
          tools: ,
          model: "sonnet"
        },
        "test-runner": {
          description: "Runs the test suite and analyzes failures",
          prompt: `You run tests and summarize failures...`,
          tools: ,
          model: "sonnet"
        }
      }
    }
  });

  console.log(result);
}

SDK ยังยอมรับตัวแทนที่ใช้ระบบไฟล์ (จะโหลด .claude/agents/ ไฟล์) หากคุณต้องการรูปแบบนั้น ตัวแทนเชิงโปรแกรมมีประสิทธิภาพสำหรับเวิร์กโฟลว์แบบไดนามิกและการผสานรวม CI

สำหรับ Python claude-agent-sdk แพ็คเกจรองรับรูปแบบที่คล้ายกัน: คุณสามารถใช้ query() or ClaudeSDKClient และกำหนดค่าตัวเลือก เครื่องมือ และเซิร์ฟเวอร์ MCP ผ่านทางโปรแกรม ดูตัวอย่างการเริ่มต้นใช้งานอย่างรวดเร็วได้ที่ Python SDK repo

วิธีการเรียกใช้ตัวแทนย่อย

การมอบหมายอัตโนมัติ

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

การเรียกที่ชัดเจน (แนะนำเพื่อความชัดเจน)

คุณสามารถเรียกใช้ตัวแทนอย่างชัดเจนในการสนทนาได้:

> Use the code-reviewer subagent to check my recent changes

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

รูปแบบออร์เคสเตรเตอร์ SDK

รูปแบบทั่วไปในแอป SDK:

  • ส้อม + รวบรวม:เปิดตัวตัวแทนย่อยหลายตัวพร้อมกัน รวบรวมคำตอบสั้นๆ ของตัวแทนแต่ละตัว จากนั้นสรุป/รวมผลลัพธ์ในตัวแทนหลัก
  • ลูปหัวหน้างาน:ผู้ประสานงานจะมอบหมายงานให้กับตัวแทนย่อย ตรวจสอบผลลัพธ์ และยอมรับผลลัพธ์หรือร้องขอการคำนวณใหม่/ชี้แจง
  • การดำเนินการแบบแซนด์บ็อกซ์:มอบความสามารถที่อาจก่อให้เกิดอันตรายได้ (การปรับใช้ การรันสคริปต์) ให้กับตัวแทนที่มีข้อจำกัดอย่างเข้มงวด และต้องมีการอนุมัติจากมนุษย์อย่างชัดเจนก่อนที่จะดำเนินการ

รูปแบบเหล่านี้จับคู่กับการใช้งานจริงโดยใช้การจัดการเซสชัน ฮุก และเครื่องมือ MCP ของ Agent SDK

วิธีสร้างตัวแทนย่อยที่มีประโยชน์ ปลอดภัย และจัดองค์ประกอบได้

1) ความรับผิดชอบเดียวและคำเตือนที่ชัดเจน

แต่ละเอเจนต์ย่อยควรมีจุดประสงค์ที่ชัดเจนและมีพรอมต์ของระบบที่ระบุขอบเขต เกณฑ์ความสำเร็จ และรูปแบบผลลัพธ์ หากผลลัพธ์ที่ต้องการมีโครงสร้าง (JSON, รายการหัวข้อย่อย, แพตช์โค้ด) ให้สั่งเอเจนต์ย่อยอย่างแม่นยำเพื่อลดข้อผิดพลาดในการแยกวิเคราะห์

2) สิทธิ์ขั้นต่ำสำหรับเครื่องมือ

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

3) คืนผลลัพธ์ที่กระชับและมีโครงสร้าง

ตัวแทนย่อยควรกลับมา คำตอบที่กระชับและสุดท้าย แทนที่จะใช้การติดตามความคิดที่ใช้เวลานาน รูปแบบทั่วไปคือ: ทำงานหนักภายในบริบทของเอเจนต์ย่อย จากนั้นส่งคืนบทสรุปสั้นๆ พร้อมไฟล์แนบ (แพตช์ การอ้างอิงไฟล์ JSON) วิธีนี้จะช่วยเพิ่มประสิทธิภาพบริบทสูงสุดสำหรับออร์เคสเตรเตอร์

4) การทดสอบและการกำหนดเวอร์ชัน

จัดเก็บไฟล์ตัวแทนย่อยไว้ในระบบควบคุมเวอร์ชัน สร้างการทดสอบ CI ที่ทดสอบการทำงานจริงกับอินพุตขนาดเล็ก และปักหมุดโมเดล/ชุดเครื่องมือ หากคุณใช้ Skills และปลั๊กอิน ให้ใช้รูปแบบตลาดปลั๊กอิน/การควบคุมเวอร์ชันเพื่อจัดการการอัปเกรดและการย้อนกลับ

5) การตรวจสอบจุดเชื่อมต่อและจุดตรวจสอบแบบมีมนุษย์ร่วมอยู่ในวงจร

ใช้ SDK hooks เพื่อสกัดกั้นการเรียกใช้เครื่องมือ (PreToolUse hooks) และกำหนดให้ต้องมีการอนุมัติจากมนุษย์สำหรับการดำเนินการทำลาย บันทึกการเรียกใช้เครื่องมือทั้งหมดเพื่อตรวจสอบซ้ำได้ SDK มี hooks และกลไกการอนุญาตเพื่อรองรับรูปแบบนี้

ตัวอย่างแอปพลิเคชัน — ท่อส่งขนาดเล็กที่คล้ายกับการผลิต

ด้านล่างนี้เป็นตัวอย่างที่กระชับซึ่งแสดงให้เห็นชิ้นส่วนทั่วไป ได้แก่ ตัวแทนระบบไฟล์ การเรียก SDK ที่ใช้ตัวแทนสองตัว (ตัวหนึ่งสำหรับการตรวจสอบ อีกตัวหนึ่งสำหรับการทดสอบ) และการประสานงานแบบง่าย

1) ตัวแทนระบบไฟล์: .claude/agents/code-reviewer.md

---
name: code-reviewer
description: Use PROACTIVELY after code changes. Perform security, style, and maintainability review on modified files.
tools: Read, Grep, Glob
model: inherit
---
You are a meticulous senior code reviewer. When invoked:
1. Run `git diff --name-only` to find modified files.
2. For each modified file, read and look for security issues, suspicious patterns, or maintainability problems.
3. Return JSON:
{
  "summary": "one-line summary",
  "issues": ,
  "recommended_changes": 
}

2) การประสานงานเชิงโปรแกรม (Node.js)

import { query } from '@anthropic-ai/claude-agent-sdk';
import fs from 'fs';

async function runPipeline() {
  const result = query({
    prompt: 'Run PR checks: security review then unit tests.',
    options: {
      agents: {
        'code-reviewer': {
          description: 'Use PROACTIVELY after code changes; output JSON with issues.',
          prompt: fs.readFileSync('./.claude/agents/code-reviewer.md', 'utf8'),
          tools: ,
          model: 'sonnet'
        },
        'test-runner': {
          description: 'Run test suite and summarize failing tests.',
          prompt: `You are a test-runner. Execute tests and return JSON { summary, failing_tests[] }`,
          tools: 
        }
      }
    }
  });

  for await (const message of result) {
    // Implement streaming logic: messages may include subagent outputs
    console.log(message);
  }
}

runPipeline().catch(console.error);

หมายเหตุ: code-reviewer จะถูกเก็บไว้ในที่เก็บข้อมูลสำหรับการนำกลับมาใช้ใหม่ของทีม การเรียก SDK แสดงให้เห็นถึงตัวแทนโปรแกรมที่มีความสำคัญเหนือกว่าและ tools การกำหนดขอบเขตช่วยป้องกันการเขียนโดยไม่ได้ตั้งใจ

หัวข้อและรูปแบบขั้นสูง

การกำหนดค่าตัวแทนแบบไดนามิก

สร้างโรงงานตัวแทนที่มีพารามิเตอร์ซึ่งเลือกโมเดลและชุดเครื่องมือขึ้นอยู่กับสภาพแวดล้อม (การพัฒนาเทียบกับการผลิต) หรือระดับความรุนแรง (เช่น strict vs balanced โหมดความปลอดภัย) ตัวอย่าง SDK แสดงวิธีการสร้างคำจำกัดความตัวแทนในระหว่างการรันไทม์

การขนานกัน

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

ตัวแทนที่จัดหาโดยปลั๊กอิน

ปลั๊กอินสามารถให้ตัวแทนย่อยที่รวมอยู่ในแพ็คเกจปลั๊กอิน manifest ซึ่งจะปรากฏใน /agents ควบคู่ไปกับเอเจนต์ที่กำหนดเอง และสามารถเรียกใช้งานโดยชัดเจน ใช้สิ่งนี้เพื่อกระจายเอเจนต์มาตรฐานไปยังทีมต่างๆ

แนะนำให้ใช้ Claude code cli ที่ไหน

เราตื่นเต้นที่จะประกาศว่าตอนนี้ CometAPI รองรับ Claude Code cli อันทรงพลังอย่างเต็มรูปแบบแล้ว คุณเพียงแค่ต้องติดตั้ง Claude Code และพิสูจน์ตัวตนด้วยรหัส API ของ Comet และที่อยู่ฐานที่ได้รับเพื่อใช้โมเดล API ของ Comet บน Claude Code

เหตุใดจึงต้องใช้โค้ดคล็อดผ่าน CometAPI?

คุณสมบัติปัญญาประดิษฐ์ชั้นนำ: สร้าง แก้ไข และเพิ่มประสิทธิภาพโค้ดได้อย่างง่ายดายโดยใช้โมเดลที่สร้างขึ้นโดยเฉพาะสำหรับนักพัฒนา

  • การเลือกโมเดลที่ยืดหยุ่น: โมเดลที่หลากหลายของเราช่วยให้คุณพัฒนาได้อย่างราบรื่นยิ่งขึ้น
  • การผสานรวมที่ราบรื่น: API พร้อมใช้งานเสมอ ผสานรวม Claude Code เข้ากับเวิร์กโฟลว์ที่มีอยู่ของคุณได้โดยตรงภายในไม่กี่นาที
  • การใช้ Claude Code ผ่าน CometAPI จะช่วยประหยัดต้นทุนได้มากขึ้นAPI ของ Claude ที่จัดทำโดย CometAPI ลดราคา 20% จากราคาอย่างเป็นทางการ และได้รับการอัปเดตด้วยรุ่นล่าสุดโดยทางการ

พร้อมที่จะใช้ Claude Code cli แล้วหรือยัง? ปรึกษา คู่มือ API สำหรับคำแนะนำโดยละเอียด

หากคุณต้องการทราบเคล็ดลับ คำแนะนำ และข่าวสารเกี่ยวกับ AI เพิ่มเติม โปรดติดตามเราที่ VK, X และ ไม่ลงรอยกัน!

ดูเพิ่มเติม จะติดตั้งและรัน Claude Code ผ่าน CometAPI ได้อย่างไร?

ความคิดสุดท้าย

ปฏิบัติต่อตัวแทนย่อยเป็น ไมโครเพอร์โซนาที่สามารถนำกลับมาใช้ใหม่ได้และมีเวอร์ชันต่างๆเริ่มต้นเล็ก ๆ: ทำ doc-reviewer และ test-runner สำหรับ repo ให้ตรวจสอบใน .claude/agents/และทำให้เป็นแบบอัตโนมัติใน CI โดยใช้ headless claude -pทำซ้ำคำเตือนของคุณ เพิ่มเอาต์พุตที่มีโครงสร้าง และเข้มงวดสิทธิ์ของเครื่องมือ

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

อ่านเพิ่มเติม

500+ โมเดลใน API เดียว

ลดราคาสูงสุด 20%