Nous Hermes 3: an open-weight agentic model

Nearly every AI agent leans on a paid API; Hermes 3 shows that an open model you run yourself can use tools too. It is Nous Research’s family of models fine-tuned on Llama 3.1, designed as a generalist with neutral alignment and solid function-calling skills. In this guide you will see what Hermes 3 is, how it calls tools, how to run it on your own machine with Ollama or vLLM, what its tool-calling format looks like, and how it differs from the base Llama models. The same explanation is available in Spanish.

Key takeaways

• Hermes 3 is Nous Research’s family of open-weight models, fine-tuned on Llama 3.1 in 8B, 70B and 405B sizes (Ollama also offers a 3B variant).
• Its technical report shipped on 15 August 2024 (arXiv 2408.11857) and describes the largest version, Hermes 3 405B, as leading among open models on several public benchmarks.
• It is built to use tools: you define the functions as a JSON schema and the model replies with a call wrapped in tool_call tags, a format Ollama and vLLM understand.
• You run it on your own machine with no paid API: ollama run hermes3 pulls the 8B version (4.7 GB) and serves it with a 128K-token context window.
• It is a good engine for building local AI agents; its successor, Hermes 4, arrived in August 2025, but the 3 line remains a light, stable option.

What is Nous Hermes 3?

Hermes 3 is a generalist language model built by Nous Research, a collective known for its open models and its focus on being uncensored. It is not trained from scratch: it starts from Meta’s Llama 3.1 base weights and applies its own instruction fine-tune, with data centred on reasoning, multi-turn conversation, roleplay and, above all, tool use.

The technical report, authored by Ryan Teknium, Jeffrey Quesnelle and Chen Guang, came out on 15 August 2024. It defines the model as "a neutrally-aligned generalist instruct and tool use model with strong reasoning and creative abilities", and adds that "its largest version, Hermes 3 405B, achieves state of the art performance among open weight models on several public benchmarks". That neutral alignment is key: rather than refusing requests on its own, Hermes 3 obeys the system prompt, which makes it very steerable for agent tasks.

The family ships in three sizes (8B, 70B and 405B), all with a 128K-token context window. The 8B variant is by far the most downloaded: its Hugging Face card sits around 398,000 downloads a month, a sign that many people use it as a local workhorse for its balance of quality and cost.

How does it use tools and call functions?

Tool use is what turns a chat model into the brain of an agent. The mechanics are simple: you describe the functions the model may invoke (name, description and parameters) and it decides when to call them. When it does, it runs nothing itself; it generates structured text that your code interprets, executes the real function and returns the result so the model can keep reasoning.

Hermes 3 was explicitly trained for this loop, which is why it fits well in agent frameworks. The Hugging Face card sums up its performance as "competitive, if not superior, to Llama-3.1 Instruct" from Meta, with 8B metrics such as 61.70 on IFEval (instruction following, 0-shot) and 23.77 on MMLU-PRO (5-shot). For an agent, reliability in emitting a well-formed call matters more than raw knowledge, and there Hermes 3 punches above its size.

The advantage over a closed API is twofold: you do not pay per token and you control the whole model. The trade-off is that you run the infrastructure, which is manageable if you already run models with Ollama on your own machine.

How do you run Hermes 3 on your own machine with Ollama or vLLM?

There are two paths depending on your goal. To try it quickly on a laptop, Ollama is the easiest: it downloads a quantised version and serves it with a single command. It pays to widen the context window, because the default of 4,096 tokens is too small for an agent dragging tools and results into every turn.

ollama run hermes3            # pull and run Hermes 3 8B (4.7 GB)

ollama run hermes3 --parameter num_ctx 32768   # widen the context

For production or to squeeze a GPU, vLLM offers a server with an OpenAI-compatible API and a tool parser specific to the Hermes format. It is the recommended path if you are going to serve the model at high concurrency:

pip install vllm

vllm serve NousResearch/Hermes-3-Llama-3.1-8B \
  --port 8000 \
  --enable-auto-tool-choice \
  --tool-call-parser hermes

