@LangChain: .@mondaydotcom had one agent trying to handle 200+ tools. Context pollution everywhere. The LLM was confused, costs ris…

.mondaydotcom had one agent trying to handle 200+ tools.

Context pollution everywhere.

The LLM was confused, costs rising, and it still wasn’t working.

@omribruchim on rebuilding Sidekick with Deep Agents: https://t.co/fS6u3D1X6V https://t.co/n5nL9PxVts

TL;DR

Monday.com’s Sidekick AI agent fully pivoted from a traditional multi-agent architecture (200+ tools, context pollution) to a Deep Agent architecture. By using three-layer tool discovery, priority delegation, code-writing tools, and self-healing mechanisms, they solved the chaos and cost issues of scaling.

Background: Painful Lessons from V1 to V2

Monday.com is an AI-powered work platform. They built Sidekick, an intelligent personal assistant. V1 was based on a simple reactive loop — limited functionality but it worked. As the business expanded (CRM, Service, Marketing and other product lines, each with different tools and contexts), the team tried to cram everything into one engine for V2 — and it “blew up in our faces.”

V2 used a multi-agent architecture: each domain had its own MCP (Model Context Protocol) and tool set, but the engine ended up with over 200 tools, plus unlimited context injection, leading to:

• Context pollution: The LLM was confused by the flood of irrelevant tools.
• Costs skyrocketing: The model had to process huge amounts of irrelevant information.
• Conflicting domain requirements: One toolset couldn’t simultaneously handle CRM boards, Service docs, and other scenarios.

The team realized they needed a completely new architecture. After researching, they chose Deep Agent.

Why Deep Agent?

Deep Agent satisfied Monday.com’s core principles:

• Built for real work, not just a chat interface.
• Supports multi-step workflows and iterative planning.
• Better separation of concerns: keeps context from exploding through sub-agents and memory management.
• Filesystem-style deep context.

Philosophy: A single highly capable brain (an intelligent orchestrator), not hundreds of chaotic specialized agents talking to each other. At the same time, trust modern LLMs to handle complex tasks like planning, memory management, and sub-agent generation on their own.

Four Core Principles

1. Three-Layer Tool Discovery

Solves the “200 tools + context pollution” problem.

• Layer 1: Base toolset — Always exposed to the model. Covers 50–60% of common use cases, such as web search, image generation, URL extraction, Monday knowledge base search, etc. Small in number, stays efficient.
• Layer 2: Contextually relevant tools — Dynamically injected based on the entity the user is currently viewing (document, board, CRM record, etc.). For example, on a notes screen, only expose tools like “get board activity” or “meeting notes.” Drastically reduces background noise.
• Layer 3: Lazy tools — A catalog of all other tools, each with a short description of 20 words or fewer. The agent can call a “lazy tool” to activate the actual tool; only then is the tool brought into context. All operations happen in real time, reducing hallucinations. Next step: push all tool descriptions into a semantic database for semantic search.

Real example: When the agent understands it needs to “create a project,” it searches via lazy tools for the corresponding creation tool, activates it, and uses it. This avoids preloading all tools.

2. Priority Delegation (Sub-agents & Middleware)

Delegates tasks to specialized sub-agents, preventing the main agent from being bogged down by repetitive chores.

• Sub-agents: For repetitive tasks (e.g., presentation builder, web researcher). Two execution modes: one is direct delegation (like “ask quality”), where the main agent can continue working in parallel and come back when the sub-agent is ready. In the demo, the user asked Sidekick to introduce itself; Sidekick immediately used a sub-agent to build a presentation (leveraging a sandbox).
• Middleware pipeline: Enables seamless delegation and separation of concerns. Key middleware includes:
  • Context manager: Injects user identity, location, time zone, connected MCPs, etc.
  • Mistaken name fix middleware: Corrects tool names hallucinated by the LLM.
  • Model selection middleware: Allows users to switch the running model in real time.

Middleware keeps the execution graph clean, testable, and composable.

3. Tools Can Write Code

Avoids building a dedicated tool for every use case. Sidekick allows the agent to write Python code and run it in a secure sandbox (LangChain sandbox). One secure sandbox can replace hundreds of tools.

Real case: A user wanted to find a new office for the unit in London, requiring a drive of no more than 20 minutes from Big Ben, departing at a specific time. Sidekick used the Google API and open maps, wrote an algorithm to calculate suitable offices around the location. Without a code-writing tool, this would have been impossible.

4. Self-Healing

LLMs often hallucinate confidently, but Sidekick can self-correct in production.

• Variable advisor tool: When Sidekick doesn’t know what to do, middleware detects the failure and automatically switches to a different model.
• Resource scaling: On out-of-memory errors, automatically tries to scale resources (a simple retry strategy that solves many issues).
• Recovery success rate: After these strategies, Sidekick achieves a 94% recovery success rate. This mechanism is called “repair reflection” and covers all resources.

Enterprise workflows cannot tolerate frequent failures — self-healing is a must for production.

Real Results & Advice for Developers

Sidekick has moved from V2’s chaos to a new-generation Deep Agent architecture, successfully solving tool bloat and context pollution. In complex tasks like the London office search, the agent autonomously plans, writes code, and calls external APIs — truly “getting work done.”

Finally, Omri gives four pieces of advice:

1. Use code-writing tools: The ultimate infinite-scale tool; works great.
2. Prioritize delegation: Don’t put everything on a single agent.
3. Use tool discovery: When the tool list is long, don’t cram it all into the orchestrator — split and use middleware.
4. Use Deep Agent: It brings clear separation of concerns and robustness.

Source: YouTube – @LangChain: .@mondaydotcom had one agent trying to handle 200+ tools… (https://www.youtube.com/watch?v=c2fLLS7np3Y)