Dev.to Security 🔐 Cybersecurity 👁 0 📖 9 min read

The lead with every tool is the slowest, weakest agent in the crew

A lead that keeps host.ssh for a quick check has quietly made every instruction that reaches it a server command. Here's the split I'd make in any runtime, five checks that catch drift, and the part nobody says out loud.

A lead that keeps host.ssh for a quick check has quietly made every instruction that reaches it a server command. Here's the split I'd make in any runtime, five checks that catch drift, and the part nobody says out loud.

Post 7 said the security boundary between a lead and its specialists lives in their tools, and moved on in one line. Post 11 was about the obligations between them — who owes a report, and how the runtime knows. This one is about the thing both posts assumed and neither argued: the lead should not hold the tools.

The claim attached to that is security-shaped, and it's true, but it isn't the reason I'd make the change first. The reason is that a tool list is a schema, and a schema is an instruction to a model. A lead with host.ssh in its list has been told, on every single turn, that running a command is a thing it could do about this. It will sometimes do it — not because it's careless, but because that's what being offered an action means. The specialists underneath it then get dispatched with the lead's improvisation already in the brief.

I write for AgentParley, so read the product parts knowing that. Everything I attribute to it is on a public docs page linked at the end, and every number below is a number I pulled from those pages rather than one I measured.

Seventeen tools the lead needs

The crews page names seventeen built-in tools for a lead's doctrine: list_agents, three dispatch/close tools, four tools for reaching other agents, report_to_caller, reply_to_human, four to-do tools and three notification tools. Take todo_write off a lead and the gate in post 11 has nothing to gate on. Take start_subagent off it and there is no crew. Those seventeen belong precisely because they are the job: governing the crew, not touching the world.

The cheapest change first: delete a tool, don't add a prompt line

The obvious way to stop a lead doing hands-on work is an instruction: "you plan, you don't execute." That's a prompt, and prompts are the thing post 7 already argued don't hold under pressure. The mechanism is blunter, and it's cheaper: the lead's tool list is the doctrine. If the lead has never been given host.ssh, no amount of a specialist's report asking for "one quick check, chief" produces a command, because the capability isn't there to be talked into.

Two surfaces make that enforceable rather than aspirational.

A crew plugin can fix each member's tool list. host.agents.create and host.agents.update take a tools: string[]. Passing it makes that agent's tool list managed by the plugin: the console shows it read-only, the account holder can no longer change it, and every update({ tools }) replaces the whole list. That last detail is a specification rather than a convenience — replace-all means the list in your source of truth is the list at runtime, with no merge to reason about. And it bites in a way you should plan for: names that match no installed tool come back in unresolvedTools and are not granted, so a typo in a tool name fails closed and shows up in the return value rather than silently working.

The agent's workspace is its own permission. host.workspace.* isn't ambient in a plugin call: it needs host:workspace:read and/or host:workspace:write plus an agent in context, and the derived permission appears on the install screen before anyone installs. So "the researcher can save its shortlist" and "the lead can read files" are separate grants, visible next to the egress hosts and the rest of the reach list — post 9's territory, applied to a person rather than to a package.

The lead keeps dispatch, reporting and mission state. It holds no SSH, filesystem, shell or web-fetch authority. read_session is a real tension: a lead who can audit shouldn't read every transcript by default, because every page lands in its context.

The part nobody says out loud: tools eat the context window

A lead with a wide tool set carries every one of those definitions in every request. That's the price every turn, before anyone has said anything. Two mechanisms address it, and they answer different questions.

Keep the list short. The simplest one. If the lead's job is dispatch, merge and answer, the list is the seventeen above and nothing else.

Keep a tool out of the list. A deferred tool stays behind search_tools and runs through call_tool; an owner can still pin it on the Access tab. That's a context lever, not a permission boundary.

Which is where the lead-with-every-tool pattern gets quietly expensive, and I want to be careful about what I claim. A specialist is offered every tool the account has installed unless the owner narrows that agent or a crew plugin manages the list — so one with a genuinely narrow job can be reading about tools it will never call. That's a statement about how the list is assembled, not a measured figure, and I have no number for what it costs you. The direction is not subtle, though: a tool definition is prompt, a prompt at the top of the list is the part of the request that gets re-sent every turn, and providers charge for input. What I won't tell you it saves is anything on a schedule. Prompt caches live minutes, not days; a lead that wakes at nine every morning and reads a long tool list is paying to write it, not to read it from cache. Per-agent models are the lever that reliably helps an overnight job — the model on the sleeping agent — not the cache.

Per-agent models, and the failure nobody plans for

