Custom Tool Groups - Launch Agents in Minutes, Not Days

Custom Tool Groups – Launch Agents in Minutes, Not Days

Yesterday we introduced Tool Groups, which let you scope your MCP server to specific domains like ecommerce or social. Today, we’re taking it one step further: Custom Tool Groups.

You can now create your own MCP server instance with exactly the tools you need—no more, no less. Whether you need a laser-focused customer support agent or a research assistant with surgical precision, Custom Tool Groups let you configure it in minutes using our new Configuration Wizard.

The Problem: One Size Doesn’t Fit All

Tool Groups solved context pollution by letting you choose pre-defined clusters like social or browser. But what if your use case doesn’t fit neatly into a category?

Let’s say you’re building a price monitoring agent. You need:

Amazon product search
eBay product data
Google Shopping insights

But you don’t need Walmart, Target, or the 15 other e-commerce datasets in the ECOMMERCE group. Loading them wastes tokens and distracts the model.

Or imagine a B2B research agent that only needs:

LinkedIn person profiles
LinkedIn company data
Search engine (for finding leads)

You don’t need Amazon, Walmart, or other e-commerce tools. They’re just noise.

The Solution: Granular Tool Selection

We’ve extended our MCP server to support per-tool customization via URL parameters. You can now hand-pick the exact capabilities your agent needs.

How It Works

Under the hood, our authentication layer extracts a tools parameter from the connection URL and dynamically constructs the tool manifest:

function extract_url_params(request){
    const url = request.url || '';
    const params = {};

    // Extract individual tools parameter
    const tools_match = url.match(/tools=([a-zA-Z0-9_,]+)/);
    if (tools_match)
    {
        const tools_str = tools_match[1];
        params.tools = tools_str.split(',')
            .map(t=>t.trim())
            .filter(Boolean);
    }
    return params;
}

When you specify ?tools=web_data_amazon_product,search_engine, the server builds an allowed tool set that only includes those two tools:

function build_allowed_tools(groups = [], tools = []){
    const allowed = new Set();
    for (let groupId of groups)
    {
        const group = Object.values(GROUPS).find(g=>g.id==groupId);
        if (group)
        {
            for (let tool of group.tools)
                allowed.add(tool);
        }
    }
    for (let tool of tools)
        allowed.add(tool);
    return allowed;
}

Finally, every tool registered in the server checks whether the client has access:

const add_tool = tool=>{
    server.addTool({
        ...tool,
        canAccess: auth=>{
            // Pro mode grants access to all tools
            if (auth?.proMode===true)
                return true;
            // Check if tool is in allowed set
            if (auth?.allowedTools && auth.allowedTools.size)
                return auth.allowedTools.has(tool.name);
            // Default to pro_mode_tools list
            return pro_mode_tools.includes(tool.name);
        },
    });
};

The result? The MCP client only sees the tools you explicitly allowed. No distractions. No wasted tokens.

The Configuration Wizard: Zero-Code Setup

Real-World Example: Price Monitoring Agent

Let’s build a price monitoring agent step-by-step.

Step 1: Choose Your Tools

You need:

web_data_amazon_product – Get current Amazon prices
web_data_ebay_product – Compare with eBay listings
web_data_google_shopping – Check Google Shopping trends
search_engine – Find product URLs (included in base tools)

Step 2: Configure via the Wizard

Open the wizard, enter your API token, and use the custom tools parameter:

?tools=web_data_amazon_product,web_data_ebay_product,web_data_google_shopping

The wizard validates your config and generates the connection URL.

Step 3: Connect Your Agent

Paste the URL into your MCP client config (e.g., Claude Desktop’s claude_desktop_config.json):

{
  "mcpServers": {
    "price-monitor": {
      "command": "npx",
      "args": [
        "-y",
        "@brightdata/mcp",
      ],
      "env": {
        "BRIGHTDATA_API_TOKEN": "YOUR_TOKEN",
        "TOOLS":"web_data_amazon_product,web_data_ebay_product,web_data_google_shopping"
      }
    }
  }
}

