license: apache-2.0
language:

• pt
• en
  library_name: transformers
  base_model:
• maritaca-ai/S5-nano

S5-nano-abliterated

this is the abliterated variant of S5-nano(not fully to maintain capabilities)

S5-nano

This repository contains the BF16 version of S5-nano (8.7 GB), with the original, unquantized weights for vLLM and SGLang. The FP8 version reduces the weight size to 5.7 GB and is recommended for GPUs with native FP8 support. The GGUF versions are for llama.cpp and compatible applications, with BF16 (8.7 GB), Q8_0 (4.6 GB), and Q4_K_M (2.8 GB) options.

S5-nano is a 4B-parameter model post-trained by Maritaca AI from
Qwen3.5-4B. It delivers substantial
improvements on Brazilian benchmarks while maintaining strong performance in
function calling, tool use, and structured outputs.

It has two modes:

• Think: reasons before answering (the default mode).
• Instruct: answers directly, without a reasoning step.

The context window supports up to 262,144 tokens, and the weights include an MTP
(multi-token prediction) layer for speculative decoding.

Evaluation results

Explore the results in Observatório Maritaca

Results for the original S5-nano checkpoint, evaluated in BF16 on text tasks.

Averages

Each primary metric is weighted equally.

Results by benchmark

Bold indicates the best result within each group with a documented evaluation protocol, in the same mode. Different groups may produce more than one highlighted result in the same row. † indicates that the model produced reasoning in Instruct mode even though it was disabled in the request.

Think / Thinking

Instruct

Recommended generation parameters

• Select the mode per request with chat_template_kwargs; the same server
  supports both modes.
• For harder problems in Think mode, max_tokens can be increased to 81,920.
• generation_config.json includes the Think-mode values, but not
  presence_penalty. Send the parameters with every request.

Serving with vLLM

vllm serve maritaca-ai/S5-nano \
  --max-model-len 262144 \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice --tool-call-parser qwen3_coder

The server starts at http://localhost:8000/v1 and is compatible with the OpenAI API.
Optional flags:

• --speculative-config '{"method":"mtp","num_speculative_tokens":3}' enables
  speculative decoding with the MTP layer;
• --language-model-only excludes the vision encoder, freeing memory for
  the KV cache;
• --max-model-len 32768 reduces the context length for GPUs with less memory.

For the FP8 version, replace the model name with maritaca-ai/S5-nano-FP8
and keep the same flags.

When serving FP8, also use maritaca-ai/S5-nano-FP8 in the request's
model field (or MODEL in the Python examples).

Requests with curl

Think mode:

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "maritaca-ai/S5-nano",
    "messages": [
      {"role": "user", "content": "Explain why the sky is blue."}
    ],
    "temperature": 1.0,
    "top_p": 0.95,
    "top_k": 20,
    "min_p": 0.0,
    "presence_penalty": 1.5,
    "max_tokens": 32768
  }'

Reasoning is returned in choices[0].message.reasoning, and the final answer
in choices[0].message.content.

Instruct mode:

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "maritaca-ai/S5-nano",
    "messages": [
      {"role": "user", "content": "Write a haiku about the Cerrado."}
    ],
    "temperature": 0.7,
    "top_p": 0.8,
    "top_k": 20,
    "min_p": 0.0,
    "presence_penalty": 1.5,
    "max_tokens": 32768,
    "chat_template_kwargs": {"enable_thinking": false}
  }'

Requests with the OpenAI library

top_k, min_p, and chat_template_kwargs are not part of the OpenAI API;
pass them in extra_body.

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")
MODEL = "maritaca-ai/S5-nano"

THINK = dict(
    temperature=1.0,
    top_p=0.95,
    presence_penalty=1.5,
    max_tokens=32768,
    extra_body={"top_k": 20, "min_p": 0.0},
)
INSTRUCT = dict(
    temperature=0.7,
    top_p=0.8,
    presence_penalty=1.5,
    max_tokens=32768,
    extra_body={
        "top_k": 20,
        "min_p": 0.0,
        "chat_template_kwargs": {"enable_thinking": False},
    },
)

# Think
messages = [{"role": "user", "content": "Explain why the sky is blue."}]
resp = client.chat.completions.create(model=MODEL, messages=messages, **THINK)
msg = resp.choices[0].message
reasoning = getattr(msg, "reasoning", None)
print("reasoning:", reasoning)
print("answer:", msg.content)

# Next turn: pass the reasoning back along with the answer
messages.append({"role": "assistant", "content": msg.content, "reasoning": reasoning})
messages.append({"role": "user", "content": "And why does the sunset look reddish?"})
resp = client.chat.completions.create(model=MODEL, messages=messages, **THINK)
print(resp.choices[0].message.content)

# Instruct
resp = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "Write a haiku about the Cerrado."}],
    **INSTRUCT,
)
print(resp.choices[0].message.content)

The model was trained with reasoning from previous turns retained in the
conversation history. In multi-turn conversations, include the reasoning
field from each assistant response, as shown above.