u/keep__it_simple

I’m building a LangGraph application with a supervisor and several specialized agents:

• Booking Agent
• Payments Agent
• Recommendations Agent
• Support Agent

Currently, the supervisor classifies the user’s first message and stores the selected agent in checkpointed session state. Every later message in that chat is routed to the same agent.

This creates two problems:

1. The user may change topics during the same chat—for example, ask for recommendations and then make a booking.
2. One prompt may require multiple agents:

> “Recommend the best hotel for my trip, then book the top option.”

Here, the Recommendations Agent should run first and return structured results. The Booking Agent should then receive those results and continue the workflow. It may also pause for confirmation using a LangGraph interrupt.

Constraints

• Each agent has its own state and may have pending interrupts.
• State must not leak between agents.
• Dependent tasks must execute in order.
• Independent tasks may run in parallel.
• Permissions must be checked before each operation.
• A new message must not accidentally resume an unrelated interrupt.
• Agents currently run as subgraphs in one Python service.
• Agents must return both streamed UI output and structured data.

Questions

1. What LangGraph architecture would you recommend?
2. Should this use a router, supervisor, orchestrator-worker pattern, or subagents-as-tools?
3. Should agents use separate thread_id values, separate checkpoint_ns values, or both?
4. How should a new message be distinguished from a response intended for a specific interrupt?
5. What is the best way to pass structured results between agents?
6. Should the supervisor create a task DAG per turn, or dynamically call agents using ReAct?
7. Are Agent Cards, A2A, or an agent mesh useful if all agents run inside the same service?

I’m looking for reliable production patterns from people who have built persistent multi-agent LangGraph applications with human-in-the-loop workflows.