Instructions to use oot-ai/oot-oneliner with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use oot-ai/oot-oneliner with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-generation", model="oot-ai/oot-oneliner", trust_remote_code=True) messages = [ {"role": "user", "content": "Who are you?"}, ] pipe(messages)# pip install -U transformers accelerate # Load model directly from transformers import AutoTokenizer, AutoModelForCausalLM tokenizer = AutoTokenizer.from_pretrained("oot-ai/oot-oneliner", trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained("oot-ai/oot-oneliner", trust_remote_code=True, device_map="auto") messages = [ {"role": "user", "content": "Who are you?"}, ] inputs = tokenizer.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) outputs = model.generate(**inputs, max_new_tokens=256) print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:])) - Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- vLLM
How to use oot-ai/oot-oneliner with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "oot-ai/oot-oneliner" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "oot-ai/oot-oneliner", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker
docker model run hf.co/oot-ai/oot-oneliner
- SGLang
How to use oot-ai/oot-oneliner with SGLang:
Install from pip and serve model
# Install SGLang from pip: pip install sglang # Start the SGLang server: python3 -m sglang.launch_server \ --model-path "oot-ai/oot-oneliner" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "oot-ai/oot-oneliner", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker images
docker run --gpus all \ --shm-size 32g \ -p 30000:30000 \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --env "HF_TOKEN=<secret>" \ --ipc=host \ lmsysorg/sglang:latest \ python3 -m sglang.launch_server \ --model-path "oot-ai/oot-oneliner" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "oot-ai/oot-oneliner", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }' - Docker Model Runner
How to use oot-ai/oot-oneliner with Docker Model Runner:
docker model run hf.co/oot-ai/oot-oneliner
oot-oneliner
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 has standalone merged weights (bf16), which need trust_remote_code=True. Other formats: LoRA adapter, the canonical artifact for shared-base serving ยท 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 transformers import AutoModelForCausalLM, AutoTokenizer
tok = AutoTokenizer.from_pretrained("oot-ai/oot-oneliner")
model = AutoModelForCausalLM.from_pretrained("oot-ai/oot-oneliner", trust_remote_code=True, dtype=torch.bfloat16).eval()
ids = tok.apply_chat_template([{"role": "user", "content": "rm -rf build/"}], 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())
Run inputs one at a time, without batching: padding leaks through LFM3's short-conv layers.
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
- 49