---
license: apache-2.0
language:
  - en
base_model:
  - SmallAICreator/AuroraGPT-700M
pipeline_tag: text-generation
tags:
  - gguf
  - tool-use
  - function-calling
  - small-language-model
  - aurora
  - llama
  - cpu
---

# 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](https://huggingface.co/SmallAICreator/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).

| Tool | Arguments | Use for |
|---|---|---|
| `calculator` | `{"expression": "27*13"}` | exact math — **route math here, don't trust its head** |
| `web_search` | `{"query": "..."}` | current / real-world info |
| `search_knowledge_base` | `{"query": "..."}` | the user's own documents |
| `execute_javascript` | `{"code": "..."}` | run JavaScript |
| `fetch_url` | `{"url": "https://..."}` | read a web page |

## 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.