Building Multi-Agent Deep Search Systems from Scratch

A 3-hour technical workshop on how to architect reliable deep search agents that go beyond simple retrieval.

Most search-based LLM systems stop too early.

They retrieve a few documents, summarize them, and return an answer. But real research tasks are harder than that. They require planning, iterative search, evidence collection across multiple sources, source validation, contradiction handling, temporal reasoning, and a structured way to merge findings into a final result.

In this workshop, I will break down how to design a multi-agent deep search system from scratch.

The session is based on a real deep search agent I built and shipped to production for personal information search. Using that system as a running case study, we will walk through the major components, architecture decisions, tradeoffs, and design patterns involved in building a reliable deep search workflow.

This is a system design and architecture-focused workshop. We will focus on how the system works, how the components interact, why certain design choices matter, and how to evaluate the quality of the overall workflow — without going deep into implementation code.

By the end of the session, you should have a clear blueprint for designing your own deep search system, including how to decompose research tasks, coordinate multiple agents, validate evidence, manage context and memory, and produce structured outputs that are more reliable than standard search or basic RAG pipelines.

What we will cover

1. What deep search agents are

• LLMs vs. agents vs. deep search agents
• Why deep search is different from normal search or basic RAG
• What kinds of tasks require multi-step search and synthesis
• Common limitations of single-pass search systems

2. Multi-agent architecture

We will break down the responsibilities of the major system components, including:

• planner agents
• executor agents
• validation agents
• merging agents
• improvement and feedback agents

We will also discuss when it makes sense to separate these roles into different agents and when a simpler design is enough.

3. Planning and iterative search

• breaking a complex topic into sub-questions
• deciding what to search first
• selecting the right sources and tools
• identifying information gaps
• knowing when to continue searching and when to stop
• improving results across iterations

4. Tool design for deep search

We will look at the types of tools that make deep search systems effective, including:

• search tools
• scraping tools
• OCR and image understanding tools
• video-to-text tools
• social and data enrichment tools
• think tools for deeper reasoning

We will also discuss how tool design affects reliability, context size, and downstream agent behavior.

5. Tools vs. MCPs

• what MCPs are
• when they are useful
• when normal tools are enough
• tradeoffs between direct tools and MCP-based integrations

6. Validation and source quality

• source reliability scoring
• official vs. unofficial sources
• handling conflicting claims
• using source authority, freshness, and corroboration
• identifying weak or unsupported evidence

7. Temporal reasoning

• managing publication dates, event dates, update dates, and retrieval dates
• avoiding outdated or mixed-time conclusions
• handling questions where freshness matters

8. Merging information from multiple sources

• deduplication
• conflict resolution
• preserving source provenance
• combining findings into a structured intermediate representation
• producing a clean final structured result

9. Context and memory management

• short-term working context
• long-term memory
• storing lessons from previous iterations
• deciding what should be passed between agents
• avoiding context overload in deeper research workflows

10. Evaluation

• how to evaluate deep search agents end to end
• what to measure beyond retrieval quality
• common failure modes
• architecture tradeoffs between quality, complexity, latency, and cost

Deliverables

When you join the workshop, you will get:

• 3-hour live technical workshop
  A detailed walkthrough of how to design a multi-agent deep search system from an architecture and system design perspective.
• Full workshop recording
  Access to the replay after the live session.
• Complete slide deck
  The full presentation used during the workshop, including architecture diagrams, workflows, and design patterns.
• 150-page technical workshop notes / handbook
  A written reference guide summarizing the main concepts, architecture decisions, and practical design patterns covered in the session.
• Multi-agent deep search architecture blueprint
  A clear system blueprint showing the planner, executor, validation, merger, memory, and improvement layers.
• Tool design reference
  Examples of useful tools for deep search systems, including search tools, scraping tools, OCR/image tools, video-to-text tools, enrichment tools, and think tools.

Who this workshop is for

This workshop is designed for:

• AI engineers
• ML engineers
• software engineers working on LLM applications
• data scientists building agent systems
• technical founders and builders exploring deep research workflows

It is especially useful for people who already understand the basics of LLMs, RAG, and tools, and want to move toward more reliable agentic research systems.

Workshop details

• Format: Live online workshop
• Duration: 3 hours
• Focus: architecture and system design
• Price: $50