วิธีสร้างเอเจนต์ AI ด้วย Grok 4.7: Python, การเรียกใช้เครื่องมือ, และฟอลแบ็กหลายโมเดล

หากคุณต้องการสร้างแอป AI เดียวที่ใช้ GPT, Claude, Gemini, DeepSeek และ Grok ให้ใช้งาน API แบบรวมสำหรับเส้นทางคำขอร่วม และคงนโยบายการกำหนดเส้นทางไว้ภายในแอปพลิเคชันของคุณ CometAPI มี base URL ที่รองรับ OpenAI และแคตตาล็อกโมเดลร่วม ทำให้บริการ Python สามารถเรียกใช้โมเดลต่างกันผ่านไคลเอนต์เดียวได้ โค้ดของคุณยังคงเป็นผู้ตัดสินใจว่าโมเดลใดจะทำงาน อนุญาตเครื่องมือใด และเมื่อใดที่การ fallback จึงปลอดภัย

คู่มือนี้สร้างเอเจนต์ Grok 4.7 ที่สามารถเรียกเครื่องมือธุรกิจแบบอ่านอย่างเดียว 2 ตัว ปฏิเสธเครื่องมือที่ไม่รู้จักและอาร์กิวเมนต์ที่ผิดรูปก่อนการรัน และสลับไปใช้โมเดลอื่นที่ผ่านการทดสอบตามสัญญาเฉพาะหลังความล้มเหลวชั่วคราวที่เลือกเท่านั้น เป้าหมายไม่ใช่ระบบอัตโนมัติที่วิเศษ แต่วงรอบเล็กๆ ที่ตรวจสอบได้ ซึ่งสามารถทดสอบและใช้งานจริงได้ในโปรดักชัน

สิ่งที่คุณกำลังสร้าง

เอเจนต์นี้มีองค์ประกอบชัดเจน 5 ส่วน:

หนึ่งไคลเอนต์ CometAPI โดย OpenAI Python SDK ใช้ base URL ของ CometAPI ตามการตั้งค่าด้านล่าง
Grok 4.7 เป็นโมเดลหลัก โดย CometAPI model ID ปัจจุบันคือ grok-4.7
รีจิสทรีเครื่องมือ โมเดลอาจเสนอให้เรียกฟังก์ชัน แต่มีเพียงโค้ดแอปเท่านั้นที่สามารถรันฟังก์ชันที่อยู่ในรายชื่ออนุญาต
วงรอบเอเจนต์แบบมีขอบเขต วงรอบจะหยุดหลังจำนวนรอบโมเดลที่กำหนดแทนที่จะรันไม่จำกัด
นโยบาย fallback แบบมีลำดับ จะลองใช้ GPT, Claude, Gemini หรือ DeepSeek ที่เข้ากันได้เฉพาะหลังความล้มเหลวของโมเดล/API ที่สามารถ retry ได้

Grok 4.7 รองรับการเรียกฟังก์ชัน และ CometAPI ปัจจุบันมีทั้งเส้นทาง /v1/chat/completions และ /v1/responses สำหรับโมเดลนี้ คู่มือนี้ใช้ Chat Completions เพราะ tools แบบเข้ากันกับ OpenAI การเรียกเครื่องมือโดยแอสซิสแทนต์ และข้อความผลลัพธ์ tool ที่สอดคล้องกัน สามารถแมปเป็นลูป Python ที่เล็กและตรวจสอบได้โดยตรง ความเข้ากันได้ด้านทรานสปอร์ตไม่ได้พิสูจน์ความเท่าเทียมของฟีเจอร์ในทุกโมเดล ดังนั้นทุก fallback ที่ตั้งค่าต้องผ่านการทดสอบสัญญาเดียวกันก่อนขึ้นโปรดักชัน

สถานะการให้เหตุผลในเอเจนต์ Grok 4.7 แบบหลายรอบ

Grok 4.7 รับระดับความพยายามในการให้เหตุผล low, medium, high หรือ xhigh โดย high เป็นค่าเริ่มต้น บน Responses API ของ xAI ทุกคำตอบของ Grok 4.7 จะมี reasoning.encrypted_content วงรอบหลายรอบที่บริหารโดยไคลเอนต์ควรส่งต่อรายการ reasoning ที่ได้รับกลับไปแบบไม่แก้ไขในคำขอถัดไป วงรอบยาวสามารถใช้ context compaction: เก็บรายการ compaction ที่คืนมาเป็นสถานะทึบ แล้วผนวกรอบใหม่ต่อท้าย เนื่องจากนี่เป็นฟิลด์การตอบกลับที่มีสถานะและเฉพาะผู้ให้บริการ โปรดตรวจสอบว่าเส้นทาง CometAPI ที่เลือกส่งฟิลด์เหล่านี้แบบ end-to-end ก่อนพึ่งพาในโปรดักชัน

