Tool-calling agent on the free Nemotron 3.5 Super VL

Short answer: the model card lists tool calling and the row is free

On the free row of Nemotron 3.5 Super VL the model card lists tool calling, so you can build an agent loop with the model id nvidia/nemotron-3.5-super-vl-free and try it with your own tools. LLMTR (llmtr.com) is a gateway that gives access to language models from different providers through one OpenAI-compatible API; requests go to the /v1/chat/completions endpoint at https://llmtr.com/v1. The price is $0.00 per 1M input and output tokens, no credit is deducted, and use is limited by a daily quota.

NVIDIA presents the model as one built for agent workflows that combines reasoning, instruction following and tool use with visual understanding. NVIDIA's model card also includes an example flow in which the model requests a tool call and the application runs the tool and returns the result. This article covers a multi-turn loop with the OpenAI Python SDK, the settings that matter in the loop and what to do on responses such as 429.

• NVIDIA, Nemotron 3.5 Super VL technical blog · 2026-10-17
• NVIDIA, Nemotron 3.5 Super VL model card (Hugging Face) · 2026-10-17

How do you build a tool-calling agent on the free Nemotron 3.5 Super VL?

The basic agent loop works like this: you send the model the conversation and the definitions of the tools it may use. If the model decides to call a tool, message.tool_calls in the response is filled; each call carries the tool name and its arguments as JSON. You run the tool in your own code, append the assistant message that holds the tool call and a tool message that carries the result to the history, and send the next request. The loop ends when the model returns a response that asks for no tool.

The example has one tool: get_weather(city). Instead of a real weather service, a local stub returns a fixed result; to wire in your own tool you only replace that function. The tool_call_id in the tool message must match the call id the model returned. On turns with a tool call, content can come back empty; the example appends the assistant message to the history with whatever content arrived. The loop runs for at most five turns, and max_tokens is 4096 because reasoning tokens count toward that limit too.

In an existing OpenAI client three things change: base_url becomes https://llmtr.com/v1, api_key takes your LLMTR key and the model string becomes nvidia/nemotron-3.5-super-vl-free. The SDK sends the key in the Authorization: Bearer header.

A loop with the OpenAI Python SDK that defines the get_weather tool, answers a tool call with a local function when the model makes one, and prints the final answer within five turns.

import json
import os

from openai import OpenAI

client = OpenAI(base_url="https://llmtr.com/v1", api_key=os.environ["LLMTR_API_KEY"])
MODEL = "nvidia/nemotron-3.5-super-vl-free"
MAX_TURNS = 5

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get the current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]


def get_weather(city):
    # Local stub: replace it with a real weather lookup.
    return {"city": city, "temperature_c": 18, "condition": "light rain"}


messages = [{"role": "user", "content": "Do I need an umbrella in Istanbul today?"}]

for turn in range(MAX_TURNS):
    response = client.chat.completions.create(
        model=MODEL,
        messages=messages,
        tools=tools,
        max_tokens=4096,
    )
    message = response.choices[0].message
    if not message.tool_calls:
        # No tool requested: this is the final answer.
        print(message.content)
        break
    # Keep the assistant turn that asked for the tools in the history.
    messages.append({
        "role": "assistant",
        "content": message.content,
        "tool_calls": [call.model_dump() for call in message.tool_calls],
    })
    for call in message.tool_calls:
        try:
            args = json.loads(call.function.arguments)
            result = get_weather(args["city"])
        except (json.JSONDecodeError, KeyError) as err:
            # Hand the problem back to the model instead of crashing.
            result = {"error": f"bad arguments: {err}"}
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })
else:
    print("Stopped after", MAX_TURNS, "turns without a final answer.")

Settings that matter in the agent loop

The context window is 1,000,000 tokens; long tool outputs and a growing message history have to fit in it. The whole history is sent again on every turn, so pass tool outputs to the model with only the fields it needs: instead of a thousand-line API response, a few fields that the decision depends on are enough. Reasoning is on by default, and the trace comes back separately from the answer in message.reasoning_content. Reasoning tokens count toward max_tokens, so 4096 or more is a good starting point on turns where the model picks a tool. If a response comes back with finish_reason: length, raise max_tokens and send the request again.