The lead needs your best model for planning and merging. A specialist with a four-line brief often doesn't. AgentParley's host.models.list() returns the account's enabled models and their user-set prices, so a plugin can choose each member's modelId from real prices.

Check that it landed: PluginAgent.modelId: null means the account default, not a visible setup failure. And host.agents.create is get-or-create by key. A second call returns the existing agent untouched — wasCreated: false — ignoring tools and modelId like every other field. Use update when you deliberately own a field; repeated updates replace the user's edits.

The honest limits

Two, and the first is the one that should make a builder angry before the other reassures them.

A clean tool list is not a clean input. The lead holds none of the world's authority and all of the world's text. A specialist's report is an inbound message into the lead's conversation; a fetched page's contents land in the specialist's context and can travel back in the report. Removing tools shrinks what an injection can do through the lead to nothing worth having. It does not stop a confident wrong report being merged, and post 7's limit was already that the runtime cannot enforce that the plan was good. Narrowing the lead moves the target. It doesn't remove it.

Refusal is not the same as a refusal that shows. start_subagent won't dispatch to an agent that can't be reached; it returns forbidden rather than throwing, so the lead carries on — good behaviour, and easy to miss. A crew also spends turns: dispatch, report and merge each cost one, and a fan-out reaches a plan's limit faster than a monologue. Nothing in the runtime knows your researcher should never have SSH. That's your judgement, recorded in the tool list, not formed there. And keep the lead's mutation tools: without todo_write, post 11's durable mission has no record to resume.

Where this is the wrong shape

Two places, and they're honest ones.

A single agent with a job that needs every tool is a legitimate design. One well-scoped agent with a tight brief beats four that argue. The split is worth its coordination cost when the work divides into pieces with different reach — never because a post said so.

OpenClaw already does per-agent tool policy. Its docs carry agents.entries.*.tools.allow and .deny, with deny winning across eight filtering levels, plus agents.entries.*.model overrides. That's the same split, in a config file you can read and an MIT repository you can fork. For a person with one host and one agent, a config file is the tool list. The hosted-product case is the one AgentParley's comparison page makes; I'm not going to restate it as neutral.

Sources: OpenClaw's multi-agent sandbox and tools, sub-agent tool policy, and models, read 22 November 2026.

The checks, in the order I'd run them

  1. Read the lead's tool list out loud and name what each tool can do to the world. If the answer for any of them is a file, a host, a network or an account, it doesn't belong on the lead. If the answer is "the crew", it does.
  2. Delete one tool and watch. Take host.ssh or its equivalent off the lead and run a mission that needs it. Pass: the lead dispatches the specialist and merges the report. Fail: the lead asks a specialist to fetch what it could once have done itself and pastes the result as its own work — which is the same failure with better manners.
  3. Check modelId landed. Read the agent back after setup. null is not an error; it's the account default wearing a specialist's name.
  4. Grep your setup for .create(. Every second run is wasCreated: false. If your reconcile re-asserts, say so in your plugin description; if it doesn't, say that too — someone who edits their crew needs to know which one they installed.
  5. Count what a turn buys you. Before the crew, one monologue per answer. After, dispatch plus a report plus a merge. If a plan's turn count is your ceiling, the fan-out spends it faster, and that's a design decision, not a bug.

Five checks don't make a crew safe. They make a lead whose reach you can state in a sentence before the first mission runs, which is the part that has to be true before the merge quality matters at all.

Disclosure: I write for AgentParley, the hosted crew of specialist agents described in this post, so the product parts are not a neutral review. Every mechanism I attribute to it is on a public page linked below, read 22 November 2026, including the limits I didn't paper over.

Sources, all read 22 November 2026: Agent crews (the built-in tool list, tools on create/update and its real restriction, get-or-create by key, step and queue behaviour), Host API reference (host.agents.create / update, unresolvedTools, PluginAgent.modelId: string | null, host.models.list() with the three price fields, host.workspace and its read/write permissions, host.session.conversation.read limits and cursor, host.session.subagent.spawn), Tools (deferred, alwaysListed, the three-per-plugin cap, search_tools and call_tool, the Access tab, the 30-second call budget), Crews (who may call whom, crew-only specialists, "the lead can read a specialist's whole conversation") and Pricing (steps per run, what a step is, models per agent, agent and concurrency limits per plan). Post 11 covered the obligation ledger those tools serve; post 9 covered how a plugin's reach is derived and shown.

The comparison, including where OpenClaw and self-hosting are the better pick: agentparley.ai/openclaw-alternative. Plans and limits: agentparley.ai.

📰 Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.