Every function calling setup demands schema definition, input/output handling, and orchestration of repeated invocations until a valid termination condition is met.

While this level of control can be necessary in specific scenarios, the underlying pattern tends to repeat. Across teams and workflows, the same scaffolding is rebuilt, resulting in duplicated effort, slower iteration, and increased maintenance overhead.

While we still support manual function calling for full control, many customers have asked for an out-of-the-box solution to standardize tool use without the overhead.

Introducing the Tool Calling Node: faster, cleaner way to handle function calling in Vellum Workflows.

You can now streamline function calls with automatic handling of OpenAPI schemas, loop logic, and function call output parsing.

Key capabilities

The Tool Calling Node provides several advantages over manual function calling implementation:

• Automatic Schema Generation: No need to manually define OpenAPI schemas for your tools
• Built-in Loop Logic: Automatically handles the iterative calling pattern until a text response is received
• Output Parsing: Automatically parses function call outputs without manual intervention
• Multiple Tool Support: Configure multiple tools within a single node

By GA’ing the Tool Calling Node we’ve handled the common orchestration logic around it in a first-class way. Now, your engineers no longer have to rebuild the same patterns, and non-technical teams can reuse pre-built tools out of the box.

How it works

The Tool Calling Node follows this execution logic:

1. Initial Prompt: The configured prompt is sent to the selected model with the available tools
2. Tool Decision: The model decides whether to call a tool or provide a text response
3. Tool Execution: If a tool is called, the node executes the appropriate tool type
4. Result Integration: The tool result is added to the chat history
5. Iteration: Steps 2-4 repeat until the model provides a final text response
6. Output: Both the complete chat history and final text response are made available to downstream nodes.

Debugging the Tool Calling Node

One of the supported outputs for this node is chat history. This output contains the accumulated list of messages that the Prompt managed during execution. This includes all user, assistant, function call and function result messages.

While this output is helpful in maintaining conversation context in multi-turn conversations, it’s highly effective in debugging the tool calling sequence as you build.

In production, however, you’re able to utilize our Tracing view, and analyze all execution details of the Tool Calling Node:

Type of tools that can be invoked

The Tool Calling Node supports three types of tools, each designed to support different parts of your workflow logic. All tool types benefit from automatic schema generation and tight integration with the LLM's reasoning loop.

Recommended usage

While there are many resources out there on how to best prompt these tools, and how to optimize the performance when you want the prompt to use multiple tools, we wanted to highlight a bit more specific set of best practices that could help you get started faster.

What’s next

We have a lot planned for this node. We know how important it is to debug the inner workings of an abstracted component, so we’re prioritizing more granular debugging support. You'll be able to inspect each intermediate step the tool takes under the hood to understand how it's working.

We're also planning to build a tool directory, starting with support for shared Vellum tools.

We’re excited to keep building, and can’t wait to see what you do with it.

Read the full documentation here: Tool Calling Node Docs.