On a short turn that needs no tool choice you can switch reasoning off with reasoning: false or with the :fast suffix on the model id. reasoning_effort is not supported on this row; a request that sends it returns HTTP 400 invalid_request. The model card also lists JSON object mode and JSON Schema output: if you want the agent's final answer to follow a schema, use response_format.

Making the loop robust

Do not assume how many tool calls a turn will bring. tool_calls can be empty, hold one element or hold several; your code should handle all three and append a separate tool message for each call. Parse the arguments as JSON before running anything and check that the fields you expect are there. In the example an argument that cannot be parsed does not stop the program; the error goes back to the model as a tool message, and the model can make a corrected call.

Limit the number of turns. The loop grows as long as the model keeps calling tools; stopping after five turns, as the example does, and returning what you have so far prevents an endless loop and keeps one task from using up the daily allowance.

HTTP 429 means one of the free usage limits has been reached; that limit can be daily or per minute, and the response carries a Retry-After header. Your agent should wait for the time in that header and send the request again with the same history. HTTP 400, on the other hand, says something is wrong with the request itself; fix the field named in the error message instead of repeating the same request. On 500, 502, 503 and 504 you can retry a few times with growing intervals; the error codes page lists these as retryable responses.

Using agent frameworks, and the data notice

Any framework that accepts an OpenAI-compatible base_url, an api_key and a model string connects the same way: https://llmtr.com/v1 as the base_url, your LLMTR key as the api_key and nvidia/nemotron-3.5-super-vl-free as the model. Tool definitions and the loop run through the framework's own mechanism, and requests still go to the /v1/chat/completions endpoint. If the framework sends reasoning_effort, turn that field off; switch a client that uses the Responses API to Chat Completions mode.

According to the model card's data notice, the text, images and videos you send may be logged by the provider and may be used to improve the model; do not send sensitive, personal or customer data to this row. In an agent, what reaches the model is not only the user's message: tool results go to the model as tool messages too. Before you connect a tool that returns records from a database or an internal system to this row, look at what its results contain. And before going to production, run an end-to-end scenario with your own tool schemas and see what the model returns.

Build a tool-calling agent on the free Nemotron 3.5 Super VL

Create an API key, define your tools and run a turn-limited loop with nvidia/nemotron-3.5-super-vl-free on https://llmtr.com/v1.

1. API key. Create an account at llmtr.com, create a key under Dashboard > API Keys and store it in the LLMTR_API_KEY environment variable.
2. Define the tools. Write each tool as an OpenAI-format function definition: a name, a description and the parameters as a JSON schema. Implement the tool itself as a function in your own code.
3. Run the loop. Send the request with tools; when tool_calls arrive, run the tool, append the result as a tool message with its tool_call_id, and continue until a response asks for no tool or the turn limit is reached. On 429, wait for Retry-After.

Frequently asked questions

Does the free Nemotron 3.5 Super VL support tool calling?

The model card lists tool calling. You send the tools field in the OpenAI format; if the model calls a tool, the calls come back in message.tool_calls. Try it with your own tools before going to production.

Is running an agent on this model free?

On the nvidia/nemotron-3.5-super-vl-free row the price is $0.00 per 1M input and output tokens, and no credit is deducted. Use is limited by a daily quota; at the limit the API returns HTTP 429 with a Retry-After header.

What max_tokens should an agent loop use?

Reasoning is on by default and reasoning tokens count toward max_tokens; 4096 is a good starting point on turns where a tool is picked. If finish_reason is length, raise the value and send the request again.

Related posts

• Free Nemotron 3.5 Super VL API: image and video input
• Nemotron 3.5 Super VL: free vs paid row
• Models added to LLMTR in October 2026: facts and guide

• Nemotron 3.5 Super VL (Free) model
• Tool calling documentation
• Nemotron 3.5 Super VL documentation
• Errors documentation