Why function calling isn’t enough for real-world AI

Enterprises don’t operate with isolated tasks — they run on complex, interdependent processes. And to build AI assistants that truly serve customers and teams, we need to move beyond atomic functions toward something more robust: process calling.

Function calling: helpful but too limited

The typical implementation of tool use involves atomic API calls like “get_order_status” or “update_user_profile.” Standards like the Model Context Protocol (MCP) promote this approach by keeping tool operations “focused and atomic.”

But when you move into enterprise use cases — like customer support, claims handling, or order fulfillment — things get more complicated.

Take this common scenario in retail:

"My order’s all wrong."

This vague complaint might involve missing items, delivery issues, damaged products, or even buyer’s remorse. Each of those situations requires a unique sequence of validations and responses. Handling them well means interacting with multiple systems, gathering more context, and adapting to the customer’s needs on the fly.

Trying to manage this with only atomic tools leads to brittle solutions.

Why prompt-based tool orchestration fails

Developers often fall back on two fragile patterns when trying to handle multi-step flows:

1. ReAct-style prompts: The LLM runs in a loop, guessing the right sequence of API calls.
2. Prompt stuffing: The model receives a huge chunk of natural-language process instructions and is expected to follow them perfectly.

This approach quickly turns into "prompt and pray." It results in assistants that are hard to debug, inconsistent, and deeply frustrating for users and developers alike. The analogy to Dijkstra’s warning against the GOTO statement in software is apt: when logic jumps are uncontrolled, software becomes impossible to reason about. The same goes for LLM-driven workflows built on guesswork.

What is process calling?

Process calling is a more structured, deterministic way of managing conversations between users, LLMs, and backend systems.

Here's how it works:

1. The user makes a request, and the LLM identifies the relevant business process.
2. Instead of executing just one step, the process persists throughout the conversation:
   

   • It maintains a shared state with the LLM.
   • It follows structured business logic.
   • It branches based on real-time information from both APIs and the user.
   • When user input is needed, it prompts the LLM to gather that data conversationally.
   • The process dictates the order of operations; the LLM handles the language layer.

3. When the task ends or the user switches topics, the process is released.

In this model, traditional function calling becomes just a special case — a one-step process.

The business value of process calling

This model isn’t just more elegant. It’s more reliable, scalable, and developer-friendly:

• Deterministic execution: Business logic runs the same way every time.
• True modularity: Processes are self-contained and reusable.
• Easy debugging: You’re working with explicit process states, not trying to reverse-engineer LLM outputs.
• Better performance: Up to 80% fewer tokens used and 8x lower latency due to fewer sequential LLM calls.

The only tradeoff? You need to define your core business processes up front. But with modern tools and code generation, that effort pays off quickly — and saves time you’d otherwise spend fixing broken flows and rewriting prompts.

CALM: A new foundation for reliable conversational AI

In 2023, Rasa introduced the CALM architecture (Conversational AI with Language and Memory), with process calling as one of its core pillars. At the time, ReAct agents dominated the conversation — but CALM took a different route, combining LLMs with deterministic business logic.

This hybrid approach doesn’t just make assistants more robust — it also gives LLMs the structure they need to perform better. Rather than guessing what comes next, the model collaborates with a transparent, structured process every step of the way.

Don’t chain tools — build processes

If you’re building AI assistants for real use in production, the difference between atomic tools and structured processes matters. Especially in sectors like banking, retail, or logistics, where accuracy and consistency are non-negotiable.

Use your LLM for what it does best — natural conversation. But let your core logic live in deterministic, stateful processes that ensure your business rules are followed, every time.

You can implement process calling today by building a CALM assistant — through code or using Rasa’s no-code interface.

Let’s build smarter assistants together

At 2Brains, we partner closely with Rasa to bring state-of-the-art conversational AI to companies across Latin America and beyond. Whether you're in financial services, retail, logistics, or customer support, we help you go from concept to production with intelligent assistants tailored to your business.

Want to see how process calling can unlock value for your organization? Reach out to us and let’s explore how to bring this approach into your operations — with structure, clarity, and performance from day one.