สถาปัตยกรรมเอเจนต์: โมเดลเสนอ แอปของคุณตัดสินใจ

โฟลว์การเรียกเครื่องมือที่ปลอดภัยนั้นเรียบง่าย:

User request → model response → validate tool call → execute allowlisted tool → append tool result → model response

โมเดลจะไม่ได้รับข้อมูลรับรองฐานข้อมูลและไม่รัน Python โดยตรง มันสร้างคำขอแบบมีโครงสร้าง เช่น “เรียก get_order_status ด้วย order ID นี้” แอปพลิเคชันของคุณตรวจสอบชื่อเครื่องมือ แปลงอาร์กิวเมนต์ ใช้การอนุญาตและกฎธุรกิจ รันฟังก์ชัน และคืนผลลัพธ์แบบซีเรียลไลซ์

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

วิธีสร้างเอเจนต์ AI Grok 4.7 ด้วย Python

ขั้นตอนที่ 1: ตั้งค่า OpenAI Python SDK สำหรับ CometAPI

ติดตั้ง OpenAI SDK:

pip install openai

ตั้งค่าผ่านตัวแปรสภาพแวดล้อม:

export COMETAPI_KEY="your-cometapi-key"
export PRIMARY_MODEL="grok-4.7"
export FALLBACK_MODEL_1="your-compatible-gpt-model-id"
export FALLBACK_MODEL_2="your-compatible-claude-model-id"
export FALLBACK_MODEL_3="your-compatible-gemini-model-id"
export FALLBACK_MODEL_4="your-compatible-deepseek-model-id"

คู่มือนี้ใช้ Chat Completions เพราะการเรียกเครื่องมือโดยแอสซิสแทนต์ที่ชัดเจนและข้อความผลลัพธ์เครื่องมือที่ตรงกัน ทำให้โฟลว์การควบคุมตรวจสอบง่ายในตัวอย่าง Python ขนาดกะทัดรัด สำหรับวงรอบสถานะยาว ให้ประเมิน Responses API ตามที่กล่าวไว้ข้างต้น และอย่าคัดลอก model ID เก่าจากบล็อกไปใช้ในโปรดักชัน: ดึงแคตตาล็อกสาธารณะ GET /api/models ของ CometAPI ระหว่างการดีพลอยหรือสตาร์ทอัพ แล้วยืนยันความสามารถและราคาใน model directory

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
    max_retries=0,
    timeout=30.0,
)

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

ขั้นตอนที่ 2: เริ่มจากเครื่องมือแบบอ่านอย่างเดียวที่แคบ

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

import json

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "Read the current status of one order.",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"}
                },
                "required": ["order_id"],
                "additionalProperties": False,
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "check_inventory",
            "description": "Read available inventory for one SKU.",
            "parameters": {
                "type": "object",
                "properties": {
                    "sku": {"type": "string"}
                },
                "required": ["sku"],
                "additionalProperties": False,
            },
        },
    },
]

def get_order_status(order_id: str) -> dict:
    # แทนที่เดโมนี้ด้วยการเรียกบริการแบบอ่านอย่างเดียวที่ผ่านการรับรองความถูกต้อง
    return {"order_id": order_id, "status": "in_transit"}

def check_inventory(sku: str) -> dict:
    # แทนที่เดโมนี้ด้วยการเรียกบริการแบบอ่านอย่างเดียวที่ผ่านการรับรองความถูกต้อง
    return {"sku": sku, "available_units": 12}

TOOL_REGISTRY = {
    "get_order_status": get_order_status,
    "check_inventory": check_inventory,
}

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

ขั้นตอนที่ 3: เพิ่มนโยบาย fallback แบบแคบสำหรับหลายโมเดล

Fallback ควรฟื้นจากความล้มเหลวของเส้นทางแบบชั่วคราว ไม่ใช่ซ่อนคำขอที่เสีย CometAPI แนะนำให้ย้ายไปยังเส้นทางถัดไปสำหรับข้อผิดพลาดการเชื่อมต่อ การหมดเวลา HTTP 408 HTTP 429 และ 5xx ชั่วคราว ข้อมูลรับรองไม่ถูกต้อง พารามิเตอร์ที่ไม่รองรับ และคำขอไม่ถูกต้องควรล้มทันที

from openai import APIConnectionError, APIStatusError, APITimeoutError

def configured_models() -> list[str]:
    names = [
        os.getenv("PRIMARY_MODEL", "grok-4.7"),
        os.getenv("FALLBACK_MODEL_1"),
        os.getenv("FALLBACK_MODEL_2"),
        os.getenv("FALLBACK_MODEL_3"),
        os.getenv("FALLBACK_MODEL_4"),
    ]
    return [name for name in names if name]

