Nova-1-0.8B

We are excited to announce Nova-1-0.8B, the first open-release assistant from HyperAI — a fine-tuned Qwen3.5-0.8B specialized for reliable function calling and everyday assistance, distributed as a standalone BF16 checkpoint that loads in stock Transformers with no adapter infrastructure required.

Nova is a compact, production-oriented assistant built for two things that matter in real applications:

1. Masterful function calling — Nova invokes tools in the exact protocol declared in the system prompt, adapting to XML, JSON or plain-text calling conventions at inference time.
2. Exceptional assistant behavior — helpful, polite and concise answers in the user's language (English and Russian verified), while fully preserving the base model's general knowledge.

We trained Nova in-house on a hand-crafted instruction dataset, merged the LoRA weights into the base model, and verified tool-use, latency, and reasoning behavior end-to-end before this release.

Highlights

• Protocol-agnostic tool calling — one model, three verified calling conventions (XML <tool_call>, JSON, plain-text), no format locked in at training time.
• Multi-domain tools — weather, arithmetic, web search, translation, unit & currency conversion, timers, notes and reminders, plus multi-step chains like lookup → compare.
• Clean tool behavior — Nova never hallucinates a call when no tool fits; it answers from knowledge instead of spamming spurious invocations.
• Knowledge preserved, reasoning improved — MMLU-Pro unchanged, +6.7 on GSM8K and +10 on ARC-Easy vs. the base model.
• Tiny & fast — 0.8B params, BF16 ~2 GB, runs on a single consumer GPU or CPU (GGUF quantizations available, down to 0.6 GB).
• Apache-2.0 — free for commercial use, modification, and redistribution.

Function Calling

Nova was trained on a proprietary, hand-crafted instruction dataset developed in-house by HyperAI, specifically designed to teach protocol-agnostic tool invocation — the model adapts to the tool protocol declared at inference time instead of overfitting to a single format. Three protocols are supported and verified:

Protocol	Specification in system prompt	Model output
Native Qwen XML	<tool_call> / <function=name> / <parameter=key> blocks	<tool_call><function=get_weather><parameter=city>Berlin</parameter></function></tool_call>
JSON function calling	reply with {"name": "...", "arguments": {...}}	{"name": "calculator", "arguments": {"expression": "45+12"}}
Plain-text protocol	TOOL <name> | <param>=<value>	TOOL timer | seconds=300

Tool domains covered include weather, arithmetic, web search, translation, unit and currency conversion, timers, notes and reminders, plus multi-step reasoning chains (e.g. lookup → compare). When no tool is available, Nova answers from its own knowledge instead of emitting spurious calls.

Benchmarks

Evaluated with an identical 0-shot protocol (greedy decoding) on both the base model and Nova:

Task	Qwen3.5-0.8B (base)	Nova-1-0.8B
MMLU-Pro (0-shot, letter answer)	10.0%	10.0%
GSM8K (0-shot)	23.3%	30.0%
ARC-Easy (0-shot, letter answer)	66.7%	76.7%

Nova fully preserves general knowledge (MMLU-Pro unchanged) while delivering significant gains in mathematical and scientific reasoning: +6.7 points on GSM8K and +10 points on ARC-Easy over the base model.

Training

• Data: a proprietary instruction dataset developed by HyperAI, comprising assistant and tool-use conversations (multi-turn, EN+RU, four tool protocols, multi-step chains) combined with high-quality general-knowledge samples to ensure robust retention of capabilities
• Method: QLoRA (r=16, alpha=16), 2 epochs, lr 1e-4, BF16, max seq 2048
• Framework: Unsloth, trained on a single NVIDIA RTX 4050 (6 GB VRAM)

Quickstart

from transformers import AutoModelForCausalLM, AutoProcessor

model = AutoModelForCausalLM.from_pretrained(
    "HyperAiCorp/Nova-1-0.8B", torch_dtype="bfloat16", trust_remote_code=True
)
processor = AutoProcessor.from_pretrained("HyperAiCorp/Nova-1-0.8B", trust_remote_code=True)

SYSTEM = (
    "You are a virtual assistant developed by HyperAI. You assist with day-to-day "
    "tasks, are helpful, polite and concise, and respond in the same language as the user."
)

messages = [
    {"role": "system", "content": SYSTEM},
    {"role": "user", "content": "What is the capital of Australia?"},
]

text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = processor(text=text, return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=128)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True))
# The capital of Australia is Canberra.

Function calling (JSON protocol)

messages = [
    {
        "role": "system",
        "content": SYSTEM + "\n\nYou have access to tools: calculator(expression), get_weather(city). "
        'Reply with ONLY a JSON object: {"name": "tool_name", "arguments": {"param": "value"}}.',
    },
    {"role": "user", "content": "What is 45 plus 12?"},
]
# -> {"name": "calculator", "arguments": {"expression": "45+12"}}

GGUF & Ollama

Quantized builds for llama.cpp and Ollama are published in the companion repo HyperAiCorp/Nova-1-0.8B-GGUF (f16, Q8_0, Q4_K_M).

Disabling Thinking Mode

Nova inherits the reasoning backbone of Qwen3.5. In some runtimes the model may emit a visible chain-of-thought block (e.g. Thinking Process: or thinking tags) before answering. That internal monologue slows responses down and — critically — breaks tool-calling, which is why Nova is designed to answer directly.

Important: when using Nova, always disable thinking mode. It degrades the model's tool-use and latency.

How to disable it per runtime:

• llama.cpp (llama-cli / llama-server): add --reasoning off.
• Ollama: create the model with a TEMPLATE that pre-closes the thinking block (an response marker right after thinking) — see the GGUF repo's README for the full Modelfile.
• Transformers: use a system prompt that forbids reasoning and generate with greedy decoding.

Deployment Notes

• Optimized for lightweight assistant deployments and on-device scenarios
• For long generations, streaming with early interruption is recommended for the best user experience
• The vision encoder is inherited from the base model; the checkpoint's training focus is conversational and tool-based interaction

Limitations

• Nova is a 0.8B model — for complex reasoning, code generation, or long-context tasks, larger models remain stronger. Its sweet spot is fast, reliable assistant and tool-calling workloads.
• The tool domains and evaluation were validated primarily in English and Russian.
• As with all language models, Nova may occasionally produce inaccurate or outdated information; validate outputs in high-stakes contexts.

Citation

If you use Nova in your work, please cite it as:

@software{hyperai_nova_1_0_8b,
  title  = {Nova-1-0.8B: A Compact Function-Calling Assistant},
  author = {HyperAI},
  year   = {2026},
  url    = {https://huggingface.co/HyperAiCorp/Nova-1-0.8B},
}

License

This model is released under the Apache-2.0 license, consistent with the base Qwen3.5-0.8B. See LICENSE for details.

About HyperAI

HyperAI develops compact, deployable language assistants and tool-calling models. Nova is the first open release of our assistant line — more sizes and capabilities are on the way. For questions or collaboration, reach us through the community discussions on this model card.