@@ -466,6 +466,12 @@ Tools appear in the registry as `server__tool` (`Linear__create_issue`) with sou
 In the bot editor, MCP tools are grouped by server: grant a whole server with one checkbox, or expand
 it and pick individual tools. `approval_tools` and `TOOL_OUTPUT_CAP` apply to them like any other tool.
 
+MCP tools load on demand (`defer_mcp_tools`, on by default). A server can bring dozens of tools with
+long schemas (Linear's 76 come to ~30k tokens), and every model call re-sends every tool definition it
+is offered. So a bot's system prompt lists its MCP tools by name only, and the bot calls `load_tools`
+(by exact name, or by keyword `query`) to add the ones a task needs; they stay loaded for the rest of the
+run. A call to a tool that was never loaded does not run, but loads it so the retry has its schema.
+
 Whatever you authorize is shared by every bot given that tool: a bot calling Linear acts as you.
 Use `approval_tools` for anything that writes.
 
@@ -634,6 +640,7 @@ name, if set, is the default the page shows and the value a reset returns to.
 | Embeddings | `embedding_model`, `embedding_dims` | `provider:model` for semantic memory search (`openrouter:openai/text-embedding-3-small`/1536 using the OpenRouter key, `openai:text-embedding-3-small`/1536, `ollama:nomic-embed-text`/768). Empty turns semantic search off. Applies immediately: the memory store is reopened. |
 | Run limits | `max_model_calls_per_run` (60), `max_repeated_tool_failures` (3), `max_bot_hops` (20) | Model turns per run before the agent stops with a notice (a bot can lower it in `model_settings.max_model_calls`; the seeded Chief of Staff uses 6); how many times one tool call may fail with the same arguments and error before the run stops with that error as the reply (0 = off); bot-to-bot mention chain limit per thread. `model_settings` also accepts `reasoning_effort` (set from the Effort select for models that declare levels), `temperature`, `max_tokens`. |
 | Context | `tool_output_cap` (8000), `shell_output_cap` (4000) | Longest single tool result the model sees; shorter cap for `run_shell` so dumping files through the shell loses to `read_file` ranges. |
+| Context | `defer_mcp_tools` (true) | Leave MCP tool definitions out of model calls until the bot loads them with `load_tools`; the system prompt lists their names. |
 | Context | `context_trigger_tokens` (40000), `context_clear_at_least` (10000) | Once a run's messages pass the trigger, tool results from turns before the last two, and their call arguments, become a placeholder, oldest first; each clearing reclaims at least the second value so clearings are rare and the prompt cache stays warm. What the last two model turns fetched is never cleared. |
 | Context | `summary_trigger_tokens` (60000), `summary_keep_messages` (24) | Older history folds into one structured summary by the bot's own model once the run's messages pass the trigger. Measured on the messages alone: the system prompt and tool schemas are not counted. |
 | Context | `history_token_budget` (24000), `history_max_messages` (80) | Thread history included in a run's prompt. |
 
@@ -74,6 +74,7 @@ class Settings(BaseSettings):
     prompt_caching: bool = True          # add Anthropic cache breakpoints to every model call
     include_llm_call_details: bool = Field(default=True, validation_alias="OPENBOT_INCLUDE_LLM_CALL_DETAILS")  # expose per-call token details in activity events; launchers opt out explicitly
     direct_anthropic: bool = True        # send OpenRouter `anthropic/...` models to Anthropic directly when a key exists
+    defer_mcp_tools: bool = True         # send MCP tool definitions only after a bot loads them (runtime/tool_loading.py)
     tool_output_cap: int = 8000          # max chars of any single tool result the model sees (head + tail kept)
     shell_output_cap: int = 4000         # tighter cap for run_shell, so dumping a file through cat/git show loses to read_file ranges
     # Context triggers: None means "derive from the model's context window" (OpenCode's compaction
 
@@ -78,6 +78,8 @@ class Tunable:
         "Longest single tool result the model sees; longer results are shortened and say so.", 500),
     "shell_output_cap": Tunable("Context", "Shell output cap (chars)",
         "Tighter cap for run_shell, so dumping a file through the shell loses to read_file with a line range.", 500),