The --enable-auto-tool-choice and --tool-call-parser hermes flags are what turn on recognition of tool calls. In Ollama that parser is already enabled for compatible models, so you need no extra flags. You can also serve it with SGLang or llama.cpp (with the --jinja flag), and GGUF quantisations are ready for LM Studio.

What does the Hermes tool-calling format look like?

The "Hermes format" is a concrete convention on top of the ChatML template (turns delimited by <|im_start|> and <|im_end|>). First, in the system message you declare the tools as JSON schemas inside a <tools> tag. When the model decides to use one, it replies with a <tool_call> block containing the name and arguments in JSON. You run the function and return what you got inside a <tool_response> tag. The exchange looks like this:

System:  You are an assistant with tools.
         <tools>[{"name": "get_weather",
         "parameters": {"city": "string"}}]</tools>

User:    What is the weather in Madrid?

Model:   <tool_call>{"name": "get_weather",
         "arguments": {"city": "Madrid"}}</tool_call>

Tool:    <tool_response>{"temp": 22, "sky": "clear"}</tool_response>

Model:   It is 22 degrees and clear in Madrid.

This format matters because the Ollama and vLLM parsers understand it out of the box: you do not parse the text by hand. If you use an agent framework that speaks the OpenAI-style API, function calls are translated into this format transparently, and you get the answer back as an already-structured tool object.

How does it differ from the base Llama models?

Hermes 3 and Llama 3.1 share the same base weights, so the difference is the fine-tune. Meta ships Llama 3.1 Instruct with its own alignment and refusal layer; Nous Research starts from the base weights and applies a neutrally-aligned fine-tune, geared to obey the system prompt and to master its tool-calling format. In practice, Hermes 3 is more steerable and, according to its card, matches or beats Llama 3.1 Instruct on several benchmarks.

The choice depends on the case. If you want a compliant model that follows your instructions to the letter and fits an agent loop, Hermes 3 shines. If you prefer Meta’s out-of-the-box safety guarantees, Llama 3.1 Instruct is the default. Note that in August 2025 Nous released Hermes 4 (14B, 70B and 405B), which adds explicit reasoning with <think> tags; even so, the 3 line stays lighter for pure tool tasks.

Frequently asked questions

Is Hermes 3 free and available for commercial use?

Hermes 3 weights are open and downloaded freely from Hugging Face, but they inherit Meta’s Llama 3.1 community licence, not a fully free licence. That licence permits commercial use with conditions (for example, attribution and a very high monthly-user cap that almost no project reaches). Always review the terms before deploying it in production.

Which size of Hermes 3 do I need?

It depends on your hardware. The 8B version runs on a mid-range GPU or even on CPU with quantisation, and is enough for many tool-using agents. The 70B demands plenty of VRAM but improves reasoning, and the 405B is for serious infrastructure. To get started and prototype, the 8B with Ollama is the sensible option.

Can I use Hermes 3 with agent frameworks like LangChain?

Yes. Because vLLM exposes an OpenAI-compatible API, any framework that speaks that protocol (LangChain, LlamaIndex, the OpenAI Agents SDK via LiteLLM, among others) can point at the local server and use Hermes 3 as its model. You just change the base URL and the model name; tool calls are translated to the Hermes format underneath.

Conclusion

Nous Hermes 3 is one of the most accessible ways to have an agentic model you run and control yourself: it starts from Llama 3.1, adds a very steerable neutral alignment and a tool-calling format that Ollama and vLLM understand with no effort. If you already work with open models, the next step is to pull the 8B version, declare it a couple of tools and build your first agent loop. From there you can scale to 70B or move to Hermes 4 when you need explicit reasoning.

Sources: [1] Hermes 3, the 8B model card on Hugging Face^[1], [2] Hermes 3 technical report on arXiv^[2], [3] Nous Research, releases page^[3], [4] Hermes 3 in the Ollama library^[4].

Sources

1. Hermes 3, the 8B model card on Hugging Face
2. Hermes 3 technical report on arXiv
3. Nous Research, releases page
4. Hermes 3 in the Ollama library

Route: Self-hosted Agentic Models and Tool Calling