I wanted a simple way to show what LLM tool calling looks like when the tools are real communication actions.
Not a weather lookup. Not a calculator.
Something you can feel immediately from your phone.
The Telnyx code example is here:
https://github.com/team-telnyx/telnyx-code-examples/tree/main/agent-with-tool-calling
The result is an agent that can read a normal message like:
Text +13125550001 I am running five minutes late
and decide to call the SMS tool.
Or:
Call me at +13125550001
and decide to call the voice tool.
The Idea
Most demos make the user choose the action first.
Click this button to send a text. Click that button to place a call. Pick a workflow. Fill in a form.
This sample flips that around.
The user writes what they want. The model reads the request, chooses one of the allowed tools, extracts the phone number and message body, and the application executes the action through Telnyx.
The approved tools are:
send_smsmake_callcheck_status
The model does not get to run arbitrary code. It gets a small, explicit set of tools with JSON schemas.
The Full Loop
The important part is that tool calling is a loop, not a single model response.
The flow is:
user message
-> model receives tool definitions
-> model returns a tool call
-> app executes the selected tool
-> app appends the tool result with the same toolCallId
-> model sees the tool result
-> model writes the final response
That last model pass matters. The tool result is structured data. The final assistant response is the human-readable summary.
So if the model chooses send_sms, the app sends the SMS first. Then the model gets the result and can say what happened in a clean sentence.
Why I Like This Example
It makes tool calling concrete.
You can inspect the code and see the exact line where Telnyx Inference is called:
this.env.TELNYX.ai.openai.chat.createCompletion()
You can inspect the SMS dispatch:
this.env.TELNYX.messages.send()
You can inspect the voice dispatch:
this.env.TELNYX.calls.dial()
And you can inspect the ledger that records each tool call and its toolCallId.
That makes the demo much easier to trust. If something happens, you can trace it.
What The Agent Remembers
The sample runs on Telnyx Edge Compute with the Agent SDK.
The ToolAgent keeps conversation history and records tool activity. That means a user can ask a follow-up like:
Did the SMS send?
The model can choose check_status, and the app can look up the latest send_sms event in the local ledger.
That is a useful pattern for real workflows. Users ask follow-up questions. They do not always phrase the second message with all the context from the first one.
The Phone Is The Interface
The fun part of this sample is that the phone becomes the proof.
When the agent sends an SMS, the recipient sees the message.
When the agent places a call, the phone rings.
That makes it different from a lot of LLM demos. You are not just watching a terminal print JSON. You are watching a model choose an action that reaches a real person through a real communications channel.
Running It
Start with the code sample:
git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/agent-with-tool-calling
npm install
Run:
npm run typecheck
npm run types
npm run ship
Then configure your Telnyx number, Messaging Profile webhook, Call Control application, and Edge function settings.
Try:
Text +13125550001 meet me at the front desk
Call me at +13125550001
Did the SMS send?
The Pattern To Reuse
This is the shape I would reuse for a lot of communication workflows:
- let the LLM classify intent
- keep the tool surface small
- validate phone numbers before dispatch
- execute tools exactly once
- store a ledger
- pass the tool result back to the model
- return a short final answer
That gives you the flexibility of natural language with the control of normal application code.
