Skip to content
The Chat Agent
Dynamic tools

Connect any API as a tool — no code

Give the model access to your internal APIs, third-party services, or any REST endpoint by describing what it does and declaring a parameter schema. The model decides when to call it and fills in the parameters automatically.

Create a toolTool docs

How it works

Define once, call automatically

Three steps turn any REST endpoint into a model-callable tool. No deployment, no code changes — just a name, a description, and a schema.

Describe the endpoint

Give the tool a clear name and a plain-English description of what it does. The model uses this description to decide when the tool is relevant — precision here pays off.

  • Name and description drive zero-shot selection
  • Include the HTTP method and base URL
  • Add per-tool authentication headers

Declare a parameter schema

Define the parameters your endpoint accepts using a standard JSON Schema object. The model fills in values at runtime based on the conversation — required fields are enforced automatically.

  • Full JSON Schema type support
  • Required vs. optional fields enforced
  • Enum constraints and default values

Let the model call it

Once saved, the tool is available in any chat or agent where you enable it. The model selects and invokes it automatically — the call and its result stream inline in the thread.

  • Zero-shot tool selection by the model
  • Inputs and outputs visible in-thread
  • Enable per chat, per agent, or globally

Tool builder

What the tool builder produces

Fill in the form — name, description, method, URL, and parameter schema — and the builder generates this definition. The model receives the schema at runtime, decides when the tool is relevant, and fills in the parameters from context.

Tool definition (produced by the builder)
{
  "name": "search_products",
  "description": "Search the product catalogue by keyword. Returns matching product names, prices, and current stock levels.",
  "method": "GET",
  "url": "https://api.acme.example/v1/products?q={query}&limit={limit}",
  "headers": {
    "Authorization": "Bearer {{env.ACME_API_KEY}}"
  },
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "The keyword or phrase to search for in the product catalogue."
      },
      "limit": {
        "type": "integer",
        "description": "Maximum number of products to return.",
        "default": 10
      }
    },
    "required": ["query"]
  }
}

The {{env.ACME_API_KEY}} placeholder is resolved server-side from the secrets you save in Settings — it never reaches the model or the browser.

Use cases

Any API, any workflow

Teams use dynamic tools to close the gap between the model and the systems they already run — without building a custom integration layer.

Internal data lookup

Expose read-only queries against your own databases or data warehouses. Let teammates ask natural-language questions and get live answers pulled from the source of truth.

  • Query internal APIs without writing SQL
  • Scope access with API-key permissions
  • Works with any REST-wrapped data store

CRM & ticketing actions

Let the model create tickets, update contact records, or look up account details in Salesforce, HubSpot, Jira, or any CRM with a REST API — mid-conversation, automatically.

  • Create, update, and query CRM records
  • Open and triage support tickets in-thread
  • Map conversation context to API fields

Search & retrieval

Connect vector databases, search APIs, or knowledge bases so the model can pull relevant documents and ground its answers in your own content.

  • Retrieval-augmented generation (RAG) ready
  • Works with Pinecone, Weaviate, Elasticsearch
  • Pass filters and metadata in the schema

Webhooks & automations

Trigger downstream workflows — send a Slack message, kick off a CI pipeline, publish to a queue — whenever the model determines the action is appropriate based on the conversation.

  • Fire-and-forget or wait-for-response modes
  • Carry conversation context into the payload
  • Chain multiple tool calls in a single turn
The tool builder — name, description, method, URL, headers, and parameter schema in one screen

Security by design

Dynamic tools can only call endpoints you explicitly configure. The model cannot construct or invoke arbitrary URLs — every request goes through a validated allowlist of your own tool definitions. Secrets are stored encrypted and resolved server-side; they are never sent to the model or exposed to the browser.

Connect your first API in minutes

Open the tool builder, paste your endpoint URL, describe what it does, and you're live. No code, no redeploy.

Get started freeRead tool docs