Lesson 68 — Beginner

Multi-Agent Architectures

Ek strong agent + tools aksar sabse sahi jawab hota hai — multi-agent sirf tab justify hota hai jab alag hisson ko alag tools, instructions, permissions ya models chahiye. Is lesson mein common patterns (orchestrator→workers, sequential handoffs, parallel specialists, hierarchical), orchestration code, state passing, worker failure handling aur A2A vs MCP ka farak cover honge.

Ek se zyada agents kyun

• Alag tools: ek agent ke tools ko doosre ko nahi dena — permission boundary bhi hai, focus bhi.
• Alag instructions: billing persona aur tech-support persona ek prompt mein ghologe toh dono kharab.
• Alag expertise/models: chhota kaam saste model par, analysis wala bade model par — specialization ke saath cost control.
• Parallelism: N specialists ek saath — wall clock time kam, par cost aur coordination badhti hai.

Common patterns

1. Orchestrator -> workers
   planner ek (task todta hai) -> workers N (specialist agents) -> results merge

2. Sequential handoffs
   agent A (apna step poora) -> B -> C   — pipeline, har agent ek stage

3. Parallel specialists
   goal -> [agent1, agent2, agent3] ek saath -> merge / vote / compare

4. Hierarchical supervisor/worker
   supervisor -> team leads -> workers   — 2+ levels, har level apne scope mein

Pattern chunne ka rule: kaam ki stages fixed hain toh handoff, alag lens chahiye toh parallel, todna khud mushkil hai toh orchestrator, aur scope ke levels alag hain toh hierarchy. Ek hi system mein do bhi mil sakte hain — orchestrator ke workers parallel chalein.

Orchestrator banana — decompose aur delegate

import asyncio

SPECIALISTS = {
    "billing": billing_agent,
    "shipping": shipping_agent,
    "policy": policy_agent,
}

async def orchestrator(task):
    plan = planner.decompose(task)   # [{"role": "billing", "task": "..."}, ...]

    async def run_one(item):
        agent = SPECIALISTS[item["role"]]
        out = await agent.run(item["task"], ctx=shared_slice(task, item))
        return item["role"], out

    pairs = await asyncio.gather(*[run_one(p) for p in plan],
                                 return_exceptions=True)

    results, failures = {}, []
    for item, out in zip(plan, pairs):
        if isinstance(out, Exception):
            failures.append(item)          # worker fail — dekho, chhupo mat
        else:
            results[item[0]] = out[1]
    return synthesizer.merge(task, results, failures)

• Planner ka kaam: task ko role-tagged subtasks mein todna — har subtask ka scope itna chhota ki uska outcome clearly check ho.
• Dispatch: independent subtasks parallel, dependent sequential. Return_exceptions se ek worker ka crash baaki ko na roke.
• Synthesizer: final merge bhi ek model call hai — results ko combine, contradictions flag, gaps batao.
• Routing: role ko LLM se chunwa sakte ho (description dekar) ya rules se — rules pehle, LLM tab jab options kam hoon.

State passing aur output aggregation

Sabse common design mistake: poora history sab agents ko dena. Worker ko sirf apna subtask + zaroori slice do, wapas aaye sirf result — context growth multi-agent ka silent killer hai (poora budget wahi kha jaati hai).

• In: task brief, relevant ids/facts, constraints (kya nahi karna), output format expectation.
• Out: structured result (JSON/typed object) — prose merge karna mushkil hota hai, data merge aasaan.
• Aggregation: merging ke rules pehle se likho — priority kiski, conflict par kya, missing result par fallback.
• State ka single owner rakho (orchestrator) — do agents apna copy banayein toh drift pakka hai.

Worker failure, escalation aur A2A vs MCP

• Retry budget: har worker ko timeout + limited retries; uske baad doosre specialist ko reassign karo.
• Escalation: do baar fail ho toh insaan ke paas jao — context, attempted actions, aur suggested next step ke saath.
• Traps: duplicated work (ek hi subtask do ko), overlapping responsibilities (conflicting answers), coordination overhead, context growth, aur latency/cost multiples.
• One strong agent wins: jab subtasks ke beech boundary dhundhi ho, shared state zyada ho, ya communication cost decomposition se zyada — toh ek agent + tools hi rakho.

MCP  : agent (ya AI app) -> tools / resources    — capability expose karna
A2A  : agent -> agent                            — independently built
                                          agents ko ek doosre se baat karana

MCP se agent duniya se judta hai; A2A se agent doosre agent se.
Dono ek ecosystem mein saath chalte hain — replace nahi karte.

Exercise

Common mistakes

• Har cheez ko multi-agent banana: Ek strong agent + tools zyada tar tasks behtar handle karta hai. Decomposition sirf tab do jab tools, permissions, instructions ya models genuinely alag chahiye.
• Poora context sab workers ko dena: Context growth multi-agent ka silent killer hai — total cost N guna. Sirf relevant slice bhejo, wapas structured result lo.
• Worker failure ko chhupana: Ek failed worker poora pipeline chup-chaap kharab kar sakta hai. Retry budget, reassignment aur escalation — teeno pehle se define karo.
• Overlapping roles dena: Do agents ek hi subtask karein toh duplicate work aur conflicting answers pakke. Har role ki boundary ek line mein likho.

OPD:        patient -> receptionist -> specialist -> report -> doctor merge
parallel:   trauma + scans + bloodwork — ek saath -> treatment plan
escalation: case complex -> senior doctor (insaan wali line) pass on