Bot & AI
Stop forcing customers through scripted menus. Define tools (order lookup, calendar booking, CRM query), and the AI decides when to call each one — based on what the customer asked.
Tool types
Webhook, JS, built-in
Tools per bot
Define as many as you need
Tool call latency
Plus your API latency
On failure
Smart error handling
Define a tool by URL + JSON schema. The LLM calls your endpoint with structured arguments when the conversation needs it. Returns flow back into the response.
Drop in custom logic without standing up an endpoint. Great for transformations, lookups in static data, or simple calculations.
Pre-built tools for common needs: send_email, create_calendar_event, lookup_order, query_knowledge_base. Configure with one click; no code required.
Unlike scripted flows where you specify exactly when to call an API, custom tools let the LLM decide based on conversation context — true AI agent behavior.
Each tool defines its arguments with JSON schema. The LLM is forced to provide valid arguments before the tool fires — no half-baked API calls.
Every tool call is logged with arguments, response, and timing. Debug conversations by replaying which tools were called and why.
Give it a name (e.g. 'get_order_status'), a description (when the LLM should call it), and a JSON schema for arguments. Point it at your webhook URL.
'Where's my order, the ID is NC-482919?' — the LLM reads the message and decides 'get_order_status' fits. It extracts the order ID into the tool arguments.
POST to your endpoint with structured JSON args. Your API returns the order data in JSON. Edesy injects that response back into the LLM's context.
With the order data in context, the LLM writes a natural response to the customer: 'Your order NC-482919 shipped yesterday and arrives Thursday.' All natural, all grounded in real data.
| Feature | Edesy | Typical WhatsApp platform |
|---|---|---|
| AI-driven tool selection | ||
| Webhook tools | Code only | |
| JavaScript inline tools | ||
| Built-in tool library | Limited | |
| Argument validation (JSON schema) | ||
| Tool call logging | ||
| Multi-step tool chains | ||
| Iteration limit controls |
Tool: lookup_order(order_id). LLM extracts ID from customer message, calls Shopify, replies with real status.
Self-service for 60% of 'where's my order' inquiries
Tools: get_available_slots(specialty), book_appointment(slot_id, patient). LLM walks through booking conversationally.
70% of bookings handled by bot end-to-end
Tools: get_emi_status(loan_id), generate_payment_link(amount). Bot looks up EMI, optionally generates a Razorpay link.
Collection conversations resolved 4x faster
Tools: get_account_details, change_plan, pause_subscription. Bot handles tier-1 account requests without an agent.
47% reduction in support tickets
Tools: search_listings(criteria), schedule_viewing(property_id, slot). Bot pulls live MLS listings and books site visits.
Lead-to-viewing conversion up 2.8x
Tools: get_booking(reference), modify_booking, request_late_checkout. Bot handles guest service requests 24/7.
Front-desk call volume down 55%
A WhatsApp bot without tools can only do two things: respond from its training data or respond from a hardcoded script. That's enough for FAQ-style use cases — 'what are your hours' — but it falls apart the moment a customer asks something specific to them. 'Where's MY order?' requires looking up THEIR order. 'Book ME an appointment' requires writing to YOUR calendar. Without tools, the bot has to escalate to a human for every personalized request, which negates most of the value.
Function calling — the LLM's ability to decide 'I need to call tool X to answer this' and produce the arguments — is what turns a chatbot into an agent. Edesy implements this via custom tools, defined in JSON schema at the bot level. When you wire up a 'get_order_status(order_id)' tool, the LLM gets a description of what it does, when to call it, and what arguments it needs. When a customer asks an order-status question, the LLM autonomously extracts the order ID from the message and fires the tool. Your webhook does the lookup, returns the data, and the LLM weaves it into a natural reply.
The reason this matters more on WhatsApp than other channels is intent: WhatsApp customers expect conversational, personalized service — not a menu tree. If they ask 'is my order shipped yet?', they want a direct answer, not 'please type 1 for order status, 2 for returns'. Custom tools let your bot give that direct answer because the LLM both understood the question and pulled the real data in one step.
The architectural superpower is composition: tools chain. A customer asks 'when is my next EMI and can you charge it now?' The LLM calls get_emi_status, sees the due date and amount, then calls generate_payment_link with those amounts, then replies with both the status and the payment link. All in one customer-facing message, all in <2 seconds. This is the conversational depth that customers describe as 'just feels like talking to a smart agent' — and it's achievable because Edesy's tool runtime supports up to 5 sequential tool calls per LLM turn.
Define your first custom tool in 5 minutes. Connect to your existing APIs and watch the bot handle conversations that used to require an agent.