OpenClaw Tool Search in June 2026: Large Catalogs, MCP Scale, and the Codex Boundary

As of June 9, 2026, OpenClaw has a new answer to one of the ecosystem’s most practical scaling problems: what happens when an agent can see too many tools at once.

The official docs now describe Tool Search as an experimental OpenClaw runtime feature that lets the model search a compact catalog first, then load only the tool schema it actually needs. That matters because the current OpenClaw plugin inventory now lists 90 plugins in the core npm package and 35 official external packages. On top of that, OpenClaw can also surface configured MCP tools and client-provided tools inside the same run.

If you need the broader ecosystem context first, start with our June 2026 ecosystem update and our guide to OpenClaw search architecture. This article focuses on the narrower operator question: when should you enable OpenClaw Tool Search, when should you leave direct tools alone, and when does Codex already solve the problem for you?

1. Why Tool Search exists now

The official Tool Search page is explicit about the motivation: large catalogs are useful but expensive. If you expose every eligible tool schema to the model before the first token, planning gets heavier, request payloads grow, and accidental tool selection becomes more likely.

OpenClaw’s current docs now describe a different shape for these larger environments. Instead of giving the model every schema up front, Tool Search lets the model search compact descriptors, describe one result when it needs the exact schema, and then call that tool through the normal OpenClaw path.

This is not a theoretical edge case anymore. OpenClaw’s generated plugin inventory currently shows 125 official plugin entries across core and external packages, and that still excludes whatever configured MCP servers or client tools your environment adds at runtime. In other words, Tool Search is arriving at exactly the moment when many OpenClaw stacks are becoming large enough to need catalog compaction on purpose.

2. How the current Tool Search flow actually works

The official runtime description is concrete. At planning time, OpenClaw builds the effective catalog for the run by resolving policy first, then listing eligible OpenClaw tools, plugin tools, MCP tools, and client-provided tools. After that, it indexes compact descriptors and exposes either one code-style bridge or a smaller structured fallback surface to the model.

The important architectural point is that the model is not getting direct access to plugin implementations, MCP client objects, or host secrets. The docs say the model searches the catalog, asks for one selected schema, and then the real tool call crosses back into the Gateway through openclaw.tools.call(...), where the normal policy, approvals, hooks, logging, and result handling still apply.

That is a better operating model than dumping a huge tool wall into prompt context and hoping the model picks cleanly. It preserves the same enforcement surface while reducing how much the model has to see before it starts reasoning.

3. The two modes matter, and both are still experimental

OpenALL CLEAR DIGITALly documents two Tool Search modes.

code mode exposes a single tool_search_code tool and uses a short JavaScript bridge.
tools mode exposes three structured tools instead: tool_search, tool_describe, and tool_call.

Both modes use the same catalog and the same execution path. The difference is what the model sees. The docs also say that if the isolated code-mode runtime cannot launch, OpenClaw falls back from code to tools before catalog compaction.

The current recommendation is not “turn this on everywhere.” OpenClaw is clear that both modes are experimental, that direct tool exposure is still the right default for small catalogs, and that Tool Search is most useful when one run can see many tools, especially from MCP servers or client-provided app tools.

4. Codex is the boundary many operators will miss

This is the section most OpenClaw teams need to read carefully. The official Tool Search doc says Codex harness runs do not receive these experimental OpenClaw Tool Search controls. The separate Codex harness reference then explains why: OpenClaw already passes most remaining OpenClaw integration capabilities to Codex as searchable dynamic tools, and Codex owns the stable native code mode, native tool search, deferred dynamic tools, and nested tool calls.

That means there are really two different stories now:

Embedded OpenClaw runs: Tool Search can be useful when your OpenClaw runtime itself is surfacing a large catalog.
Codex app-server runs: Codex already has its own stable tool-search and deferred-loading surfaces, so OpenClaw tells operators to prefer those instead of reaching for tools.toolSearch.

If your team is already standardizing on the newer Codex path, our June 2026 OpenAI and Codex routing guide is the more relevant companion. If you are still running mixed OpenClaw-native and Codex-mediated stacks, this distinction should become part of your deployment checklist now.

5. Why MCP-heavy deployments are the real target

The MCP docs make the intended use case easier to see. Embedded OpenClaw can expose configured MCP tools in normal coding and messaging profiles, filter them per server, generate resource and prompt utility tools, refresh catalogs when a server’s tool list changes, and briefly pause broken servers so one failure does not consume the whole turn.

That is exactly the sort of environment where catalog size can stop being a theoretical concern. Once you add plugin tools, MCP servers, and client tools into one agent lane, the question is no longer “does the model have access?” but “how much of that access should be serialized into the initial context?” Tool Search is OpenClaw’s current experimental answer to that problem.

It also fits the broader direction of the platform. We already saw OpenClaw move toward a leaner core and a more package-managed ecosystem in our plugin security coverage. Tool Search applies the same maturity pattern to runtime tool discovery: smaller default exposure, more deliberate expansion, and clearer policy boundaries.

6. The safety model is stronger than the name suggests

“Tool Search” can sound like a convenience feature, but the current docs frame it as a guarded runtime boundary. In code mode, the bridge runs in a short-lived isolated Node subprocess with Node permission mode enabled, an empty environment, and no filesystem, network, child-process, or worker grants. OpenClaw also enforces a wall-clock timeout and kills the subprocess on timeout.

The final tool execution still returns to the Gateway, which means the existing control layers remain in force:

tool allow and deny policy,
per-agent and per-sandbox restrictions,
approval hooks,
plugin before_tool_call hooks,
session identity, logging, and telemetry.

The failure behavior is also conservative. The docs say Tool Search should fail closed: tools outside policy should not be returned, selected tools can still fail if they become unavailable, approval blocks still block execution, and operators can fall back to mode: "tools" or disable Tool Search entirely if the isolated code bridge is not appropriate for the deployment.

7. The best June 2026 rollout pattern

If you are deciding what to do today, the most defensible current pattern is straightforward:

Stay with direct tools when the catalog is small and stable.
Use Tool Search for embedded OpenClaw runs when MCP servers, plugins, or client tools make the catalog genuinely large.
Prefer Codex-native searchable dynamic tools for Codex harness runs instead of trying to force OpenClaw Tool Search into that lane.
Use mode: "tools" when your provider should not receive code.
Watch the telemetry so you can compare prompt size, search/describe behavior, and final tool-call patterns against direct exposure.

If you also need the surrounding workflow stack, pair this with our browser guide, our update playbook, and our search provider comparison. Those are the adjacent decisions most teams end up making at the same time.

The monetization angle for ALL CLEAR DIGITAL readers

The commercial opportunity here is not “enable one config flag.” It is helping teams design a tool-catalog operating model that stays fast, reviewable, and safe as more plugins, MCP servers, and client tools pile into the same workspace.

If you need help deciding where direct tools should stop, where Tool Search should start, and where Codex already provides the better surface, ALL CLEAR DIGITAL can help. We work with operators on plugin-stack audits, MCP catalog design, Codex/OpenClaw boundary decisions, and rollout policies that keep agent capability from turning into prompt bloat or approval chaos. See our support options if you want that work packaged into a real deployment plan.