Function calling lets AI use tools to do things beyond conversation—calculate, check the weather, access your calendar. With MyBenAI, all these functions are built-in and run on your phone, so you don't manage API keys, pay per request, or wait for cloud latency. Function calling without API keys means simpler, faster, private tool use.
What is Function Calling?
Function calling (also called tool use) is the ability for an AI model to request tools to accomplish tasks. In a normal chat, the model generates text in response to your prompt. With function calling, the model can instead say: "I need to calculate something" or "I need to look up the current temperature" and request a specific tool. The app then runs that tool and returns the result to the model, which incorporates it into the response.
For example: you ask ChatGPT "What's 2,847 times 391?" The model might try to calculate in its head and get it wrong. With function calling, it requests a calculator tool, receives the correct answer (1,113,177), and gives you accurate results. The same works for weather, currency conversion, accessing your contacts, or scheduling calendar events.
The ChatGPT Plugin Problem
ChatGPT's plugin ecosystem was supposed to unlock this. In theory, ChatGPT Plus subscribers could enable third-party plugins (Zapier, Wolfram Alpha, web browsing, etc.) and the model would call them seamlessly. In practice, this model had serious drawbacks:
- Cost: Plugin usage wasn't free. While ChatGPT Plus is $20/mo, heavy plugin use adds per-request charges. A plugin call might cost $0.02-$0.10, which adds up fast. Calculating with Wolfram Alpha every conversation gets expensive.
- Latency: Each plugin call requires a network round trip to OpenAI's servers, then to the plugin provider. A simple calculation might take 2-5 seconds. Multiple tool calls compound the delay.
- Reliability: Plugins break when the third-party service is down. If Wolfram Alpha is having issues, your ChatGPT calculations fail, even though calculation is logically simple.
- Privacy: Plugin calls leave traces: OpenAI logs which tools you use, what inputs you send, and what results you receive. They may use this data for analytics or model improvement.
- API key management: To use plugins that need authentication (email, social media, your own APIs), you paste API keys into ChatGPT's interface. That's a security concern and a manual burden.
The core issue: ChatGPT turned tools into a premium service with cloud dependency, when tools could be much simpler.
Function Calling Without API Keys
MyBenAI takes a different approach: built-in tools run locally on your phone, with no API keys, no per-request cost, and no cloud latency. When the model requests a tool, the app runs it instantly on-device. The result comes back in milliseconds, not seconds.
Built-in tools in MyBenAI include:
- Calculator: Arithmetic, conversions, unit math. No cloud API required.
- Clock and timers: Ask "What time is it in Tokyo?" or "Set a 10-minute timer." Responds instantly using device time.
- Calendar: "Schedule a meeting for 2 PM Tuesday" or "When am I free next week?" The model reads your calendar (with your permission) and updates it.
- Contacts: "What's Sarah's phone number?" or "Email john@example.com" with a draft message. Device contacts are retrieved locally.
- Currency and crypto: "Convert $100 to EUR" or "What's the BTC price?" These require live network data for current rates, but requests come from your phone, not a third-party service.
- Weather, device status, dictionary: Additional reference tools; weather and some services need network access for live data.
The big difference: core local tools (calculator, clock, calendar, contacts) work without network calls. No cost, no third-party API keys, and your message content stays on your phone. Function calling without API keys means zero friction for local execution.
Tool Allowlists and Privacy Control
You don't have to enable every tool. MyBenAI ships with a default tool allowlist: by default, the model can call calculator and basic reference tools, but not access your calendar or contacts. You control this in settings.
For sensitive tools like contacts or calendar, you explicitly grant permission. The model learns which tools are available, but it only calls them if you've approved them. If you don't want the model accessing your calendar, you disable that tool, and the model won't try. This is fine-grained control—not "let ChatGPT access everything" or "restrict it completely," but "let the model use these specific tools with your approval."
This also matters for MCP connectors and remote server integration. When you add a custom connector (Home Assistant, your own API, a remote MCP server), you can set a per-connector tool allowlist. Maybe the Home Assistant connector is allowed to control lights but not locks. This prevents tool misuse: even if the model tries to call a tool it shouldn't, the allowlist blocks it.
Comparison: Local Tools vs Cloud Plugins
Here's how MyBenAI's approach differs from ChatGPT's plugin ecosystem:
- Cost: ChatGPT plugins: $20/mo + per-request charges. MyBenAI tools: $2 one-time, unlimited calls.
- Speed: ChatGPT plugins: 2-5 seconds per tool call (network round trip). MyBenAI built-in tools: fast, instant local execution with no remote latency.
- Availability: ChatGPT plugins: dependent on third-party uptime. MyBenAI tools: always work (run on your phone).
- Privacy: ChatGPT plugins: logged by OpenAI and plugin providers. MyBenAI tools: message content stays on-device; API keys encrypted in MMKV, never transmitted to third parties.
- API keys: ChatGPT plugins: you manage and store keys in the cloud. MyBenAI tools: encrypted on-device in MMKV, never sent to remote services.
The trade-off: MyBenAI's built-in tools are fewer and simpler than ChatGPT's plugin library. You can't add a Slack plugin to MyBenAI (you could with ChatGPT, if you pasted your API key). But for everyday tasks—calculate, check time, look up a contact—local tools are faster, cheaper, and more private. For advanced integrations, you can add MCP connectors to connect remote servers while keeping fine-grained control over which tools each connector can access.
When to Use Local Tools vs Remote Connectors
MyBenAI draws a clear line: built-in local tools for everyday use (calculator, calendar, weather reference), and optional remote connectors for custom integrations. This keeps the default experience fast and private, while giving power users the option to safely extend the AI with remote APIs.
For example:
- Local: "Calculate my hourly rate if I earn $80k/year." Instant, no API call.
- Remote connector: "Turn on my living room lights in my Home Assistant." Requires a network call to your own home server (user-controlled, and recorded in the app's network log so you can see it happen).
The model learns which tools are available and when to use each. This is how function calling and tools architecturally work: the model sees a tool schema (name, description, parameters), decides whether to call it, and the app handles execution.
How MyBenAI Executes Tool Calls
When you chat in MyBenAI and the model decides it needs to use a tool:
- The model generates a tool call (e.g., "calculator tool: multiply 2847 by 391").
- The app intercepts this and checks the tool allowlist. Is the tool enabled? Is it available on this device?
- The app executes the tool locally (e.g., runs the calculation).
- The result (1,113,177) is sent back to the model as context.
- The model incorporates the result into its response: "The answer is 1,113,177."
This entire cycle happens on-device, with no cloud round trip. The model doesn't need to upload your question to an API provider; it gets the answer instantly from local execution.
Trade-Offs: Simplicity Over Extensibility
MyBenAI's tool architecture prioritizes simplicity and speed over breadth. You get a curated set of reliable, fast, private tools built-in. You don't get the Slack plugin, the Zapier integration, or access to every third-party API. If you need advanced integrations, you add MCP connectors, which requires more setup but gives you full control.
For most users, this trade-off is worth it. Everyday use doesn't need a plugin marketplace. It needs a calculator that works instantly, a calendar that doesn't log your schedule to a cloud service, and contacts that never leave your phone. That's what function calling without API keys delivers.
Getting Started with Tool Calling
When you open MyBenAI, built-in tools are ready to use. Just ask: "What's the time in Paris?" or "Calculate 15% of $240" or "When's my next meeting?" The model will use the appropriate tool automatically. If you want to enable more sensitive tools like calendar or contacts, you can do so in Settings > Tools.
For custom integrations, device integration with contacts and calendar gives you local access. For remote tools (Home Assistant, custom APIs, remote MCP servers), add a connector in the app and configure which tools it exposes.
Why This Matters for Privacy and Reliability
Every tool call is a potential privacy leak if sent to the cloud. With function calling without API keys and local-first execution, you eliminate that risk. Your calculations, calendar reads, contact lookups—all stay on your phone. Additionally, local execution means reliability: tools never fail because a third-party service is down. You're not dependent on Wolfram Alpha's uptime or ChatGPT's plugin infrastructure.
This is the core advantage of an on-device AI assistant: not just the chat is local, but the tools it uses are local too. You get a complete, offline-capable assistant with built-in function calling—no API key management, no per-request charges, no cloud latency, and no third-party service in the loop.
Ready to experience fast, private function calling? Get MyBenAI and start using local tools immediately. Explore how function calling and tools architecture work in detail, learn about using an offline AI assistant with no internet, or dive into the specifics of accessing your contacts and calendar locally.