Agentic AI Engineering/The Agentic Leap
Lesson 7 / 7 · 300 min
Course contents
Project

Mid-Course Project: Multi-Agent Support Desk

Integrate Projects 1–3 into one system you can demo: a supervisor that routes tickets to specialist agents, handles two-problem tickets, escalates cleanly, and streams replies into a chat interface.

Halfway through the course, put the pieces together. The triage service, the help-center assistant and the order agent become specialists under a supervisor. This is the system Module 4 will evaluate, Module 5 will partly move to a local model, and Module 6 will attack, so build it to be inspected: one shared ticket record, one trace id per conversation, logs for every handoff.

The architecture

  • Supervisor: reads the triage record and decides which specialist acts next, or whether the ticket is done. It routes; it doesn't do the work.
  • Policy specialist: the Project 2 assistant, for how-to and policy questions.
  • Orders specialist: the Project 3 agent, for anything involving an order.
  • Escalation writer: drafts a handoff note for a human (what happened, what was checked, what's needed) when the ticket is beyond policy or the agents disagree.
  • Shared ticket record: triage fields, findings from each specialist, the draft reply, approvals and a handoff counter, so no specialist re-asks for what another already found.
Why a supervisor instead of a swarm
A supervisor keeps control flow inspectable: one place decides, and every decision lands in the trace. Cap the handoffs (four is plenty here). Two-problem tickets, such as a login issue plus a stuck order, can fan out to two specialists in parallel and merge their findings into one reply.

The 10-ticket gauntlet

Run Project 1's eight tickets, plus two new ones: “My order ORD-6100 is stuck, and what's your warranty on tent poles?” (two specialists), and a follow-up in the same conversation after ticket 2: “Actually, can I get store credit instead?” (context carried across turns).

Definition of done0 / 6
Pick your track · finish either one
Steps · 0 / 6 done

  1. Define the shared ticket state

    Write a TypedDict for the ticket record: the conversation, the triage fields, a list of findings, the draft reply, approvals, a handoff count and a trace id. Every node reads it and returns updates.

    VerifyYou can describe any point in a ticket's life by printing the state; nothing important lives only inside one specialist.

  2. Wrap the specialists as nodes

    Turn Project 2's answer() and Project 3's agent into nodes that append findings to the state, and add an escalation node that writes a structured handoff note with structured outputs.

    VerifyEach node runs on its own in a test with a hand-built state and returns only the fields it owns.

  3. Add the supervisor

    The supervisor node calls a small model with structured outputs to choose the next step (policy, orders, escalate, reply or done), and a conditional edge routes on its choice. Stop at four handoffs. For two-problem tickets, fan out to both specialists in parallel with LangGraph's Send and merge their findings before drafting.

    VerifyThe two-problem gauntlet ticket visits both specialists and ends with one reply that covers both issues.

  4. Serve it with streaming

    Put the compiled graph behind an endpoint (FastAPI or similar) that streams tokens and node updates, keyed by a conversation thread_id with a persistent checkpointer. A minimal web page, or the Vercel AI SDK's UI hooks if you prefer TypeScript, is enough for the chat.

    VerifyReplies appear word by word, and the follow-up ticket remembers the earlier double-charge conversation.

  5. (Stretch) Publish the orders specialist over A2A

    Wrap the orders specialist with the a2a-sdk package and serve an Agent Card at /.well-known/agent-card.json that declares its skills and an authentication scheme. Have the supervisor call it as a remote agent.

    VerifyFetching the card returns valid JSON, and a delegated ticket moves through working to completed with an artifact.

  6. Run the gauntlet

    Run all ten tickets, act as approver at the gates, and keep each conversation's trace id. Write down the three worst failures with their trace ids.

    VerifyEvery ticket ends in a reply, a pending approval or an escalation note, and your failure list is specific enough to turn into eval cases.
· Tick off the 6 step(s) above.
Vocabulary in this lesson
TicketA bounded unit of work with a clear done state, sized so an agent can finish it in one session.AgentA model wired to tools and a loop: it reads, acts, checks the result, and goes again until the task is done or you stop it.HandoffEnding one session and starting another on the same task, carrying the state forward in writing rather than in the window.TurnYour message and all the work the agent does before it hands control back to you.Handoff artifactThe written note that carries a task across a session boundary: what's done, what's left, what was decided, where to look.ToolA named capability the harness lets the model invoke, such as reading a file, running a shell command or fetching a page.

Plain-English definitions from the AI Coding Dictionary.