Aurora-Instruct-Multitool

Aurora-Instruct-Multitool

A 700M-parameter, from-scratch instruction model that calls tools — quantized to Q8_0 GGUF, small enough to run on a phone or a laptop CPU.

It's AuroraGPT-700M taught (via a LoRA, then merged in) to use a calculator, web search, knowledge-base search, a JavaScript runner, and a URL fetcher — with the correct arguments — plus hold multi-turn context and drop the occasional emoji.

Honest scope: this is a tiny, data-limited model. It's good at knowing when and how to reach for a tool, holding a conversation, and staying coherent — not at deep world knowledge. Offload facts and math to the tools. That's the entire point of the design: own the reasoning, rent the facts.

---

What it does

• Calls 5 tools with correct argument shapes (below)
• Holds multi-turn context — resolves references to earlier turns ("he", "there", "that thing")
• Shows restraint — answers simple things directly instead of over-calling tools
• Occasional emojis — sprinkled, not spammed

Tools it knows

The model emits a <tool_call> block. Your app runs the tool and feeds the result back as a <tool_response> — the model does not execute tools itself, so you wire that loop app-side (e.g. parse the JSON, run it, return the result).

Prompt format (Aurora native)

<|system|>{system}<|end|><|user|>{user}<|end|><|assistant|>{assistant}<|end|>

• Special tokens: <|endoftext|>(bos)=0, <pad>=1, <|system|>=2, <|user|>=3, <|assistant|>=4, <|end|>=5
• EOS / EOT = <|end|> (id 5) — set this in your runner, or generation won't stop cleanly
• Tool call: <tool_call>\n{"name": "...", "arguments": {...}}\n</tool_call>
• Tool result (send back as a user turn): <tool_response>\n{...}\n</tool_response>

Declare the available tools (name + arguments) in the system prompt so the model knows what it can reach for.

Example

<|system|>You are AuroraGPT by UltraLabs. Tools you can call:
- calculator: {"expression": "..."}
- web_search: {"query": "..."}
Call a tool when it helps; answer simple things directly.<|end|><|user|>what's 27 times 13?<|end|><|assistant|><tool_call>
{"name": "calculator", "arguments": {"expression": "27*13"}}
</tool_call><|end|><|user|><tool_response>
{"result": 351}
</tool_response><|end|><|assistant|>27 × 13 = 351. ✅<|end|>

Running it

Works in any GGUF runner (llama.cpp and GGUF chat apps). To actually use the tools, the app has to run the tool loop (see above). Files:

• Aurora-Instruct-Multitool-Q8_0.gguf — recommended (~0.75 GB)
• Aurora-Instruct-Multitool-f16.gguf — full precision

How it was made

• Base: AuroraGPT-700M — 707M params, Llama-style (hidden 1536, 27 layers, 12 heads / 2 KV heads, 32k vocab), trained from scratch (~22.4B pretrain tokens + SFT).
• Method: LoRA (r=16, α=32, ≈11.5M trainable / 1.6%) on the plain SFT model, trained on a laptop CPU (Intel i5-1335U), then merged into the base and converted to GGUF.
• Training mix (4,150 examples): 2,000 multi-tool calls (correct arg schemas + result-handling turns) · 900 general multi-turn chat (SmolTalk) · 600 context-referencing conversations · 400 tool-restraint · 250 occasional-emoji.

Limitations (please read)

• It's 700M and data-limited (~22.4B pretrain tokens). World knowledge and reasoning depth are shallow next to frontier models — by design, it rents knowledge via tools rather than memorizing it.
• Don't trust its raw arithmetic — it fumbles digits. The calculator tool exists precisely for this; route math there.
• Tool arguments are most reliable for the five tools above. It generalizes the call format to unseen tools but may guess their arguments.
• Not safety-tuned or production-hardened. This is a hobby / research model.

Identity & credits

Identifies as AuroraGPT, made by UltraLabs. Built and trained by SmallAICreator (aka UltraLabs) — the from-scratch AuroraGPT-700M base plus this multi-tool LoRA + merge, all on a laptop CPU.