def is_retryable(error: Exception) -> bool:
    if isinstance(error, (APIConnectionError, APITimeoutError)):
        return True
    if isinstance(error, APIStatusError):
        return error.status_code in {408, 429} or error.status_code >= 500
    return False

def complete_with_fallback(messages: list[dict], tools: list[dict]):
    models = configured_models()
    last_error = None

    for index, model in enumerate(models):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                tools=tools,
                tool_choice="auto",
            )
            return response, model
        except Exception as error:
            last_error = error
            final_route = index == len(models) - 1
            if final_route or not is_retryable(error):
                raise

    raise RuntimeError("No configured model completed the request") from last_error

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

ขั้นตอนที่ 4: รันวงรอบเอเจนต์ Grok 4.7 แบบมีขอบเขต

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

def execute_tool_call(tool_call) -> str:
    name = tool_call.function.name

    if name not in TOOL_REGISTRY:
        return json.dumps({"error": f"Tool not allowed: {name}"})

    try:
        arguments = json.loads(tool_call.function.arguments)
        result = TOOL_REGISTRY[name](**arguments)
        return json.dumps(result)
    except (json.JSONDecodeError, TypeError, ValueError) as error:
        return json.dumps({"error": f"Invalid tool arguments: {error}"})

def run_agent(user_text: str, max_turns: int = 4) -> dict:
    messages = [
        {
            "role": "system",
            "content": (
                "You are a support agent. Use tools only when needed. "
                "Never invent order or inventory data."
            ),
        },
        {"role": "user", "content": user_text},
    ]
    route_log = []

    for turn in range(max_turns):
        response, model = complete_with_fallback(messages, TOOLS)
        route_log.append({"turn": turn + 1, "model": model})

        assistant = response.choices[0].message
        messages.append(assistant.model_dump(exclude_none=True))

        if not assistant.tool_calls:
            return {
                "answer": assistant.content,
                "routes": route_log,
                "usage": response.usage.model_dump() if response.usage else None,
            }

        for tool_call in assistant.tool_calls:
            messages.append(
                {
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": execute_tool_call(tool_call),
                }
            )

    raise RuntimeError("Agent stopped after reaching max_turns")

result = run_agent("Where is order A-104, and is SKU BLUE-42 in stock?")
print(result["answer"])
print(result["routes"])

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

GPT, Claude, Gemini และ DeepSeek เข้ากับแอปเดียวกันอย่างไร

CometAPI ช่วยลดการทำงานซ้ำในเลเยอร์การเชื่อมต่อ: บัญชีเดียว base URL ที่เข้ากันกับ OpenAI สำหรับเส้นทางร่วม และเลือกโมเดลด้วย model ID โดยโค้ดแอป ทำให้ GPT, Claude, Gemini, DeepSeek และ Grok เป็นตัวเลือกอยู่หลังอินเทอร์เฟซภายในเดียวกัน

แต่นั่นไม่ได้ทำให้โมเดลแทนกันได้ ก่อนเพิ่ม fallback ให้ตรวจสอบว่า:

model ID ปัจจุบันถูกส่งกลับโดยแคตตาล็อกของ CometAPI;
เส้นทางรองรับ schema เครื่องมือและบทบาทข้อความที่ต้องการ;
อาร์กิวเมนต์ในการเรียกเครื่องมือและพฤติกรรมการเรียกหลายครั้งตรงตามสัญญาของเอเจนต์;
หน้าต่างคอนเท็กซ์และโมดาลิตีอินพุตเหมาะกับคำขอ;
คำตอบสามารถตรวจสอบได้ก่อนถึงผู้ใช้;
latency และต้นทุนยังอยู่ในงบประมาณของโปรดักต์

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

Grok 4.7 Multi-Model Fallback ไม่ใช่ระบบ Multi-Agent

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

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

รั้วคุ้มกันสำหรับโปรดักชันของเอเจนต์ Grok 4.7

ตรวจสอบก่อนรันเครื่องมือ

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

แยกเครื่องมืออ่านออกจากเครื่องมือเขียน

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

กำหนดขอบเขตให้ทุกลูป

ตั้งจำนวนรอบของโมเดลสูงสุด จำนวนการเรียกเครื่องมือ เวลา wall-clock ขนาดพรอมต์ และงบโทเค็น คืนข้อผิดพลาดที่ควบคุมได้หรือเส้นทางส่งต่อเมื่อถึงขอบเขต

บันทึกร่องรอยการตัดสินใจ