+    "defer_mcp_tools": Tunable("Context", "Load MCP tools on demand",
+        "Leave MCP tool definitions out of each model call until the bot loads them with load_tools; the system prompt lists their names. Saves the definitions' tokens (tens of thousands for large servers) on every call."),
     "context_trigger_tokens": Tunable("Context", "Clear old tool results above (tokens)",
         "Once a run's messages pass this, tool results from turns before the last two, and their call arguments, are replaced by a placeholder. The system prompt and tool schemas are not counted. Leave empty to derive it from the model's context window (falls back to 40000 when unknown).", 1000),
     "context_clear_at_least": Tunable("Context", "Reclaim at least (tokens)",
 
@@ -52,8 +52,11 @@
 OUTPUT_TOKEN_MAX = 32_000
 # Ceiling on a derived summary trigger. Every call re-sends the whole context, so a 1M window
 # summarizing at ~700k made each call slow and costly; past this a summary is cheaper than
-# carrying the history. An explicit `summary_trigger_tokens` override may still go higher.
-MAX_DERIVED_SUMMARY_TRIGGER = 200_000
+# carrying the history. At 200k (2026-10-17) a 1M-window bot cleared nothing until ~133k of
+# messages and its calls passed 170k tokens; 100k keeps clearing near 67k, above the ~47k that
+# made bots re-read what had just been cleared. An explicit `summary_trigger_tokens` override
+# may still go higher.
+MAX_DERIVED_SUMMARY_TRIGGER = 100_000
 
 # Built-in fallbacks (the old fixed defaults), used when the window is unknown or a trigger
 # setting is None without a window to derive from.
 
@@ -6,6 +6,7 @@
 from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
 
 from openbot.db.models import Actor, Message
+from openbot.runtime.tool_loading import deferred_tools_section
 from openbot.tools.builtin.scratchpad import scratchpad_section
 from openbot.tools.builtin.todo import todo_list_section
 
@@ -166,6 +167,7 @@ def build_system_prompt(
     scoped: bool = False,
     todos: list[dict] | None = None,
     scratchpad: str | None = None,
+    deferred_tools: list[str] | None = None,
 ) -> str:
     stable, dynamic = build_system_prompt_parts(
         bot=bot,
@@ -179,6 +181,7 @@ def build_system_prompt(
         scoped=scoped,
         todos=todos,
         scratchpad=scratchpad,
+        deferred_tools=deferred_tools,
     )
     return stable + dynamic
 
@@ -196,6 +199,7 @@ def build_system_prompt_parts(
     scoped: bool = False,
     todos: list[dict] | None = None,
     scratchpad: str | None = None,
+    deferred_tools: list[str] | None = None,
 ) -> tuple[str, str]:
     roster = (
         "\n".join(
@@ -248,6 +252,8 @@ def build_system_prompt_parts(
     }
     stable = _STABLE_SYSTEM_PROMPT_TEMPLATE.substitute(**values)
     dynamic = _DYNAMIC_SYSTEM_PROMPT_TEMPLATE.substitute(**values)
+    if deferred_tools:
+        dynamic += f"\n\n{deferred_tools_section(deferred_tools)}"
     if scratchpad is not None:
         dynamic += f"\n\n{scratchpad_section(scratchpad)}"
     if todos:
 
@@ -55,6 +55,7 @@
 from openbot.runtime.providers import builtin_tools, effective_bot_profile
 from openbot.runtime.retry import ModelRetryMiddleware
 from openbot.runtime.tool_failures import ToolFailureMiddleware
+from openbot.runtime.tool_loading import LOAD_TOOLS, DeferredToolsMiddleware
 from openbot.tools.builtin.core import CORE_TOOLS
 from openbot.tools.builtin.scheduling import SCHEDULING_TOOLS
 from openbot.tools.builtin.scratchpad import load_scratchpad
@@ -674,6 +675,7 @@ async def _prepare(self, bot: Actor, thread: Thread, run: Run) -> tuple[str, dic
             else []
         )
         workspace_root = thread_workspace_root(st.workspace_root, thread.working_directory)
+        deferred = set(self.deferred_tool_names(bot))
         stable_prompt, dynamic_prompt = build_system_prompt_parts(
             bot=bot,
             all_bots=list(all_actors),
@@ -683,11 +685,16 @@ async def _prepare(self, bot: Actor, thread: Thread, run: Run) -> tuple[str, dic
             older_count=older,
             # Only tools that will actually be bound: an MCP server that is down
             # must not be advertised, or the model calls a tool it does not have.
-            tool_names=[n for n in bot.bot.tool_names if self.s.registry.has(n)],
+            # Tools loaded on demand are listed in their own section instead (runtime/tool_loading.py).
+            tool_names=[
+                *(n for n in bot.bot.tool_names if self.s.registry.has(n) and n not in deferred),
+                *([LOAD_TOOLS] if deferred else []),
+            ],
             default_bot_handle=default_bot_handle,
             scoped=scoped,
             todos=todos,
             scratchpad=scratchpad,
+            deferred_tools=[n for n in bot.bot.tool_names if n in deferred],
         )
         prompt = SystemMessage(
             content=[
@@ -783,8 +790,23 @@ def build_middleware(self, bot: Actor, model, triggers: tuple[int, int] | None =
                     description_prefix="Tool execution requires approval",
                 )
             )
+        deferred_names = self.deferred_tool_names(bot)
+        if deferred_names:
+            middleware.append(DeferredToolsMiddleware(self.s.registry.resolve(deferred_names)))
         return middleware
 
+    def deferred_tool_names(self, bot: Actor) -> list[str]:
+        """The bot's MCP tools, which are bound but sent to the model only once it loads them
+        (runtime/tool_loading.py). None when deferral is off, or for a CLI-agent bot, which never
+        goes through create_agent."""
+        if (
+            self.s.registry is None
+            or not getattr(self.s.settings, "defer_mcp_tools", True)
+            or adapter_for(bot.bot.provider) is not None
+        ):
+            return []
+        return [n for n in bot.bot.tool_names if (self.s.registry.source(n) or "").startswith("mcp:")]
+
     def _build_agent(self, bot: Actor, system_prompt: str, triggers: tuple[int, int] | None = None):
         p = bot.bot
         tools = [