Agent tools

Agents can call tools mid-conversation to take actions: end the call, look up data in your CRM, query a knowledge base, send a rich card to the chat widget, integrate with an MCP server, or hit any HTTP endpoint you own. The LLM decides when to call a tool based on its system prompt and the conversation context.

Three kinds of tools:

Mix and match — an agent can have any combination active at once.

Built-in tools

Pre-implemented tools shipped with Nerva. Toggle them on per-agent.

Voice + Chat

Voice-only

Chat-only

CRM-attached tools

When you attach a CRM integration to an agent, additional tools become available. For GoHighLevel:

• lookup_contact — search contacts by phone or email
• check_availability — list free calendar slots
• book_appointment — book a confirmed slot
• get_pipelines — list opportunity pipelines

See CRM integrations for details.

Webhook tools

Webhook tools are custom HTTP calls your agent can make. You define the URL, HTTP method, request shape, and how the response should be parsed; the LLM decides when to call it based on the description you give.

This is the most powerful tool type — it's how you connect agents to your own backends, third-party APIs, or any HTTP service.

Configuring a webhook tool

Dashboard → Agents → your agent → Tools → Add webhook tool:

Use case 1 — Order status lookup

A support agent looks up order status mid-call.

Name: lookup_order
Description: |
  Look up the status of an order by ID. Use this when the customer asks
  about an order or wants tracking information. The order ID is usually
  6+ alphanumeric characters.
 
URL: https://api.example.com/orders/{{order_id}}
Method: GET
Auth: Bearer (your API token)
 
Parameters:
  - name: order_id
    type: string
    description: The order ID, typically alphanumeric
    in: url-path
    required: true
 
Output schema:
  - status: string         # "pending", "shipped", "delivered", "returned"
  - estimatedDelivery: string  # ISO date
  - trackingNumber: string

The agent now responds naturally: "Let me check that for you... your order is shipped and should arrive by Friday."

Use case 2 — Trigger an n8n / Zapier workflow

Fire a complex multi-step automation from inside a call.

Name: send_quote_email
Description: |
  Send a personalized quote email to the customer. Use this when the
  customer agrees to receive a quote.
 
URL: https://hook.us2.make.com/abc123xyz
Method: POST
Auth: None  # webhook URL is the secret
 
Parameters:
  - name: customer_email
    type: string
    description: The customer's email address
    in: body
 
  - name: product_name
    type: string
    description: The product they're interested in
    in: body
 
  - name: quoted_price
    type: number
    description: The agreed-upon price
    in: body

The agent: "Great — I'll send that quote to your inbox right now." Make runs the workflow (lookup customer in HubSpot, generate PDF, attach, send via Gmail), and the agent gets a 200 OK to confirm.

Use case 3 — Stripe payment link

Generate a one-time payment link during the call.

Name: create_payment_link
Description: |
  Create a payment link for a one-time charge. Use when the customer
  agrees to pay. Reads back the link to the customer or texts it via
  send_sms.
 
URL: https://api.stripe.com/v1/payment_links
Method: POST
Auth: Bearer (your Stripe restricted key)
 
Headers:
  Content-Type: application/x-www-form-urlencoded
 
Parameters:
  - name: amount_cents
    type: integer
    description: Amount in cents (e.g., 4999 for $49.99)
    in: body
 
  - name: description
    type: string
    description: What the customer is paying for
    in: body
 
Output schema:
  - url: string  # the payment link

Combine with send_sms: "I've sent the link to your phone. It's $49.99 for the premium plan."

Use case 4 — Internal sales lookup

Read your CRM/ERP to personalize the call.

Name: get_account_summary
Description: |
  Get the customer's account summary including their plan, MRR, and last
  contact date. Call this at the start of every conversation when you have
  the caller's phone number.
 
URL: https://api.your-saas.com/accounts/by-phone
Method: GET
Auth: API key (X-Api-Key header)
 
Parameters:
  - name: phone
    type: string
    description: E.164 phone number (e.g., +14155551234)
    in: query
 
Output schema:
  - companyName: string
  - plan: string           # "free", "pro", "enterprise"
  - mrr: number
  - daysSinceLastContact: integer
  - openTickets: integer

The agent uses this for context: "Hi Sarah, I see you're on our Pro plan and have one open ticket about billing — is that what you're calling about?"

Use case 5 — Real-time inventory

Check live stock before promising delivery.

Name: check_inventory
Description: |
  Check whether a product is in stock at a specific store location. Use
  before committing to a delivery date.
 
URL: https://api.your-store.com/inventory
Method: POST
Auth: Bearer (your API token)
 
Body template:
  {
    "sku": "{{sku}}",
    "store_id": "{{store_id}}",
    "qty": {{qty}}
  }
 
Parameters:
  - name: sku
    type: string
    description: Product SKU
    in: body
 
  - name: store_id
    type: string
    description: Store ID or location code
    in: body
 
  - name: qty
    type: integer
    description: Quantity needed
    in: body
 