ล็อกงานที่ร้องขอ เวอร์ชันนโยบาย model ID ที่เลือก เหตุผลในการ fallback ชื่อเครื่องมือ latency ของเครื่องมือ ผลการตรวจสอบ การใช้โทเค็น และสถานะสุดท้าย อย่าล็อกความลับหรือเนื้อหาลูกค้าที่ไม่จำเป็น

ใช้การทดสอบตามสัญญา ไม่ใช่การคาดเดา

รันฟิกซ์เจอร์เดียวกันกับทุกโมเดลที่ตั้งค่า ชุดขั้นต่ำที่มีประโยชน์ควรครอบคลุมคำตอบปกติ การเรียกเครื่องมือหนึ่งครั้ง การเรียกหลายเครื่องมือ อาร์กิวเมนต์ที่ผิดรูป เครื่องมือที่ไม่รู้จัก การหมดเวลาของเครื่องมือ primary-model 429 และคีย์ API ไม่ถูกต้องซึ่งต้องไม่กระตุ้น fallback

เช็กลิสต์ก่อนดีพลอย

ดึง model ID ปัจจุบันและยืนยันเส้นทาง Grok 4.7 ก่อนดีพลอย
เก็บคีย์ CometAPI ไว้ในตัวจัดการความลับ ไม่ใช่ในซอร์สโค้ดหรือพรอมต์
เริ่มจากเครื่องมืออ่านอย่างเดียวพร้อม JSON schema ที่ชัดเจน
ใช้การยืนยันตัวตนและการอนุญาตผู้เช่าก่อนการเรียกเครื่องมือทุกครั้ง
อนุญาต fallback เฉพาะสำหรับข้อผิดพลาดชั่วคราวที่จำแนกแล้ว
ทดสอบทุก fallback กับสัญญาการเรียกเครื่องมือเดียวกัน
เพิ่ม idempotency และการยืนยันก่อนเปิดใช้เครื่องมือเขียน
ตั้งขีดจำกัดลูป latency คอนเท็กซ์ และต้นทุน
วัดความสำเร็จของงาน ไม่ใช่แค่ความพร้อมของ API

ทำไมจึงสร้างเอเจนต์นี้ผ่าน CometAPI?

CometAPI มีประโยชน์เพราะการผสานรวมร่วมยังคงเล็ก OpenAI Python SDK ชี้ไปที่ base URL เดียว เลือก Grok 4.7 ด้วย model ID และโมเดลที่เข้ากันได้จากผู้ให้บริการอื่นสามารถวางไว้หลังนโยบายเส้นทางที่แอปเป็นเจ้าของเดียวกัน

นั่นทำให้ทีมมีพื้นที่ประเมิน GPT, Claude, Gemini และ DeepSeek โดยไม่ต้องกระจายโค้ดเชื่อมต่อเฉพาะผู้ให้บริการไปทั่วโปรดักต์ และยังคงขอบเขตสำคัญไว้: CometAPI จัดหา access ขณะที่แอปพลิเคชันของคุณเป็นเจ้าของการตรวจสอบความสามารถ การรันเครื่องมือ นโยบาย fallback การประเมินผล และพฤติกรรมที่ผู้ใช้เห็น

ตรวจสอบหน้าโมเดล Grok 4.7 ตั้งค่าไคลเอนต์จาก CometAPI quickstart และดึง model ID ปัจจุบันก่อนเลือก fallback สำหรับโปรดักชัน

คำถามที่พบบ่อย

ฉันควรใช้ API อะไรสำหรับแอปที่มี GPT, Claude, Gemini และ DeepSeek?

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

Grok 4.7 เรียกฟังก์ชัน Python ได้โดยตรงหรือไม่?

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

ทุกข้อผิดพลาดควรกระตุ้นให้ใช้โมเดลอื่นหรือไม่?

ไม่ ควรใช้ fallback สำหรับข้อผิดพลาดการเชื่อมต่อที่เลือก การหมดเวลา 408, 429 และ 5xx ชั่วคราว คำขอไม่ถูกต้อง การยืนยันตัวตนล้มเหลว และพารามิเตอร์ที่ไม่รองรับควรแก้ไขแทนที่จะส่งไปยังโมเดลอื่น

ฉันสามารถใช้ schema เครื่องมือเดียวกับทุกโมเดลได้หรือไม่?

เฉพาะหลังการทดสอบ การขนส่งร่วมไม่ได้รับประกันพฤติกรรมเครื่องมือที่เหมือนกัน คุณภาพอาร์กิวเมนต์ พฤติกรรมการเรียกคู่ขนาน หรือการบังคับใช้ schema เพิ่มโมเดลเข้ากับเชนเฉพาะหลังผ่านการทดสอบสัญญาของเอเจนต์

ระบบ fallback หลายโมเดลคือระบบหลายเอเจนต์หรือไม่?

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