tools changedmanaged-agents/tools
Nearest release: v2.1.237, published an hour after this site recorded the change. Shown because the two are within 24 hours of each other. Nothing here says the release caused the edit.
Recorded here
Lines+439added
Lines−9removed
From line
14
where the diff opens
First seen
14 Aug 2026
this site's first read of the page
Recorded edits24to this page, all time
### Restrict web search and web fetch domains #### Domain list rules #### When settings are validated #### Multiagent sessions, outcomes, and mid-session updates #### Differences from the Messages API tools
The whole hunk
from line 14, old and new numbered
/
The two sides of this change are more than 400 edits apart, too far apart to line up, so this is the differ's own diff of it and the words inside a line are not marked.
from line 14
1414
1515## Available tools
1616
17The agent toolset includes the following tools. All are enabled by default when you include the toolset in your agent configuration. Use the values in the Name column to reference tools in the `configs` array.
17The agent toolset includes the following tools. All are enabled by default when you include the toolset in your agent configuration. Each entry in the `configs` array is identified by its `name`, using the values in the Name column, and accepts an optional `type` field with the same value. The `web_search` and `web_fetch` entries accept additional settings; see [Restrict web search and web fetch domains](https://platform.claude.com/docs/en/managed-agents/tools#restrict-web-search-and-web-fetch-domains).
1818
1919| Tool | Name | Description |
2020| ---------- | ------------ | ---------------------------------------------- |
from line 32
3232## Configuring the toolset
3333
3434Enable the full toolset with `agent_toolset_20260401` when creating an agent. Use the `configs` array to disable specific tools or override their settings. Each config entry can also set a `permission_policy` that controls whether the tool's calls are auto-approved or require confirmation. See [Permission policies](https://platform.claude.com/docs/en/managed-agents/permission-policies) for the available policy types.
35
36Config entries for `web_search` and `web_fetch` also accept domain filters and other web settings; see [Restrict web search and web fetch domains](https://platform.claude.com/docs/en/managed-agents/tools#restrict-web-search-and-web-fetch-domains).
3537
3638<CodeGroup defaultLanguage="CLI">
3739 ```bash cURL
from line 113
111113 Type = "agent_toolset_20260401",
112114 Configs =
113115 [
114 new() { Name = "web_fetch", Enabled = false },
116 new BetaManagedAgentsWebFetchToolConfigParams { Enabled = false },
115117 ],
116118 },
117119 ],
from line 129
127129 Tools: []anthropic.BetaAgentNewParamsToolUnion{{
128130 OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
129131 Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
130 Configs: []anthropic.BetaManagedAgentsAgentToolConfigParams{{
131 Name: anthropic.BetaManagedAgentsAgentToolConfigParamsNameWebFetch,
132 Enabled: anthropic.Bool(false),
132 Configs: []anthropic.BetaManagedAgentsAgentToolConfigUnionParamsUnion{{
133 OfBetaManagedAgentsWebFetchToolConfigs: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
134 Enabled: anthropic.Bool(false),
135 },
133136 }},
134137 },
135138 }},
from line 151
148151 .model(BetaManagedAgentsModel.CLAUDE_OPUS_5)
149152 .addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
150153 .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
151 .addConfig(BetaManagedAgentsAgentToolConfigParams.builder()
152 .name(BetaManagedAgentsAgentToolConfigParams.Name.WEB_FETCH)
154 .addConfig(BetaManagedAgentsWebFetchToolConfigParams.builder()
153155 .enabled(false)
154156 .build())
155157 .build())
from line 159
157159 ```
158160
159161 ```php PHP
160 use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolConfigParams;
161162 use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
163 use Anthropic\Beta\Agents\BetaManagedAgentsWebFetchToolConfigParams;
162164
163165 $agent = $client->beta->agents->create(
164166 name: 'Coding Assistant',
from line 169
167169 BetaManagedAgentsAgentToolset20260401Params::with(
168170 type: 'agent_toolset_20260401',
169171 configs: [
170 BetaManagedAgentsAgentToolConfigParams::with(name: 'web_fetch', enabled: false),
172 BetaManagedAgentsWebFetchToolConfigParams::with(enabled: false),
171173 ],
172174 ),
173175 ],
from line 221
219221 ]
220222}
221223```
224
225### Restrict web search and web fetch domains
226
227To control which sites the agent's web tools can reach, set `allowed_domains` (the tool can reach only these hosts) or `blocked_domains` (the tool can never reach these hosts) on the `web_search` and `web_fetch` entries of the toolset's `configs` array. Each tool carries its own list, so `web_search` and `web_fetch` can have different restrictions. A listed domain covers that host and all of its subdomains. At runtime, a `web_fetch` call for a URL that its lists do not permit returns an error result to the agent (`is_error: true` on the `agent.tool_result` event, with content that names the error code `url_not_allowed`), and `web_search` omits results that its lists do not permit.
228
229The following toolset limits `web_search` to two sites and localizes its results, and blocks one host for `web_fetch` while capping how much fetched content enters the context:
230
231```json
232{
233 "type": "agent_toolset_20260401",
234 "configs": [
235 {
236 "type": "web_search",
237 "name": "web_search",
238 "allowed_domains": ["docs.example.com", "arxiv.org"],
239 "user_location": {
240 "type": "approximate",
241 "country": "US",
242 "timezone": "America/Los_Angeles"
243 }
244 },
245 {
246 "type": "web_fetch",
247 "name": "web_fetch",
248 "blocked_domains": ["ads.example.com"],
249 "max_content_tokens": 50000
250 }
251 ]
252}
253```
254
255<Note>
256 In the Python, TypeScript, Go, Java, C#, Ruby, and PHP SDKs, each `configs` entry is typed per tool: a union with one member per built-in tool, discriminated by `type`. `type` is optional when you construct an entry (the server infers it from `name`) and always present on responses. This typing does not change the JSON that an entry serializes to, so a request whose entries set only `name`, `enabled`, and `permission_policy` is valid with or without `type`. In SDKs where you construct entries from typed values rather than plain dictionaries or hashes (Go, Java, C#, and PHP), the element type of `configs` is the union itself: build each entry from its per-tool member type.
257</Note>
258
259The following request creates an agent with this toolset and prints the `configs` array from the response:
260
261<CodeGroup defaultLanguage="CLI">
262 ```bash cURL
263 agent=$(curl -fsSL https://api.anthropic.com/v1/agents \
264 -H "x-api-key: $ANTHROPIC_API_KEY" \
265 -H "anthropic-version: 2023-06-01" \
266 -H "anthropic-beta: managed-agents-2026-04-01" \
267 -H "content-type: application/json" \
268 -d @- <<'EOF'
269 {
270 "name": "Research Agent",
271 "model": "claude-opus-5",
272 "tools": [
273 {
274 "type": "agent_toolset_20260401",
275 "configs": [
276 {
277 "type": "web_search",
278 "name": "web_search",
279 "allowed_domains": ["docs.example.com", "arxiv.org"],
280 "user_location": {
281 "type": "approximate",
282 "country": "US",
283 "timezone": "America/Los_Angeles"
284 }
285 },
286 {
287 "type": "web_fetch",
288 "name": "web_fetch",
289 "blocked_domains": ["ads.example.com"],
290 "max_content_tokens": 50000
291 }
292 ]
293 }
294 ]
295 }
296 EOF
297 )
298 jq '.tools[0].configs' <<< "$agent"
299 ```
300
301 ```bash CLI
302 ant beta:agents create --transform tools.0.configs <<'YAML'
303 name: Research Agent
304 model: claude-opus-5
305 tools:
306 - type: agent_toolset_20260401
307 configs:
308 - type: web_search
309 name: web_search
310 allowed_domains: [docs.example.com, arxiv.org]
311 user_location:
312 type: approximate
313 country: US
314 timezone: America/Los_Angeles
315 - type: web_fetch
316 name: web_fetch
317 blocked_domains: [ads.example.com]
318 max_content_tokens: 50000
319 YAML
320 ```
321
322 ```python Python
323 client = Anthropic()
324
325 agent = client.beta.agents.create(
326 name="Research Agent",
327 model="claude-opus-5",
328 tools=[
329 {
330 "type": "agent_toolset_20260401",
331 "configs": [
332 {
333 "name": "web_search",
334 "allowed_domains": ["docs.example.com", "arxiv.org"],
335 "user_location": {
336 "type": "approximate",
337 "country": "US",
338 "timezone": "America/Los_Angeles",
339 },
340 },
341 {
342 "name": "web_fetch",
343 "blocked_domains": ["ads.example.com"],
344 "max_content_tokens": 50_000,
345 },
346 ],
347 }
348 ],
349 )
350
351 for tool in agent.tools:
352 if tool.type == "agent_toolset_20260401":
353 print(json.dumps([config.to_dict() for config in tool.configs], indent=2))
354 ```
355
356 ```typescript TypeScript
357 const client = new Anthropic();
358
359 const agent = await client.beta.agents.create({
360 name: "Research Agent",
361 model: "claude-opus-5",
362 tools: [
363 {
364 type: "agent_toolset_20260401",
365 configs: [
366 {
367 name: "web_search",
368 allowed_domains: ["docs.example.com", "arxiv.org"],
369 user_location: {
370 type: "approximate",
371 country: "US",
372 timezone: "America/Los_Angeles"
373 }
374 },
375 {
376 name: "web_fetch",
377 blocked_domains: ["ads.example.com"],
378 max_content_tokens: 50_000
379 }
380 ]
381 }
382 ]
383 });
384
385 for (const tool of agent.tools) {
386 if (tool.type === "agent_toolset_20260401") {
387 console.log(JSON.stringify(tool.configs, null, 2));
388 }
389 }
390 ```
391
392 ```csharp C#
393 using Anthropic.Models.Beta.Agents;
394
395 AnthropicClient client = new();
396
397 var agent = await client.Beta.Agents.Create(new()
398 {
399 Name = "Research Agent",
400 Model = BetaManagedAgentsModel.ClaudeOpus5,
401 Tools =
402 [
403 new BetaManagedAgentsAgentToolset20260401Params
404 {
405 Type = BetaManagedAgentsAgentToolset20260401ParamsType.AgentToolset20260401,
406 Configs =
407 [
408 new BetaManagedAgentsWebSearchToolConfigParams
409 {
410 AllowedDomains = ["docs.example.com", "arxiv.org"],
411 UserLocation = new()
412 {
413 Country = "US",
414 Timezone = "America/Los_Angeles",
415 },
416 },
417 new BetaManagedAgentsWebFetchToolConfigParams
418 {
419 BlockedDomains = ["ads.example.com"],
420 MaxContentTokens = 50_000,
421 },
422 ],
423 },
424 ],
425 });
426
427 JsonSerializerOptions jsonOptions = new() { WriteIndented = true };
428 foreach (var tool in agent.Tools)
429 {
430 if (tool.TryPickBetaManagedAgentsAgentToolset20260401(out var toolset))
431 {
432 Console.WriteLine(JsonSerializer.Serialize(toolset.Configs, jsonOptions));
433 }
434 }
435 ```
436
437 ```go Go
438 client := anthropic.NewClient()
439 ctx := context.Background()
440
441 agent, err := client.Beta.Agents.New(ctx, anthropic.BetaAgentNewParams{
442 Name: "Research Agent",
443 Model: anthropic.BetaManagedAgentsModelConfigParams{
444 ID: anthropic.BetaManagedAgentsModelClaudeOpus5,
445 },
446 Tools: []anthropic.BetaAgentNewParamsToolUnion{{
447 OfAgentToolset20260401: &anthropic.BetaManagedAgentsAgentToolset20260401Params{
448 Type: anthropic.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
449 Configs: []anthropic.BetaManagedAgentsAgentToolConfigUnionParamsUnion{
450 {OfBetaManagedAgentsWebSearchToolConfigs: &anthropic.BetaManagedAgentsWebSearchToolConfigParams{
451 AllowedDomains: []string{"docs.example.com", "arxiv.org"},
452 UserLocation: anthropic.BetaManagedAgentsUserLocationParam{
453 Country: anthropic.String("US"),
454 Timezone: anthropic.String("America/Los_Angeles"),
455 },
456 }},
457 {OfBetaManagedAgentsWebFetchToolConfigs: &anthropic.BetaManagedAgentsWebFetchToolConfigParams{
458 BlockedDomains: []string{"ads.example.com"},
459 MaxContentTokens: anthropic.Int(50000),
460 }},
461 },
462 },
463 }},
464 })
465 if err != nil {
466 panic(err)
467 }
468
469 for _, tool := range agent.Tools {
470 switch toolset := tool.AsAny().(type) {
471 case anthropic.BetaManagedAgentsAgentToolset20260401:
472 configs := make([]json.RawMessage, len(toolset.Configs))
473 for i, config := range toolset.Configs {
474 configs[i] = json.RawMessage(config.RawJSON())
475 }
476 output, err := json.MarshalIndent(configs, "", " ")
477 if err != nil {
478 panic(err)
479 }
480 fmt.Println(string(output))
481 }
482 }
483 ```
484
485 ```java Java
486 import com.anthropic.models.beta.agents.AgentCreateParams;
487 import com.anthropic.models.beta.agents.BetaManagedAgentsAgentToolset20260401Params;
488 import com.anthropic.models.beta.agents.BetaManagedAgentsModel;
489 import com.anthropic.models.beta.agents.BetaManagedAgentsUserLocation;
490 import com.anthropic.models.beta.agents.BetaManagedAgentsWebFetchToolConfigParams;
491 import com.anthropic.models.beta.agents.BetaManagedAgentsWebSearchToolConfigParams;
492
493 void main() {
494 var client = AnthropicOkHttpClient.fromEnv();
495
496 var agent = client.beta().agents().create(AgentCreateParams.builder()
497 .name("Research Agent")
498 .model(BetaManagedAgentsModel.CLAUDE_OPUS_5)
499 .addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
500 .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
501 .addConfig(BetaManagedAgentsWebSearchToolConfigParams.builder()
502 .allowedDomains(List.of("docs.example.com", "arxiv.org"))
503 .userLocation(BetaManagedAgentsUserLocation.builder()
504 .country("US")
505 .timezone("America/Los_Angeles")
506 .build())
507 .build())
508 .addConfig(BetaManagedAgentsWebFetchToolConfigParams.builder()
509 .blockedDomains(List.of("ads.example.com"))
510 .maxContentTokens(50_000)
511 .build())
512 .build())
513 .build());
514
515 for (var tool : agent.tools()) {
516 if (tool.isAgentToolset20260401()) {
517 var configs = tool.asAgentToolset20260401().configs();
518 IO.println(ObjectMappers.jsonMapper().valueToTree(configs));
519 }
520 }
521 }
522 ```
523
524 ```php PHP
525 use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401;
526 use Anthropic\Beta\Agents\BetaManagedAgentsAgentToolset20260401Params;
527 use Anthropic\Beta\Agents\BetaManagedAgentsUserLocation;
528 use Anthropic\Beta\Agents\BetaManagedAgentsWebFetchToolConfigParams;
529 use Anthropic\Beta\Agents\BetaManagedAgentsWebSearchToolConfigParams;
530 // ...
531
532 $client = new Client();
533
534 $agent = $client->beta->agents->create(
535 name: 'Research Agent',
536 model: 'claude-opus-5',
537 tools: [
538 BetaManagedAgentsAgentToolset20260401Params::with(
539 type: 'agent_toolset_20260401',
540 configs: [
541 BetaManagedAgentsWebSearchToolConfigParams::with(
542 allowedDomains: ['docs.example.com', 'arxiv.org'],
543 userLocation: BetaManagedAgentsUserLocation::with(
544 country: 'US',
545 timezone: 'America/Los_Angeles',
546 ),
547 ),
548 BetaManagedAgentsWebFetchToolConfigParams::with(
549 blockedDomains: ['ads.example.com'],
550 maxContentTokens: 50_000,
551 ),
552 ],
553 ),
554 ],
555 );
556
557 foreach ($agent->tools as $tool) {
558 if ($tool instanceof BetaManagedAgentsAgentToolset20260401) {
559 echo json_encode($tool->configs, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES), PHP_EOL;
560 }
561 }
562 ```
563
564 ```ruby Ruby
565 client = Anthropic::Client.new
566
567 agent = client.beta.agents.create(
568 name: "Research Agent",
569 model: "claude-opus-5",
570 tools: [
571 {
572 type: :agent_toolset_20260401,
573 configs: [
574 {
575 name: :web_search,
576 allowed_domains: ["docs.example.com", "arxiv.org"],
577 user_location: {type: :approximate, country: "US", timezone: "America/Los_Angeles"}
578 },
579 {
580 name: :web_fetch,
581 blocked_domains: ["ads.example.com"],
582 max_content_tokens: 50_000
583 }
584 ]
585 }
586 ]
587 )
588
589 case agent.tools.first
590 in Anthropic::Models::Beta::BetaManagedAgentsAgentToolset20260401 => toolset
591 puts JSON.pretty_generate(toolset.configs.map(&:to_h))
592 end
593 ```
594</CodeGroup>
595
596In the Claude Console, set allowed or blocked domains from the `web_search` and `web_fetch` rows of the **Built-in tools** card on the agent form; set `max_content_tokens` and `user_location` in the **Raw** view of the agent's configuration.
597
598In addition to `enabled` and `permission_policy`, the web tool entries accept the following settings:
599
600| Setting | Applies to | Description |
601| -------------------- | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
602| `allowed_domains` | `web_search`, `web_fetch` | The only hosts the tool can reach. Cannot be combined with `blocked_domains` on the same entry. |
603| `blocked_domains` | `web_search`, `web_fetch` | Hosts the tool cannot reach. |
604| `max_content_tokens` | `web_fetch` | Caps the amount of fetched page content included in the context. Must be a positive integer. See [content limits](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool#content-limits). |
605| `user_location` | `web_search` | Localizes search results. An object with the same fields as the Messages API [`user_location`](https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool#localization) parameter. |
606
607<Note>
608 An environment's [`networking`](https://platform.claude.com/docs/en/managed-agents/environments#networking) settings control the sandbox's own outbound traffic. They do not affect `web_search` or `web_fetch`, which run on Anthropic's servers whether the environment is a cloud or self-hosted sandbox. The per-tool `allowed_domains` and `blocked_domains` lists are the way to restrict what these tools can reach.
609</Note>
610
611<Note>
612 Organization-level web search and web fetch settings in the Claude Console apply to the Messages API and do not apply to Managed Agents sessions. To restrict an agent's web tools, configure `allowed_domains` or `blocked_domains` on its toolset instead.
613</Note>
614
615#### Domain list rules
616
617* Set either `allowed_domains` or `blocked_domains` on an entry, not both. An entry that sets both is rejected.
618* Each list holds 1 to 64 domains, each 1 to 255 characters. An empty list is rejected: to apply no restriction, omit the field or send `null`.
619* Each domain is a registrable domain name, or a subdomain of one, written as a plain hostname: ASCII letters, digits, hyphens, underscores, and dots, with no scheme, port, credentials, wildcard, or whitespace, no label that begins or ends with a hyphen, and no path other than the optional `web_search` path suffix described later in this list. Use `example.com`, not `https://example.com`, `example.com:443`, or `*.example.com`. Hostnames are compared without regard to case, and a single trailing `/` is ignored.
620* A listed domain matches that host and its subdomains: `example.com` covers `docs.example.com`, but `docs.example.com` does not cover `example.com` or `api.example.com`. A leading `www.` is a subdomain like any other, so `www.example.com` does not cover `example.com`; list the bare domain to cover both.
621* IP addresses are not accepted in any form, whether IPv4, IPv6, bracketed, or numeric shorthand such as `127.1`. List the site's domain name instead.
622* A bare top-level domain or registry suffix such as `com`, `co.uk`, or `gov.uk` is rejected, and so is a single-label name such as `intranet`. List a full domain such as `example.co.uk`.
623* `localhost` and hosts ending in `.localhost`, `.local`, `.internal`, `.localdomain`, or `.invalid` are rejected.
624* Use the `xn--` (Punycode) form for internationalized domain names; a domain that contains non-ASCII characters is rejected.
625* A `web_fetch` domain cannot include a path: use `example.com`, not `example.com/*`. A `web_search` domain can carry a path suffix such as `example.com/blog`, in which the path cannot contain spaces, `?`, `#`, or any of the characters `$ , | ^ !`. Prefer plain hostnames for `web_search` too, because the search provider matches path suffixes as URL patterns rather than as strict host rules.
626* Duplicate domains within a list are rejected. `www.example.com` and `example.com` count as different domains; see the earlier matching rule for what each covers.
627
628#### When settings are validated
629
630Format and limit violations are rejected with a 400 `invalid_request_error` when you [create an agent](https://platform.claude.com/docs/en/managed-agents/agent-setup#create-an-agent) or [update an agent](https://platform.claude.com/docs/en/managed-agents/agent-setup#update-an-agent), and when you create or update a session that supplies `tools`. For example, the message for an entry that sets both lists includes `Only one of allowed_domains or blocked_domains may be set.`, and the message for an empty list includes `allowed_domains: Empty list of domains is ambiguous. Provide at least one domain or null.` The message for a domain that breaks a format rule names its list and zero-based position, for example `allowed_domains.0: IP addresses are not supported; provide a plain hostname like "example.com"`.
631
632The same requests also reject three settings that depend on the search and fetch providers: a domain in `allowed_domains` that Anthropic's crawler is not permitted to access, a `user_location.country` that the search provider does not support (the message ends in `user_location.country: not a country the search provider supports`), and a `user_location.timezone` that is not a valid IANA name. The session checks the configuration again when it first initializes the tool; if a setting that was accepted earlier is no longer valid at that point, the session emits a [`session.error`](https://platform.claude.com/docs/en/managed-agents/events-and-streaming) event and returns to `idle` without retrying. Fix the setting by [updating the session's tools](https://platform.claude.com/docs/en/managed-agents/session-operations#updating-the-agent-configuration), update the agent as well so that new sessions start with the corrected configuration, then send a new `user.message` to continue.
633
634#### Multiagent sessions, outcomes, and mid-session updates
635
636In a [multiagent session](https://platform.claude.com/docs/en/managed-agents/multiagent-orchestration), every domain list that applies to a thread is enforced at the same time: an agent in the roster of the coordinator is bound by its own `allowed_domains` and `blocked_domains`, by those of any agent that called it, and by the coordinator's current lists.
637
638* Allowlists combine to the domains that all of them cover, and blocklists add together, so a roster agent can narrow what a tool reaches but never widen it. For example, a roster agent that sets `blocked_domains` keeps the coordinator's `allowed_domains` and blocks those hosts within it, and a roster agent that sets its own `allowed_domains` can reach only the hosts that both its list and the coordinator's list cover.
639* If the combined allowlists have no domain in common, the tool stays available to that agent but every call fails with a `url_not_allowed` error stating that no domain is permitted, and the tool description tells the model so. Keep each roster agent's allowlist inside the coordinator's to avoid this.
640* `max_content_tokens` and `user_location` are not combined: a thread uses the value from its own tool configuration if set, otherwise from the agent that called it, otherwise from the coordinator's current configuration.
641* A `{"type": "self"}` roster entry has no web settings of its own and follows the coordinator's current settings.
642* The grader in [outcome-driven sessions](https://platform.claude.com/docs/en/managed-agents/define-outcomes) runs without `web_search` and `web_fetch`, regardless of these settings.
643* You can change the lists on an idle session by [updating its tools](https://platform.claude.com/docs/en/managed-agents/session-operations#updating-the-agent-configuration). The new lists apply to the rest of the session; in a multiagent session, every thread applies them from its next turn, while a roster agent's own lists stay as its agent definition set them when the session was created.
644
645#### Differences from the Messages API tools
646
647These settings use the same `allowed_domains` and `blocked_domains` vocabulary as [domain filtering](https://platform.claude.com/docs/en/agents-and-tools/tool-use/server-tools#domain-filtering) on the Messages API server tools, with the following differences on Managed Agents:
648
649* Each list is capped at 64 domains.
650* Domains listed for `web_fetch` cannot include a path.
651* `max_uses`, `citations`, and `cache_control` are not available on the toolset.
222652
223653## Custom tools
224654
225655
No line in this hunk matches that.