Output schema:
  - available: boolean
  - quantityOnHand: integer
  - earliestRestockDate: string  # null if available

Webhook tool best practices

• Write the description for the LLM, not for humans. Be specific about when to call it ("when the customer asks about X", not "this gets X").
• Name parameters clearly. customer_email beats email if there could be more than one email in the conversation.
• Use output schemas so the agent can refer to specific response fields without guessing JSON keys.
• Keep timeouts short. 5–10s is plenty for most APIs. Long timeouts block the conversation.
• Authenticate via the Auth field, not custom headers. That way Nerva redacts secrets from logs automatically.
• Test with Send test event before pointing real traffic at it.

MCP tools

Model Context Protocol (MCP) is an open standard for connecting LLMs to external systems. Many SaaS products and internal services expose an MCP server that handles auth, schemas, and tool discovery automatically — point Nerva at the URL and your agent gets all those tools at once.

Configuring an MCP tool

Dashboard → Agents → your agent → Tools → Add MCP server:

Nerva connects to the server, fetches its tool catalog, and registers each tool with the LLM. The LLM sees them like any other tool.

Use case 1 — Notion workspace

Let the agent read and create pages in your team's Notion workspace.

Name: Notion
Server URL: https://mcp.notion.com/mcp
Headers:
  Authorization: Bearer ntn_xxxxxxxxxxxxxxxxxxxxxxxx
 
Selected tools:
  - search_pages
  - create_page

The agent can now: "Let me find that runbook... [searches Notion]... here's the relevant section." Or: "I've created a Notion page with the action items from this call."

Use case 2 — GitHub repo access

A dev-tools support agent can search code, read PRs, file issues.

Name: GitHub
Server URL: https://api.githubcopilot.com/mcp/
Headers:
  Authorization: Bearer ghp_xxxxxxxxxxxxxxxxxxxxxxxx
 
Selected tools:
  - search_code
  - get_pull_request
  - create_issue

Use case: developer support agent that can answer "where is the auth middleware defined?" by searching code, then file a GitHub issue describing the bug the user reported.

Use case 3 — Linear / Jira / Asana

Let the agent file tickets directly from a support call.

Name: Linear
Server URL: https://mcp.linear.app/mcp
Headers:
  Authorization: Bearer lin_api_xxxxxxxxxxxxxxxxxxxx
 
Selected tools:
  - create_issue
  - search_issues

"I've filed Linear ticket ENG-1234 with the steps you described. Engineering will follow up by tomorrow."

Use case 4 — Slack notifications

Notify a channel from inside a call.

Name: Slack
Server URL: https://your-mcp-proxy.example.com/slack
Headers:
  Authorization: Bearer your-proxy-token
 
Selected tools:
  - post_message

"I'm escalating this to our on-call engineer right now... done, they'll ping you in the next 5 minutes."

Use case 5 — Internal company MCP

Build your own MCP server exposing your specific business operations (create user, refund order, escalate ticket) and point your agents at it.

This is the cleanest way to expose a suite of related tools without configuring each one as a webhook tool. Build the server once with your auth + schemas; every agent attaches with a single URL.

Name: Acme Internal Ops
Server URL: https://mcp-internal.acme.com/v1/mcp
Headers:
  X-Internal-Token: {{your-vault-secret}}
 
# All tools exposed by the server — selected_tools blank

MCP best practices

• Restrict scope. Use the selected_tools allowlist to only expose tools the agent actually needs. Don't give a customer-support agent access to your delete_account tool.
• One MCP server per concern. Notion + Linear + GitHub as three separate MCP entries is cleaner than one mega-server.
• Auth happens at the server. MCP servers handle their own auth — you pass a token in headers and the server scopes the operations. No need to repeat auth config per tool.
• Test with a short prompt. After adding an MCP server, verify the agent can list its tools with a prompt like "what tools do you have for Linear?" before relying on them in production.

How the agent decides which tool to call

The LLM sees all enabled tools as function-calling candidates. It picks based on:

1. Conversation context — what the user just said.
2. Tool descriptions — short, specific descriptions guide the LLM toward the right tool. Be intentional.
3. System prompt — your top-level instructions shape tool-selection bias ("always look up the contact first before answering pricing questions").

Multiple tools can be called in a single turn — the agent might lookup_contact then immediately book_appointment based on the returned data, all before responding to the user.

Webhooks vs webhook tools — clarifying the names

Nerva uses "webhook" for two distinct things:

Both are HTTP POSTs from Nerva to your URLs, but they fire at different times for different reasons. Webhooks are about what just happened; webhook tools are about what the agent wants to do right now.

See also

• Voice agents — voice-specific tool considerations
• Chat agents — chat-specific tool considerations
• CRM integrations — managed tools shipped via CRM connections
• Webhooks — outbound event delivery (different concept)