Instructions to use oot-ai/oot-oneliner-lora with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- PEFT
How to use oot-ai/oot-oneliner-lora with PEFT:
from peft import PeftModel from transformers import AutoModelForCausalLM base_model = AutoModelForCausalLM.from_pretrained("LiquidAI/LFM3-1.7B-Base") model = PeftModel.from_pretrained(base_model, "oot-ai/oot-oneliner-lora") - Notebooks
- Google Colab
- Kaggle
oot-oneliner (LoRA adapter)
OOT (Only One Task) model: writes a one-line summary of any input. The input type decides the style:
| Input type | Output |
|---|---|
| Chat message or short conversation | Title: 3β7 words, sentence case, same language as the user |
| Bash / shell command | Intent: 5β10 words, English, verb-first, present tense |
| SQL query | Intent |
| File edit (unified diff, Write/Edit tool call) | Intent |
| Tool / function call (JSON) | Intent |
Output is plain text on one line, with no quotes, prefix, trailing period, markdown or reasoning. Destructive actions are trained to state their destructive effect explicitly.
This repo is the LoRA adapter, the canonical OOT artifact. Every OOT task is an adapter on the same unmodified base, so one server can host all of them. Other formats: merged bf16 Β· GGUF.
Where it fits best
1. Conversation titles at scale. Chat apps create millions of new sessions every day, and most of them get their title from a call to the same large model that answers the user. That spends frontier-model tokens, latency and GPU time on a 5-word string. A title is a small, closed task: read the first message and name the topic, in the user's language. oot-oneliner does it on a 1.7B base, on CPU if needed, and keeps to the format: on a 100-case arena, 100% of its outputs follow the output contract, against 78% for Claude Haiku 5.5 and 55% for Claude Sonnet 5.5 prompted with the same contract (see Evaluation).
2. Intents for every agent action, without asking the agent. Agent harnesses often make the main model write a human-readable description next to each tool call so the user can follow along or approve the step. The large model pays for those tokens on every step, and the description says what the agent meant to do, not always what the command does. Instead, drop that field and send the action itself (shell command, SQL, diff or JSON tool call) to oot-oneliner:
- Cheaper agent turns: the main model emits only the action.
- Independent of the agent: the intent is derived from the action, so it can be used to log steps, review them, or gate approvals.
- Destructive effects stated: in our own agent traces, only 41% of agent-written descriptions of destructive commands mentioned the destruction. oot-oneliner states the destructive effect in 99.0% of a 399-case held-out destructive slice.
Examples
Real outputs (Q8_0 GGUF, temperature 0, canonical format):
| Input | Output |
|---|---|
My Docker build keeps reinstalling all npm packages even when package.json didn't change |
Docker reinstalling npm packages unnecessarily |
Comment configurer un reverse proxy nginx pour plusieurs sous-domaines ? |
Reverse proxy nginx pour plusieurs sous-domaines |
rm -rf build/ |
Deletes the build directory and its contents |
git reset --hard HEAD~3 && git push --force origin main |
Hard-resets to three commits back and force-pushes main |
SELECT customer_id, COUNT(*) FROM orders WHERE year = 2025 GROUP BY 1 |
Counts orders per customer for 2025 |
DELETE FROM sessions |
Deletes every row from the sessions table |
diff config/loader.py: -TIMEOUT = 5 / +TIMEOUT = 30 |
Increases loader.py TIMEOUT from 5 to 30 |
{"name": "get_weather", "arguments": {"city": "Paris"}} |
Gets weather information for Paris |
{"name": "send_invoice", "arguments": {"customer_id": "c_812", "amount": 1200}} |
Sends invoice for 1200 to customer c_812 |
system Generate a short title for this conversation. + user kubectl delete namespace staging |
Deletes the staging Kubernetes namespace |
The last row shows that the input's content decides the style, not the wrapper's wording. A title-style wrapper around a command still gets an intent.
Usage
Best quality (canonical format): send the raw input as a single user message with no system prompt. Wrapped prompts (your own system/user instructions) are supported, and the eval measured about the same quality for wrapped and canonical inputs.
Generation defaults: temperature=0, max_tokens=32, stop=["\n"]. The chat template is ChatML with LFM3 special tokens and no <think> block. It is included as chat_template.jinja and must be used as-is.
import torch
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
base_id, rev = "LiquidAI/LFM3-1.7B-Base", "545fc8f4c7b5fa9f405105274cd29c4f8f44b526"
tok = AutoTokenizer.from_pretrained("oot-ai/oot-oneliner-lora") # ships the OOT chat template
model = AutoModelForCausalLM.from_pretrained(base_id, revision=rev, trust_remote_code=True, dtype=torch.bfloat16)
model = PeftModel.from_pretrained(model, "oot-ai/oot-oneliner-lora").eval()
ids = tok.apply_chat_template([{"role": "user", "content": "git status"}], add_generation_prompt=True, return_tensors="pt")
out = model.generate(ids, max_new_tokens=32, do_sample=False)
print(tok.decode(out[0, ids.shape[1]:], skip_special_tokens=True).split("\n")[0].strip())
Multi-LoRA serving (vLLM, target setup; native LFM3 support in vLLM is pending):
vllm serve LiquidAI/LFM3-1.7B-Base --revision 545fc8f4c7b5fa9f405105274cd29c4f8f44b526 \
--chat-template chat_template.jinja --enable-lora --max-loras 8 --max-lora-rank 32 \
--lora-modules oot-oneliner=oot-ai/oot-oneliner-lora
Recommended client guard: trim whitespace, strip quotes and any trailing period, and keep the first line. Inputs are trained up to ~2K tokens, so truncate longer inputs on the client.
Evaluation
Held-out test sets were never used for training (enforced by hash exclusion). Scores are for the Q8_0 GGUF:
| Metric | Score |
|---|---|
| Mode accuracy (title vs intent matches input type), 1,000 cases, 200 per type | 99.5% |
| Format compliance (one line, word count, no prefix/quotes/period), same 1,000 cases | 98.5% |
| Faithfulness (nothing unsupported by the input, Sonnet 5.5 judge), same 1,000 cases | 89.6% |
| Topic score (0β3, Sonnet 5.5 judge), same 1,000 cases | 2.71 |
| Destructive effect stated, 399-case destructive slice | 99.0% |
| Mode / faithfulness / chat title quality (0β3), 155-case gold set | 97% / 85% / 2.58 |
Versus the previous release (data v0.6, Haiku-labeled), paired on the same 1,000 held-out inputs: faithfulness +2.0 pts overall (tool calls +10, SQL +5.5, but bash β5.6 and bash topic score β0.10; bash faithfulness varies Β±7 pts between training seeds), and an independent judge (TypeSafe Jev) prefers this version 39% vs 28% (34% ties). Format is 0.6 pts lower, within run-to-run noise (Β±1.5 pts between training seeds).
Against frontier models on a 100-case arena (20 per type), oot-oneliner leads on contract compliance:
| oot-oneliner | Claude Haiku 5.5 | Claude Sonnet 5.5 | |
|---|---|---|---|
| Format compliance | 100% | 78% | 55% |
| Mode accuracy | 98% | 89% | 96% |
| Destructive effect stated (Jev, n = 27 / 25 / 24) | 85% | 72% | 83% |
On output quality alone the frontier models are still preferred: in pairwise Jev judgments over all 100 cases, oot-oneliner wins or ties 39% of pairs against Haiku 5.5 and 27% against Sonnet 5.5. Restricted to pairs where both outputs are compliant and within one word in length, it wins or ties 51% against Haiku 5.5 and 47% against Sonnet 5.5 (previous release: 36% / 33%). Counting a contract break as a loss, it wins or ties 57% / 61%.
Known limitations
- Faithfulness on long multi-step scripts: the model can name the wrong entity or invent a purpose. Capacity is the limit here, not labels.
- About 3% of chat titles and 2% of SQL intents run one word over the limit.
- Intents are always in English, and titles follow the user's language.
Training
- Base:
LiquidAI/LFM3-1.7B-Base@545fc8f4c7b5fa9f405105274cd29c4f8f44b526, unmodified. - LoRA r=32, Ξ±=64, dropout 0.05 on all attention, short-conv and MLP linear projections (
q_proj k_proj v_proj o_proj gate_proj in_proj out_proj w1 w2 w3). Nolm_heador embeddings. - SFT with loss on assistant tokens only. 29,441 examples (training split after dropping rows over the max length), 2 epochs (best checkpoint at
1.5 by a balanced dev score), lr 2e-4 cosine, batch 64, max length 2048, bf16, single GPU (30 min). - Data v0.7.1 (not released): chat titles and intents distilled from Claude Sonnet 5.5 (every v0.6 input relabeled, the teacher's own length kept, intents at the 10-word limit trimmed to β€ 9), filtered against the output contract, plus synthetic hard cases (destructive actions, minimal arguments, prompt injection, mismatched wrappers) and ~40% wrapped prompts. Seed sources: chat-title messages (15 languages), agent tool-call traces, Spider/BIRD (SQL), ToolACE (tool calls), CommitPackFT (diffs).
- Chat template sha256[:16]:
24295b6e9794c3e0.
License
Derived from LiquidAI/LFM3-1.7B-Base, licensed under the LFM Open License v1.0. That license allows free commercial use only below Liquid AI's revenue threshold; see the base model's LICENSE. This derivative is subject to the same license.
- Downloads last month
- 35
Model tree for oot-ai/oot-oneliner-lora
Base model
LiquidAI/LFM3-1.7B-Base