openhubresearch/ATLAS-Taurus-Expert-7B-poc-v1

ATLAS-Taurus-Expert-7B — PoC v1 (LoRA adapter)

A small QLoRA LoRA adapter that nudges OLMo-3-7B-Think toward being a Taurus-platform expert — the multi-agent orchestration platform behind The Beast. This is an honest proof-of-concept: it validates the end-to-end fine-tune pipeline (data → QLoRA → held-out eval) on a single A100-40GB without interrupting the live 32B production endpoint, and shows a small but real lift on a held-out generalization set. It is not a finished product — see Limitations.

TL;DR

What is this?	A LoRA adapter (PEFT) over allenai/Olmo-3-7B-Think, trained with QLoRA (4-bit NF4 base) to answer questions about the Taurus agent platform.
Adapter size	~80 MB (adapter_model.safetensors), LoRA r=16 on all attention + MLP projections.
Held-out result	keyword-overlap on 12 unseen scenario questions: base 0.368 → adapter 0.389 (+0.021, +5.7% rel.).
Trained on	124 curated Taurus QA pairs (hand-authored seed + doc-derived), 2 epochs, LR 1e-4.
Where it ran	astra-01 (A100-SXM4-40GB, Chiang Mai), alongside the live OLMo-3-32B production server (which was untouched).
Intended use	Domain-adaptation PoC + template for the larger 32B Taurus-expert run.

Results (held-out eval)

Scored by keyword-overlap on 12 held-out scenario questions that are not in the training set (e.g. "a scheduled agent wakes with no memory — walk through rehydration", "URL pattern for a public dashboard with slug X"). Both models are loaded in 4-bit NF4 (the same quantization the adapter is trained against) for a fair delta, greedy decoding, max_new_tokens=400.

Model	avg keyword score (12 Q)
Base Olmo-3-7B-Think (4-bit)	0.368
+ Taurus-Expert adapter (this repo)	0.389
Delta	+0.021 (+5.7% relative)

An honest note on the process. A first run (197 examples, incl. 73 raw doc-continuation chunks, LR 2e-4, 3 epochs) regressed to 0.229 — the doc-continuation chunks pulled the model away from the QA-answering behavior the eval measures, and the high LR induced forgetting of Taurus-specific facts. The published adapter uses the corrected recipe: QA-only data, LR 1e-4, 2 epochs, which recovered a positive lift. The absolute gain is small because the base 7B-Think is already a capable reasoner and the eval is deliberately hard (scenario generalization, not definitions) — a 124-example PoC is expected to move the needle modestly.

Training

• Method: QLoRA — base loaded in 4-bit NF4 (double-quant, bf16 compute) via bitsandbytes; LoRA adapters via peft; SFT via trl SFTTrainer.
• LoRA: r=16, alpha=32, dropout=0.05, target = q,k,v,o,gate,up,down proj.
• Optim: paged AdamW 8-bit, cosine schedule, warmup 0.03, grad-checkpointing, bsz=1 × grad-accum=16, max_seq=2048.
• Data (124 examples): hand-authored Taurus QA seed (agents/runs/memory/tools/filesystem/delegation/dashboards/escalation/scheduling/security/SOP/continuity/admin-API) + doc-derived QA. Chat-templated to the base tokenizer.
• Compute: ~3.3 min on one A100-40GB (2 epochs, 16 steps). Train loss 3.64 → 2.53; token-accuracy 0.39 → 0.54.

Usage

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import PeftModel
import torch

base = "allenai/Olmo-3-7B-Think"
bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4",
                         bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_use_double_quant=True)
tok = AutoTokenizer.from_pretrained(base)
model = AutoModelForCausalLM.from_pretrained(base, quantization_config=bnb, device_map="auto")
model = PeftModel.from_pretrained(model, "openhubresearch/ATLAS-Taurus-Expert-7B-poc-v1")

SYS = ("You are ATLAS, a Taurus platform expert. You give precise, accurate answers "
       "about the Taurus multi-agent orchestration platform: agents, runs, tools, "
       "delegation, memory tiers, schedules, the admin API, and operating SOPs.")
msgs = [{"role":"system","content":SYS},
        {"role":"user","content":"What determines how well an agent survives context compaction?"}]
ids = tok.apply_chat_template(msgs, add_generation_prompt=True, return_tensors="pt").to(model.device)
print(tok.decode(model.generate(ids, max_new_tokens=400, do_sample=False)[0][ids.shape[1]:], skip_special_tokens=True))

Limitations

• Proof-of-concept, small corpus (124 ex). Absolute quality gains are modest; not intended for production use as-is.
• Crude eval metric. Keyword-overlap is a cheap proxy, not a judge model — it rewards factual coverage, not answer quality/faithfulness. Treat the +0.021 as a directional signal, not a benchmark claim.
• Domain-narrow. Adapts to Taurus-platform Q&A; may not help (and could slightly shift) general-domain behavior.
• Adapter only. Ships the LoRA delta, not merged weights; requires the base allenai/Olmo-3-7B-Think + peft to run.

Roadmap

• 32B Taurus-Expert: repeat this recipe on ATLAS/OLMo-3-32B-Think in a maintenance window (needs the 32B service stopped to free VRAM + provisioned disk for the BF16 base).
• Bigger, cleaner corpus: admin-API dump + real run-traces; better (judge-model) eval.
• Multi-model routing: teach ATLAS its fleet role — the cheap default that owns routine work and routes hard / high-stakes tasks to frontier sub-agents (Claude/GPT) with a self-contained brief. (Corpus design in the ATLAS Taurus-Expert plan.)

Provenance

Built by beast-atlas, a sub-agent of The Beast, operating ATLAS (Robin Dey / OpenHub Research) on the A100 astra-01. Base model © AI2 (Apache-2.0). This adapter is released under Apache-2.0.