Nous Research publishes Arete-27B on Hugging Face with tunable reasoning

Nous Research has published a new model repository, Arete-27B, on Hugging Face under the NousResearch organisation. The most concrete information available so far comes from the repository’s chat template. A chat template is the formatting script that turns a conversation into the exact token sequence the model expects. This one shows three adjustable reasoning-effort levels, a structured tool-calling format, and placeholders for images and video.

Much of what builders usually want to know is not in the text available for this report. That includes the base model, the training method, the licence and any benchmark results. This article covers what the repository text shows, sets it against Nous Research’s earlier releases, and lists what still needs confirmation.

What the Arete-27B repository confirms

The repository sits at NousResearch/Arete-27B on Hugging Face. The “27B” in the name follows the common convention for parameter count, which would point to about 27 billion parameters. The visible repository text does not state the figure directly. It does not name a base model, describe the training data or post-training recipe, show a licence, or report benchmark scores.

The chat template and tokenizer settings carry the hard details:

• Conversations use <|im_start|> and <|im_end|> markers around each role’s turn. The padding token is set to <|endoftext|>.
• A reasoning mode is on by default and can be switched off through an enable_thinking flag.
• A reasoning_effort setting accepts three values: xhigh, medium and low. Any other value triggers an error that names xhigh as the default.
• Tool definitions go into the system turn, and the template specifies a strict format for function calls.
• The template contains handling for image and video content.

Item	What the repository text shows
Location	NousResearch/Arete-27B on Hugging Face
Reasoning effort	xhigh (default), medium, low
Thinking toggle	enable_thinking; on unless set to false
Tool calling	Nested tool_call / function / parameter blocks
Media placeholders	Image and video pad tokens between vision start and end markers
Base model, licence, benchmarks	Not shown in the visible text

How the reasoning-effort setting works

The reasoning controls are the most developer-facing feature in the template. When thinking is enabled and no effort level is passed, the template resolves to xhigh. At that level it adds this instruction to the system turn:

Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.

At low, the injected text reads: “Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.” The medium setting is accepted as valid, but the template adds no extra instruction for it. That suggests medium works as the model’s unprompted baseline, though the repository text does not say so.

The template also handles earlier reasoning in a conversation. Assistant messages can carry a separate reasoning_content field, and a preserve_thinking option is on by default. That points to prior reasoning being kept in context across turns unless a developer turns it off. The visible text is cut off partway through this logic, so the exact rules for which past reasoning is kept are not fully shown.

For builders, this means Arete-27B is set up for a single deployment that can be called at different depths of reasoning, rather than separate “fast” and “thinking” variants. How much latency and token use differ between levels is not stated in the sources.

Tool calling and agent use

When a request includes tools, the template opens a system turn with a “# Tools” header. It lists each function definition as JSON inside <tools> tags. It then tells the model that if it chooses to call a function, it must “ONLY reply in the following format with NO suffix.” That format is a <tool_call> block containing a <function=name> block, with each argument in its own <parameter=name> block. The instructions say required parameters must be specified. Any reasoning about the call may come before it but not after. If no function fits, the model should answer normally without mentioning function calls.

The template also supports multi-step tool use. It scans the conversation backwards to find the last real user query, treating user messages wrapped in <tool_response> tags as tool results rather than new requests. It raises an error if no genuine user query exists and if a system message appears anywhere but the start.

This matters because Nous Research’s most visible product this year is an agent framework. Hermes Agent, released in February 2026, is an open-source, MIT-licensed framework in which agents save successful task solutions as reusable “skills”. By April 2026, Ertas AI reported, it had crossed 103K GitHub stars. The framework calls models through standard OpenAI-compatible endpoints, so it works with many models, not only Nous’s own. Nous has kept adding to it: voice activation with a local wake word in July, a minimal “Blank Slate” setup mode in June, and connectors launched in October, which the launch post said numbered 50+.

No source says Arete-27B was built for Hermes Agent or will be offered through it. A strict, well-defined tool-call format is still what an agent framework needs from its model. One user request on the Hermes Agent GitHub tracker shows the gap that can exist between Nous’s models and its own tooling. In April 2026, a user said Hermes models were missing from the Nous Portal provider’s curated list. Adding them manually seemed to redirect to OpenRouter.

Image and video handling in the template

The chat template contains code paths for images and videos. When a message item is an image, the template inserts <|vision_start|><|image_pad|><|vision_end|>. For a video it inserts the same markers around a <|video_pad|> token. An optional setting labels each item in order as “Picture 1:”, “Video 1:” and so on. System messages are barred from containing images or videos.

The presence of these placeholders shows the template is built to accept image and video inputs in the message format. It does not establish how well the model handles them. The available text gives no description of the model’s supported modalities, no vision benchmarks and no indication of whether a vision encoder ships with the weights. Developers planning image or video workloads should check the full model card and test directly before relying on these paths.

How Arete-27B fits Nous Research’s model history

Nous Research is best known for its Hermes model family. Hermes 4, released on August 30, 2025, came in 14B, 70B and 405B sizes, all derived from Meta’s Llama 3.1 base models. It was trained to switch between direct answers and extended reasoning marked with <think> tags. Its post-training used Nous’s Atropos reinforcement learning framework with about 1,000 task-specific verifiers. Verifiers are automated graders that score outputs for things like factual accuracy and code correctness. Coverage at launch reported a 96.3% score on the MATH-500 benchmark and described the models as operating without content restrictions. Hermes 4’s licence was inherited from Llama 3.1’s community licence, which Ertas AI describes as commercial-permissive with usage caps and attribution requirements.

Arete-27B differs from that line in visible ways. It carries a new name rather than the Hermes brand. Its reasoning control is an explicit three-level setting instead of the model deciding when to think, and its template includes media placeholders. Whether it shares Hermes 4’s neutral-alignment approach, its Atropos training pipeline or a Llama base is not stated in any source. Its size would fall between Hermes 4’s 14B and 70B variants if the name reflects its parameter count.

What it means for builders, and the open questions

For developers, the template already answers some integration questions. Arete-27B expects a ChatML-style conversation format. It needs a custom parser for its XML-like tool calls rather than JSON function-call output. It exposes a per-request reasoning dial that inference servers will need to pass through. Teams that already run Hermes Agent or similar frameworks will want to confirm their tool-call parsing matches the nested <function=...> and <parameter=...> format.

The gaps are large enough that no one should treat Arete-27B as production-ready on the basis of the template alone:

• Licence. No licence is visible in the source text. If the model derives from another base model, the licence may carry that model’s terms, as Hermes 4 did with Llama 3.1.
• Base model and training. Nothing in the available text names a base model or describes training data or methods.
• Benchmarks. No source reports any Arete-27B scores, from Nous Research or independent testers.
• Safety behaviour. Hermes 4 was positioned around minimal refusal training. Whether Arete-27B follows that approach is unknown.
• Hosted access. The sources do not say whether Arete-27B is offered through the Nous Portal or any hosted API.

What to watch next

The next useful signals are a full model card or technical write-up from Nous Research covering base model, training and licence. Independent benchmark results from third-party leaderboards would show how a 27B model with tunable reasoning compares with other recent open releases, such as the models covered in Unicorn API’s report on Thinking Machines’ Inkling 2 Small. Hands-on reports on the image and video paths will show whether those template features reflect real capability. Developers should also watch whether Nous wires Arete-27B into Hermes Agent and the Nous Portal, which would make it the default model for the company’s own agent stack.