Hermes Function Calling

What is Hermes Function Calling?

Hermes Function Calling is Nous Research's prompt standard for teaching a model how to use tools with structured XML tags and JSON payloads. It places available tool schemas in and tool invocations in blocks, so the model can emit machine-readable actions instead of free-form text. (hermes-agent.nousresearch.com)

Understanding Hermes Function Calling

In practice, Hermes Function Calling is a formatting convention for tool use. The model is shown a list of tools, each with a JSON schema, then asked to return a single JSON object naming the tool and its arguments inside tags. That makes parsing straightforward for orchestration code and helps keep the model's action selection aligned with the schema. (hermes-agent.nousresearch.com)

This approach is useful when you want an LLM to choose among functions, pass structured arguments, and resume the conversation after a tool response. The Hermes docs and repository show examples for recursive function calling, JSON mode, and schema validation, which makes the pattern practical for agents, assistants, and workflow automations. (github.com)

Key aspects of Hermes Function Calling include:

1. Tool schema block: Available tools are presented in a section so the model can inspect names, descriptions, and parameters.
2. Structured call output: The model returns a JSON object with a function name and arguments inside tags.
3. Parser-friendly format: XML wrappers and JSON payloads make tool calls easy to extract in downstream code.
4. Schema alignment: The prompt encourages arguments that match the declared JSON schema, reducing formatting drift.
5. Agent compatibility: The format fits recursive tool use, where the system can execute a tool and feed the result back to the model.

Advantages of Hermes Function Calling

1. Clear machine parsing: The tool call is wrapped and structured, which simplifies automation.
2. Better control: The schema tells the model what arguments are valid before it acts.
3. Reusable prompt pattern: Teams can apply the same format across many tools.
4. Fits agent loops: The format works well with iterative tool execution and follow-up reasoning.
5. Portable across stacks: The pattern can be adapted to different backends and orchestration layers.

Challenges in Hermes Function Calling

1. Strict formatting: Small tag or JSON mistakes can break parsing.
2. Prompt sensitivity: Tool selection can change if the schema or examples are rewritten.
3. Validation overhead: Teams still need code to verify arguments and handle errors.
4. Multi-step complexity: Recursive tool use adds state management and retries.
5. Template dependence: The format works best when the serving stack matches the expected chat template.

Example of Hermes Function Calling in Action

Scenario: a user asks an assistant to look up a stock price and summarize it.

The system prompt provides a block with a market-data function, then asks the model to respond with a object. The model emits a call like {"name":"get_stock_price","arguments":{"symbol":"TSLA"}} inside , your app runs the API request, and the result is passed back to the model for a final answer.

That workflow is especially helpful when you want the model to decide when to act, but still keep execution deterministic in your application code. In PromptLayer, you can log the prompt, inspect the tool call, and compare how different prompt versions affect tool choice and argument quality.

How PromptLayer helps with Hermes Function Calling

PromptLayer gives teams a place to version prompts, inspect tool-call traces, and evaluate whether Hermes-style formatting is producing the right arguments at the right time. That makes it easier to iterate on tool schemas, prompts, and agent workflows without losing visibility.

Ready to try it yourself? Sign up for PromptLayer and start managing your prompts in minutes.