Remote tool calling, without giving us your API keys

Most support bots know what you told them yesterday. They search docs, match FAQs, and repeat answers from a knowledge base. That works until someone asks: *"Where is my order?"*

That question needs live data. Order status lives in Shopify. Subscription state lives in Stripe. Account details live in your database. The bot needs to call out — not just look up.

We built Custom Tools for exactly that: remote tool calling that turns Thoth into a first-line agent that can reach your systems mid-conversation, without Thoth ever holding your third-party API keys.

Tools, but make them yours

If you've used an AI assistant with function calling, the shape is familiar. During a ticket, Thoth's model decides it needs information it can't get from docs or past conversations. It picks a tool, fills in arguments, and waits for a result.

What makes our version different is where those tools come from.

You define them in the dashboard:

• A name the model calls (check_order_status)
• A description that tells the model when to use it
• A parameter schema (order ID, email, plan tier — whatever the lookup needs)
• A webhook URL pointing at infrastructure you run

Thoth compiles that schema into a real tool at runtime. String fields become Zod validators. Enums become constrained choices. Required vs optional parameters are enforced before any network request goes out.

No deploy. No code change on our side. Add a tool in the dashboard, paste the signing secret into your server, and the next ticket can call it.

The call goes to you, not through us

When the model invokes a custom tool, Thoth POSTs a signed JSON payload to your HTTPS endpoint:

json{
  "tool": "check_order_status",
  "guildId": "123456789012345678",
  "ticketId": 42,
  "discordUserId": "987654321098765432",
  "arguments": {
    "orderId": "ORD-42"
  },
  "timestamp": 1710000000
}

Your server verifies the HMAC signature, looks up the order with your Shopify credentials, and returns JSON:

json{
  "orderId": "ORD-42",
  "status": "shipped",
  "carrier": "UPS",
  "eta": "2026-06-24"
}

Thoth feeds that back to the model as context. The user gets an answer grounded in live data.

The interesting part: Thoth never stores your Shopify, Stripe, or internal API keys. We store one thing — an encrypted webhook signing secret — so we can prove requests came from us and you can prove requests came from us. Everything sensitive stays on your side.

Security wasn't an afterthought

Letting a multi-tenant SaaS bot call arbitrary URLs is a footgun. We treated it that way from the start.

On the way out (Thoth → your webhook):

• HTTPS only — no HTTP, no IP literals, no .local / .internal hostnames
• DNS resolution checked at call time so a safe-looking domain can't redirect to a private IP (SSRF protection)
• 10-second timeout, 64 KB response cap, response sanitization before it touches the model
• Per-guild and per-tool rate limits, plus a cap of three custom tool calls per model turn

On the way back (your webhook → the model):

• Tool output is explicitly marked untrusted context in the system prompt
• The model is instructed never to follow directives found inside tool responses
• Documentation-backed claims still require a knowledge base search — live lookups don't replace your docs

On the wire:

• HMAC-SHA256 signatures over timestamp + body, with a five-minute replay window
• Bearer token in Authorization for a second verification path
• Context fields (ticketId, discordUserId, channelId) are opt-in per tool — you choose what Thoth sends

This is the architecture we wanted: remote execution with local trust boundaries. You control the data access. We control the call surface.

Same tools in tickets and the Playground

Custom tools aren't a production-only feature bolted onto live traffic. They run in the same pipeline as real Discord tickets and in the dashboard Playground, so you can test *"where is order ORD-42?"* before a customer asks.

There's also a Test tool button that sends sample arguments straight to your webhook — useful when you're iterating on signature verification or response shape without burning model tokens.

Why we like this design

A lot of products solve "live data" by asking you to paste API keys into their settings. That's fast to ship and painful to trust. Your keys sit in someone else's database. Their outage becomes your outage. Their breach becomes your breach.

Webhook-based tool calling flips the model:

1. You define what the AI can ask for (parameter schema + description)

2. You decide what context Thoth includes (Discord user, ticket ID)

3. You implement the lookup with whatever auth you already use

4. Thoth handles the orchestration — when to call, argument validation, rate limits, prompt injection defenses

The AI gets function calling superpowers. You keep custody of your systems.

Try it

Custom Tools are available on Plus (10 tools per server) and Enterprise (25 tools per server). Setup takes a few minutes: create a tool, deploy a small webhook handler, verify signatures, test in Playground.

We publish the Node.js verification helper (@thothsupport/webhook), a mock demo server, and a dashboard import bundle in the open-source thoth-open repository — useful if you want to try the flow before writing your own backend.

If you're already running Thoth, head to Custom Tools in your guild settings. If you're evaluating support bots and live lookups matter to you — this is the piece most products hand-wave. We didn't.

---

*Questions about custom tools or webhook verification? Read the docs, browse thoth-open for the SDK and demo server, or open a ticket — Thoth might even call one of your tools to answer it.*