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). No lm_head or 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
Inference Providers NEW
This model isn't deployed by any Inference Provider. πŸ™‹ Ask for provider support

Model tree for oot-ai/oot-oneliner-lora

Adapter
(8)
this model