A 707M-parameter reasoning model, full-SFT'd from the AuroraGPT-700M base to think natively in <think>...</think> and call a web_search tool — small enough to run on a phone.

This is not a LoRA patch — reasoning is baked into the weights via a full fine-tune from the base model, on ~150M tokens of a custom + premade reasoning mix (with 120k web-search tool-call examples).

What it does

Reasons out loud. Every answer starts with a <think>...</think> block where it works the problem step by step, then gives the answer.

Searches the web. When a question needs current/live/specific info it isn't sure of, it emits a Hermes-style tool call instead of guessing:

<think>
The weather in Tokyo changes every day and I have no live data, so I can't answer from
memory. I should search the web for the current forecast.
</think>
<tool_call>
{"name": "web_search", "arguments": {"query": "Tokyo weather today"}}
</tool_call>

Knows when not to search. For things it can work out itself (math, logic), it just reasons and answers — no needless tool calls.

Prompt format

Native AuroraGPT format (ChatML-equivalent), which supports system prompts:

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

Special tokens: <|endoftext|>=0 (bos), <|pad|>=1, <|system|>=2, <|user|>=3, <|assistant|>=4, <|end|>=5 (eos).

The model then generates: <think>\n{reasoning}\n</think>\n{answer or tool call}<|end|>

web_search tool

Schema (matches the LM Playground / llama.cpp web_search tool):

json

{"name": "web_search",
 "parameters": {"type": "object",
   "properties": {
     "query": {"type": "string"},
     "max_results": {"type": "integer", "description": "default 5, max 10"}},
   "required": ["query"]}}

Tool results come back as a user turn wrapping <tool_response>{...}</tool_response> (the Qwen3/Hermes convention), and the model then answers grounded in those results.

Using web search in LM Playground

Load the GGUF in LM Playground.
Settings → Tools → enable web_search (tools are off by default).
Reasoning <think> blocks render; when a query warrants it, the model fires the search and answers from live results.

Note: reliable tool firing is genuinely hard at 700M — the model searches when it decides to, not every time (this is expected for small models). Tool-call emission is verified; end-to-end execution depends on the app enabling the web_search tool and on the chat template being recognized as tool-capable (chat_template_tools.jinja is provided for that).

Files

model.safetensors + config/tokenizer — the fp32 model (loadable in 🤗 transformers)
aurora-reason-Q8_0.gguf — Q8_0 quant (~805 MB), for phones / llama.cpp / LM Playground
chat_template_tools.jinja — a Hermes-style template (aurora delimiters) for enabling tool-call parsing in llama.cpp-based apps

Training

Method: full SFT from AuroraGPT-700M base (not LoRA)
Data: ~150M-token mix — custom correct-by-construction reasoning (math/logic traces computed in Python so they're always right), Orca-Math, GSM8K, OpenR1-Math (filtered), SmolTalk rehearsal, + 120k web_search tool-call examples
Run: 1 epoch on a focused 70k-example subset, 2×T4, adafactor, loss 2.11 → 0.68

Honest limitations

It's 700M. It follows the right method but will fumble multi-digit arithmetic and miss obscure facts. Reasoning routes around some of this, but it's not a jump in raw knowledge over the base — same pretraining, same facts.
Tool-calling reliability is size-limited (see note above).

Built by SmallAICreator.

SmallAICreator/AuroraGPT-700M-Reason

AuroraGPT-700M-Reason