Instructions to use SmallAICreator/Aurora-Instruct-Multitool with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Notebooks
Google Colab
Kaggle
Local Apps Settings

How to use SmallAICreator/Aurora-Instruct-Multitool with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0
# Run inference directly in the terminal:
llama cli -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0
# Run inference directly in the terminal:
llama cli -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0
# Run inference directly in the terminal:
./llama-cli -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0
# Run inference directly in the terminal:
./build/bin/llama-cli -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Use Docker

docker model run hf.co/SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Llama new
LM Studio
Jan

vLLM

How to use SmallAICreator/Aurora-Instruct-Multitool with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "SmallAICreator/Aurora-Instruct-Multitool"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "SmallAICreator/Aurora-Instruct-Multitool",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Ollama
How to use SmallAICreator/Aurora-Instruct-Multitool with Ollama:
```
ollama run hf.co/SmallAICreator/Aurora-Instruct-Multitool:Q8_0
```
Unsloth Desktop

How to use SmallAICreator/Aurora-Instruct-Multitool with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Configure the model in Pi

# Install Pi:
npm install -g @earendil-works/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "SmallAICreator/Aurora-Instruct-Multitool:Q8_0"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use SmallAICreator/Aurora-Instruct-Multitool with Docker Model Runner:
```
docker model run hf.co/SmallAICreator/Aurora-Instruct-Multitool:Q8_0
```

Lemonade

How to use SmallAICreator/Aurora-Instruct-Multitool with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Run and chat with the model

lemonade run user.Aurora-Instruct-Multitool-Q8_0

List all available models

lemonade list

Hermes Agent

How to use SmallAICreator/Aurora-Instruct-Multitool with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use SmallAICreator/Aurora-Instruct-Multitool with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf SmallAICreator/Aurora-Instruct-Multitool:Q8_0

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "SmallAICreator/Aurora-Instruct-Multitool:Q8_0" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

Aurora-Instruct-Multitool / README.md

SmallAICreator

Add model card

a04d062 verified 2 months ago

preview code

Raw History Blame Contribute Delete

4.83 kB

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

	---
	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": "2713"}` \| 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.