มาลองทำ AI Multi-agent Orchestration กันน

Summary of Technological Concepts & Features (AI Multi-Agent Orchestration)

The video explains how to orchestrate AI agents so that one AI can delegate tasks to other AIs (“multi-agent orchestration”). It focuses on how orchestration works behind the scenes and how to build practical examples.

1) Core idea: delegation/orchestration vs a single agent

• With a single AI agent, you “enter the command” and receive a response.
• With orchestration, there is typically one lead/orchestrator agent that:
  • breaks down the task,
  • dispatches subtasks to multiple other agents,
  • then collects and synthesizes their results into a final answer.

Delegation pattern (as described):

• One agent distributes tasks
• Others execute
• Results are gathered back

2) Scope: Agent CLI integrated into coding tools

The presenter frames the discussion around using CLI-integrated AI agents inside coding-oriented tools (names are mentioned as approximate auto-subtitles), including:

• Code/Codex-like tools
• Anti-Gravity (called out as fast to activate)
• Open Code (and others)

3) Recommended prior concepts (for context)

The video references earlier topics the viewer should review for deeper understanding:

• Graph analysis
• Deep Agent (as prerequisite concepts)

4) Sub-agents and why they help

A key mechanism is that these coding/agent tools support “sub-agents”:

• A custom sub-agent can be created with:
  • a defined role
  • knowledge
  • a set of available tools

Common orchestration pattern:

• A lead agent spawns multiple sub-agents (e.g., “Researcher,” “Reviewer,” etc.)
• Subtasks run in parallel
• Outputs are combined later

5) Example: parallel research / parallel code review

Examples described include:

• One agent creates work (e.g., code), then many agents independently review it
  • (the video mentions a scenario like “ten different agents”)
• An “agent research” sub-agent searches multiple dimensions concurrently
  • (e.g., three variables at once)

6) Context window reasoning (performance/cost tradeoffs)

The video discusses how orchestration impacts:

• Context management (main agent vs sub-agents)
• Potential economy/cost-effectiveness

Notable claim:

• It isn’t always cheaper, based on the presenter’s experience.

Main benefit highlighted:

• Orchestration can finish faster by parallelizing work, even if total cost doesn’t always drop (because each sub-agent may still need to gather/reconstruct context).

7) Headless mode for orchestration (CLI pipeline concept)

A major technical section explains Headless mode:

• Agents/tool commands can be run without interactive UI
• Execution happens via terminal-style STDOUT/STDIN piping

Core orchestration mechanism:

• Run an agent/tool command
• Take its standard output (often JSON)
• Feed that output as input to the next agent/tool

Described like a terminal pipeline:

• Output of one command becomes input to the next command

8) JSON-based workflows

Multiple times, the video emphasizes that agent/tool outputs come as JSON (sometimes referenced as “STEM JSON”).

The orchestrator can parse JSON chunks and route them, for example:

• status messages
• user vs assistant events
• resources arriving
• final synthesized results

9) Streaming UI/status updates via server-sent events

The presenter describes a runtime architecture for live feedback:

• The front-end receives live status updates while sub-agents run

Mechanism:

• A “server event” / event-stream style approach:
  • server continuously sends updates after the client connects
  • the client can’t send back during that stream

10) Two orchestration approaches highlighted

The video concludes there are two main ways to do orchestration:

1. Sub-agents approach

   • create/dispatch sub-agents
   • combine results

2. Headless pipeline approach

   • run tools/agents headlessly
   • pipe STDOUT → STDIN
   • orchestrate using shell-like chaining

11) Demo architecture: “plan → dispatch → sync/synthesize”

A concrete implementation pattern is described using code-like conceptual steps:

• plan: split the question into 3 parallel subtasks
• dispatch: send subtasks to specific workers/agents
• synthesize: wait for all results, then combine into a final response

It also references the idea of Promise.all (JavaScript conceptually) for waiting on parallel tasks.

12) Demo examples shown (high level)

The presenter describes three demo/case types:

• Case 1: create a custom multi-agent “character/vocabulary” system and generate webpage-like output
• Case 2: distribute a task across agents (e.g., comparing options or research angles) and synthesize a final summary
  • includes progress/status streaming
• Case 3: an RPG/game-like orchestration metaphor where task routing chooses a “runner”/agent (similar structure to case 1/2, but with only one runner chosen)

13) Tool capability note: image generation differences

The video notes capability differences between tools:

• Some tools (e.g., Codex in subtitles) can generate images via command execution
• Another referenced tool (“Code course”) may lack that image capability
  • it then requires delegating to an image-capable agent/tool

The demo attempts to create an image (e.g., “a cat running”) using an image-capable provider/tool.

14) Practical engineering concerns: tool permissions & security

When using headless execution:

• tool execution requires permissions
• outputs are routed through controlled channels
• arbitrary tool injection should be avoided
• some agent/tool invocations may be blocked unless explicitly allowed

---

Main Speakers / Sources

• Single main speaker (host/presenter; exact name not clearly available in the subtitles)
• Referenced sources (not treated as speakers):
  • “articles” by other agencies covering similar multi-agent topics
  • “vendor/platform documentation” for sub-agent features (implied: each tool provides similar sub-agent capability)