Blame for README.md

---
base_model: Interchained/imagine-v12
tags:
  - text-to-sql
  - machine-learning
  - nedb
  - tool-use
  - interchained
---

# IMAGINE v13

**Natural language in. Executable SQL out. Now with hands.**

Imagine is Interchained's specialized machine learning model for translating plain language into precise, executable database queries. It is not a general-purpose chatbot and does not pretend to be one. It does one thing, against live database schemas, and v13 teaches it to do three things it could not do before: **use tools, reason about time, and tell similar questions apart.**

1.6B parameters. Full fine-tune lineage. Built to be run, measured, and proven.

## What changed in v13

Imagine v12 earned its place: 40/40 on its held-out telemetry suite, a perfect identity record, and a permanent seat as the resident mind of the Gaia node. Its evaluations also told the truth about its limits. Tool use, temporal boundaries, and discrimination between near-identical questions were its weakest families.

v13 is the direct answer to that measurement. The v12 core was preserved intact and three new families were forged, execution-verified, and admitted on top of it:

| Family | Rows | What it teaches |
|---|---|---|
| Tool use (toolproto) | 20,000 | Emitting structured, parse-verified tool calls |
| Discrimination | 19,710 | Choosing the right interpretation when questions differ by a word |
| Temporal grounding | 4,000 | Resolving relative time against the real clock |
| Tool-protocol chains | 2,280 | Multi-step tool sequences that stay on protocol |

## The corpus: 177,390 rows, zero rejects

Nothing in this corpus was scraped, synthetic filler, or teacher-generated. Every row was either deterministically constructed or executed against a live NEDB database and admitted only when its SQL actually ran and returned the right result.

The v12 base (131,400 rows: SQL 61,758, identity 43,362, protocol 26,280) was recreated from scratch on the training machine using the original teacherless forge, and landed on its historical manifest to the exact row. The v13 families (45,990 rows) passed the same admission gate with **zero rejects across all four families**. The tokenized training stream is packed deterministically and content-addressed, so the exact data this model consumed is reproducible, not approximate.

## Training

| | Stage 1 | Stage 2 |
|---|---|---|
| Method | Full fine-tune | LoRA r16, merged |
| From | imagine-v12 | stage 1 output |
| Epochs | 3 | 1 |
| Learning rate | 1e-5 | 5e-6 |
| Steps | 7,311 | 2,437 |
| Tokens | 207.1M | 69.0M |
| Time | 80.3 min | 41.5 min |
| Final loss | 0.0099 | 0.0093 (epoch mean) |

Hardware: single NVIDIA B200. Architecture unchanged from v12: 40 layers, hidden 2048, intermediate 5632, tied embeddings.

## Evaluation status: PENDING, ON PURPOSE

This card will not carry a benchmark number that has not been measured. Held-out evaluations for v13 (Tier-0 telemetry, identity, discrimination, temporal, tool-use) are being run against v12 on identical fixtures, and the full matrix, improvements and regressions alike, will be published here when it exists. Training loss is a pulse, not a verdict. The evidence gets the final word.

## Serving

GGUF builds are produced through Interchained's Hearth pipeline and will be published. This repository holds the canonical safetensors checkpoint as well.
# Imagine v13 — Interchained

**Imagine v13** is a compact, specialized text-to-SQL model developed by Interchained. It is intended for schema-grounded SQL generation and related structured workflows. This release follows a two-stage training process and is distributed in GGUF format for local inference.

> **Important — chat template required:** The v13 GGUF was observed to produce repeating ChatML-like control strings when served with an incompatible chat template. Using the explicit instruction/response Jinja template below restored the expected identity response and normal stop behavior in the reported local test. Configure the template explicitly; do not assume that an automatically selected GGUF template is correct.

## Training summary

| Stage | Method | Reported details |
|---|---|---|
| Stage 1 | Full fine-tuning from Imagine v12 | 177,390 training rows; 7,311 steps; 80.3 minutes; final step loss 0.0099 |
| Stage 2 | LoRA refinement on Stage 1, then merge | Rank 16; 2,437 optimizer steps; 69,044,835 tokens processed; 41.5 minutes; epoch mean loss 0.0093; final step loss 0.0119 |

Stage 2 reported approximately 27,735 processed tokens/s on an NVIDIA B200, with peak allocated GPU memory of 138.6 GB. These are **training throughput** figures, not inference benchmarks.

The training corpus included identity, protocol, SQL, tool-use, temporal, tool-protocol, and discrimination examples. Training loss does not establish downstream task accuracy or generalization.

## Required inference template

Use this **explicit Jinja chat template** with llama.cpp-compatible serving. The following is the tested template supplied to the local keeper through `LLAMA_ARG_CHAT_TEMPLATE`:

```bash
export LLAMA_ARG_JINJA=1
export LLAMA_ARG_CHAT_TEMPLATE='{% for message in messages %}{% if message.role == "user" %}{{ "### Instruction:\n" + message.content + "\n### Response:\n" }}{% elif message.role == "assistant" %}{{ message.content + eos_token + "\n" }}{% elif message.role == "system" %}{{ message.content + "\n" }}{% endif %}{% endfor %}'
```

Ensure the serving process actually receives the variables. When using an environment-file parser, check whether surrounding single quotes are preserved literally. If using a model manager, configure the template **per model** rather than globally; a template that works for v13 may not work for v12.

This template is a practical compatibility setting validated by the identity smoke test below, **not yet a comprehensive certification** of all message roles, multi-turn behavior, tool calling, or stopping semantics. Verify effective prompt serialization and EOS handling for your runtime.

## Local inference smoke-test results