Step 4: Launch

Your agent now has exactly 4 tools in its context:

search_engine
web_data_amazon_product
web_data_ebay_product
web_data_google_shopping

Instead of 60+ tools clogging the system prompt, you have 4. The LLM’s attention is laser-focused.

Combining Groups and Custom Tools

Here’s the power move: you can mix Tool Groups with custom tools.

Start with a base group, then add individual tools:

&groups=social&tools=web_data_amazon_product

This gives you:

All Social Media tools (LinkedIn, TikTok, Instagram, etc.)
Plus Amazon product data

Use case? An influencer marketing agent that:

Finds creators on TikTok
Analyzes their product mentions
Cross-references Amazon product reviews

You’ve built a hybrid agent with surgical precision.

Performance Impact: Even Leaner Than Tool Groups

Yesterday, we showed that Tool Groups reduce system prompt tokens by ~60% compared to loading all 60+ tools.

Custom Tools takes this further:

Configuration	Tools Loaded	Estimated Token Reduction
Full Suite	60+ tools	Baseline (0%)
Tool Group (e.g., `social`)	~25 tools	~60%
Custom Tools (e.g., 4 tools)	4 tools	~85%

Why does this matter?

Lower latency – The initial handshake is faster
Higher accuracy – The model doesn’t hallucinate parameters from irrelevant tools
Cost savings – You’re paying for fewer input tokens on every request

Token Optimization Beyond Tool Selection

Custom Tools is just one part of our token reduction strategy. We’ve also optimized the output side:

ARIA Snapshot Filtering

When using Scraping Browser tools, the agent receives a DOM snapshot. But a full snapshot can be thousands of tokens.

We filter it to only show interactive elements (buttons, links, form fields):

export class Aria_snapshot_filter {
    static INTERACTIVE_ROLES = new Set([
        'button', 'link', 'textbox', 'searchbox', 'combobox', 'checkbox',
        'radio', 'switch', 'slider', 'tab', 'menuitem', 'option'
    ]);

And we format elements compactly, truncating long names:

static format_compact(elements){
    const lines = [];
    for (const el of elements)
    {
        const parts = [`[${el.ref}]`, el.role];
        if (el.name && el.name.length>0)
        {
            const name = el.name.length>60 ?
                el.name.substring(0, 57)+'...' : el.name;
            parts.push(`"${name}"`);
        }
        // Compact formatting
    }
    return lines.join('\n');
}

Result? A browser snapshot that was 22,000 tokens becomes 3000 tokens. The agent still gets all the information it needs to click buttons and fill forms, but without the bloat.

Domain-Based Browser Session Caching

We also cache browser sessions per domain to avoid unnecessary re-launches:

export class Browser_session {
    constructor({cdp_endpoint}){
        this.cdp_endpoint = cdp_endpoint;
        this._domainSessions = new Map();  // Cache sessions per domain
        this._currentDomain = 'default';
    }

    async _getDomainSession(domain, {log}={}){
        if (!this._domainSessions.has(domain))
        {
            this._domainSessions.set(domain, {
                browser: null,
                page: null,
                browserClosed: true,
                requests: new Map(),
            });
        }
        return this._domainSessions.get(domain);
    }

If your agent is automating Amazon, the browser stays open for subsequent Amazon operations. This cuts execution time by 2-3 seconds per action and reduces token usage from repeated initialization logs.

Try It Out

Custom Tools is live now in The Web MCP server.

Use the Wizard

Visit our MCP control panel to access the Configuration Wizard. Enter your API token, select your tools, and get a ready-to-use connection URL.

Free Tier

Sign up for 5,000 free requests per month on base tools (Web Unlocker and Search Engine). Perfect for prototyping your custom agent.

Tomorrow: We’re releasing something we’ve been working on for months. It’s going to change how you think about agentic workflows. Stay tuned.