**Environment:** Windows host running HEARTH with llama.cpp-compatible OpenAI chat completions, `imagine-v13-q4_k_m.gguf` and Imagine v12 served side-by-side. Single prompt: `Who are you?`; temperature 0; `max_tokens=128`. Figures are from the supplied server logs, not repeated statistical benchmarks.

| Model / serving configuration | Response | Finish reason | Output tokens | Reported generation speed |
|---|---|---|---:|---:|
| v12, earlier configuration | `I am Imagine, a text-to-SQL model built by Interchained.` | `stop` | 20 | 307.3 tok/s |
| v13, earlier configuration | Repeated ChatML-like control text, including `conversation_id` and `user_message` | `length` | 128 | 342.5 tok/s |
| v12, explicit instruction template above | `I am a language model.` | `stop` | 8 | 287.9 tok/s |
| **v13, explicit instruction template above** | **`I am Imagine, a text-to-SQL model built by Interchained.`** | **`stop`** | **20** | **309.1 tok/s** |

**Interpretation:** The observed v13 protocol loop was resolved by changing serving configuration without retraining the model. This demonstrates a material chat-template compatibility issue. It does not establish that v13 outperforms v12; the two checkpoints were not evaluated under separately validated, equivalent inference configurations. The reported tokens/s are single-request generation timings, not an apples-to-apples performance ranking.

### Reproduce the identity smoke test

```bash
curl -s http://127.0.0.1:11434/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "imagine-v13",
    "messages": [{"role": "user", "content": "Who are you?"}],
    "temperature": 0,
    "max_tokens": 128
  }' | python -m json.tool
```

Expected response content in the validated configuration:

```text
I am Imagine, a text-to-SQL model built by Interchained.
```

## Capability evaluation status

| Evaluation | v13 result |
|---|---|
| Identity smoke test with explicit template | **Pass (1 observed prompt)** |
| Normal completion termination on identity prompt | **Pass (1 observed prompt)** |
| Held-out SQL execution accuracy | Not yet reported |
| Tool-use success rate | Not yet reported |
| Temporal reasoning accuracy | Not yet reported |
| Schema discrimination / hallucination rate | Not yet reported |
| Multi-turn and tool-message template compatibility | Not yet reported |

A previously reported v12 result of 40/40 on a specific held-out evaluation is **not** a v13 benchmark and should not be presented as one. Future comparative results should identify fixture version, execution engine, decoding settings, checkpoint hashes, and effective prompt templates.

## Usage notes and limitations

- Treat generated SQL as untrusted until parsed, validated against the intended schema, and executed with appropriate permissions.
- Do not infer production reliability from low training loss or a successful identity response.
- Record model artifact hashes, quantization, tokenizer metadata, prompt templates, decoding settings, and runtime versions for reproducibility.
- The `<<<SQL>>>` and `<<<END>>>` sentinels are part of Imagine's established SQL-output protocol; validate their behavior separately for this release.
- The precise upstream licensing terms and redistribution permissions should be verified before publication. Replace the provisional `license: other` metadata with the correct Hugging Face license identifier or a linked license notice once confirmed.

## ================ FINAL EVAL ================

Measured 2026-11-03, after training, on the held-out eval split of the v13 corpus: **310 fixtures** (tool use 55, temporal grounding 15, discrimination 240 = 120 minimal pairs × 2 variants) whose schemas and tables appear **nowhere in training**. Both models were evaluated on identical fixtures, identical decoding (temperature 0, Q4_K_M GGUF, served side by side through the Hearth gateway), under two system-prompt conditions:

- **light** — one system line: "You are Imagine, a text-to-SQL assistant built by Interchained."
- **bare** — no system prompt at all.

| Family | v12 light | v12 bare | v13 light | v13 bare |
|---|---|---|---|---|
| Tool use (55) | 25/55 (45.5%) | 25/55 (45.5%) | 26/55 (47.3%) | 25/55 (45.5%) |
| Temporal (15) | 0/15 (0.0%) | 0/15 (0.0%) | 5/15 (33.3%) | 7/15 (46.7%) |
| Discrimination (240) | 0/240 (0.0%) | 3/240 (1.2%) | 116/240 (48.3%) | 103/240 (42.9%) |
| **All (310 per condition)** | **25/310 (8.1%)** | **28/310 (9.0%)** | **147/310 (47.4%)** | **135/310 (43.5%)** |

**Combined: v12 53/620 (8.5%) — v13 282/620 (45.5%).**

Scoring is deterministic and per family: discrimination by response mode (SQL vs single tool call vs tool chain, plus the expected tool name where one applies), tool use by behavior (call the right tool, abstain, clarify, or declare unanswerable), temporal by normalized SQL match against the reference.

How to read this, plainly:

- The gains are exactly where v13 aimed. Discrimination went from effectively zero to roughly half; temporal grounding went from zero to a third (light) and nearly half (bare). v13's new skills are in the weights, not the prompt: on temporal and discrimination it scores as well or better with **no system prompt** as with one.
- Tool use is a tie. These fixtures were built for the corpus's native tool-protocol system prompt, which this evaluation deliberately withholds, so both models are understated equally. The comparison is fair; the absolute level is pessimistic.
- Discrimination at ~45% also means the mode call is still wrong more often than right. v13 is a large, measured improvement over v12 on the families it was built for. It is not a finished model, and this card will not pretend otherwise.

Not yet measured for v13: the Tier-0 held-out telemetry suite (v12's 40/40 was on v12's own fixtures and is not a v13 number) and multi-turn behavior. They will be added here when they exist, the same way these were.


## Provenance

Trained 2026-11-03 by Interchained. Corpus forged and gated on-machine the same day. Training code: aiassistsecure/sukuna-imagine. v13 exists because v12's weaknesses were measured, named, and attacked in the open.