Instructions to use openhubresearch/ATLAS-OLMo-3-7B-Think-v4 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use openhubresearch/ATLAS-OLMo-3-7B-Think-v4 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="openhubresearch/ATLAS-OLMo-3-7B-Think-v4")

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("openhubresearch/ATLAS-OLMo-3-7B-Think-v4")
model = AutoModelForCausalLM.from_pretrained("openhubresearch/ATLAS-OLMo-3-7B-Think-v4", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use openhubresearch/ATLAS-OLMo-3-7B-Think-v4 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "openhubresearch/ATLAS-OLMo-3-7B-Think-v4"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "openhubresearch/ATLAS-OLMo-3-7B-Think-v4",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/openhubresearch/ATLAS-OLMo-3-7B-Think-v4

SGLang

How to use openhubresearch/ATLAS-OLMo-3-7B-Think-v4 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 "openhubresearch/ATLAS-OLMo-3-7B-Think-v4" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "openhubresearch/ATLAS-OLMo-3-7B-Think-v4",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

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 "openhubresearch/ATLAS-OLMo-3-7B-Think-v4" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "openhubresearch/ATLAS-OLMo-3-7B-Think-v4",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use openhubresearch/ATLAS-OLMo-3-7B-Think-v4 with Docker Model Runner:
```
docker model run hf.co/openhubresearch/ATLAS-OLMo-3-7B-Think-v4
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

ATLAS-OLMo-3-7B-Think-v4

OLMo-3-7B-Think served by the ATLAS pure-Rust inference engine (v4.2.0) — zero external crate dependencies, byte-identical to the HuggingFace transformers reference, BF16 GPU inference on A100-SXM4-40GB.

🟢 Production endpoint: an OpenAI-compatible API serving this model is live at https://atlas.thebeastagi.com/v1 (bearer-key auth; GET /v1/models and GET /health open). An OpenRouter provider application is in progress.

Latest Release — v4.2.0 (2026-07-06): Reference Fidelity

v4.2.0 — HF-Reference Fidelity + Reasoning API · 627 tests · CI green

Differential testing against HuggingFace transformers (token-level logit comparison) uncovered and fixed three silent inference-quality bugs that had been degrading output since the initial port:

YaRN correction range — missing 2π factor in the wavelength calculation, incorrect interpolation ramp, and attn_factor must be applied squared
Layer-type RoPE split — YaRN scaling applies only to the 8 full-attention layers; the 24 sliding-window layers use plain θ=500,000 (per configuration_olmo3.py)
QK-norm scope — RMSNorm is computed over the full 4096-dim Q/K projection, not per-head — the per-head variant silently destroyed retrieval beyond ~128 tokens

ATLAS output is now byte-identical to the HF reference implementation. To our knowledge, ATLAS is the only from-scratch (non-transformers, zero-dependency Rust) OLMo-3-7B-Think implementation serving at full reference quality.

Serving upgrades in v4.2.0:

Context window raised to 16,384 tokens served (model supports up to 64K via YaRN), max output 3,584 tokens
Official OLMo chat template with server-side <think> primer and the Ai2 reference system prompt
Reasoning API: chain-of-thought surfaced as message.reasoning and streaming delta.reasoning (OpenRouter convention) — final answers stay clean, reasoning stays inspectable
Sampling defaults aligned with the Ai2 reference (repetition_penalty=1.0 — penalties make thinking models ramble)
compute-sanitizer memcheck clean; exact CPU/GPU parity verified on long sequences

Benchmarks (measured on the live A100 endpoint, before → after the fidelity fixes)

Benchmark	Before fixes	After fixes (v4.2.0)	Reference
GSM8K (25 problems)	12%	88%	Ai2 reported: 85–91% ✅
MMLU (100 questions, direct)	22%	54%	—
HumanEval (15 tasks, execution-verified)	—	73.3% pass@1	—
Needle-in-a-haystack	failed >128 tok	clean at 3.3K+	—

All remaining misses were output-length truncations; accuracy was 100% on items where reasoning completed within budget.

Previous release — v4.1.0 (Full GPU Attention + StigmergicHook)

4× throughput: 61.7 tok/s BF16 on A100 (up from 15.4 tok/s) — zero intra-layer PCIe transfers during decode
Full GPU attention path: custom CUDA kernels handle the entire decode step on-device
New CUDA kernels: decode_attention_kernel, qk_norm_inplace_kernel, rope_precomputed_kernel, kv_cache_write_kernel, atlas_gpu_argmax
New crate atlas-infer: exposes the StigmergicHook trait — a GraphPalace bridge that lets inference hooks read/write stigmergic memory in real time during token generation

Model Details

Property	Value
Base model	allenai/Olmo-3-7B-Think
Architecture	Olmo3ForCausalLM — post-norm + QK-norm, SWA + YaRN RoPE
Parameters	7.3B
Precision	BF16 (bfloat16)
Context	65,536 tokens max (YaRN factor=8); served at 16,384 in v4.2.0
Vocab	100,278 tokens
License	Apache 2.0
Inference engine	ATLAS v4.2.0 — pure Rust, zero external crate dependencies
Fidelity	Byte-identical logits vs HF `transformers` reference
ATLAS tests	627 passing, CI green

Note on model weights: The weights in this repository are the unmodified allenai/Olmo-3-7B-Think base weights. ATLAS is the inference + memory palace engine — not a fine-tune. Use this repo to benefit from the ATLAS ecosystem (stigmergic memory, ASTRA discovery, ZK proofs). Benchmark numbers above measure the ATLAS serving stack, not modified weights.

ATLAS Inference Engine

This model is verified to run correctly with ATLAS, a pure-Rust LLM inference framework with zero external crate dependencies. ATLAS implements the full OLMo-2/3 architecture from scratch:

Post-norm layer ordering — x = residual + rmsnorm(output) matching the HuggingFace Olmo2DecoderLayer reference
QK-norm — RMSNorm over the full 4096-dim Q/K projections before RoPE (v4.2.0 fix)
Sliding Window Attention — 24/32 layers with window=4,096, plain θ=500K RoPE; YaRN on the 8 full-attention layers only (v4.2.0 fix)
YaRN RoPE — factor=8, original_max_seq_len=8,192, corrected 2π wavelength range, attn_factor² (v4.2.0 fix)
BF16 W16A32 — weights in BF16 (14 GB VRAM), activations in f32
Official OLMo chat template — with <think> primer and Ai2 system prompt (v4.2.0)
Reasoning API — message.reasoning / streaming delta.reasoning (v4.2.0)
Full sampling pipeline — repetition penalty, temperature, top-p, top-k, min-p, frequency/presence penalty
Full GPU attention path (v4.1.0) — five custom CUDA kernels, zero PCIe transfers during decode
StigmergicHook trait (v4.1.0, atlas-infer crate) — GraphPalace bridge for live stigmergic memory reads/writes during token generation

Performance (A100-SXM4-40GB, production serving)

Metric	Value
Decode throughput	~50 tok/s sustained (BF16, live endpoint); 61.7 tok/s peak micro-bench
TTFT	~1.5 s (short prompts)
VRAM	~14 GB
CPU/GPU parity	exact match (long-sequence test)
Model load time	~108 s (3 shards, 14 GB)

Known gaps being tracked for the next cycle: batched prefill, GEMV occupancy, 32K context via BF16 KV cache.

Quick Start with ATLAS

# Build ATLAS from source
git clone https://github.com/web3guru888/ATLAS.git
cd ATLAS
cargo build --release -p atlas-cli

# Download model weights
# (or use huggingface-cli: hf download openhubresearch/ATLAS-OLMo-3-7B-Think-v4)

# Start OpenAI-compatible API server
./target/release/atlas api serve \
  --weights /path/to/ATLAS-OLMo-3-7B-Think-v4 \
  --model olmo3-7b \
  --port 8080

# Query the API (reasoning is returned in message.reasoning)
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "olmo3-7b",
    "messages": [{"role": "user", "content": "What is the capital of France?"}],
    "max_tokens": 1500,
    "temperature": 0.6,
    "top_p": 0.95
  }'

Tip: OLMo-3-Think reasons before answering — give it max_tokens ≥ 1500 so the chain of thought can complete. Leave repetition_penalty at 1.0 (Ai2 reference).

Quick Start with HuggingFace Transformers

from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "openhubresearch/ATLAS-OLMo-3-7B-Think-v4",
    torch_dtype="bfloat16",
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(
    "openhubresearch/ATLAS-OLMo-3-7B-Think-v4"
)

messages = [{"role": "user", "content": "What is the capital of France?"}]
inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True,
    return_tensors="pt", return_dict=True
).to(model.device)

output = model.generate(
    **inputs, max_new_tokens=1500,
    temperature=0.6, top_p=0.95, do_sample=True,
)
print(tokenizer.decode(output[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True))

What's Next: the 32B chapter

With the 7B substrate at reference fidelity, work is beginning on serving OLMo-3-32B-Think on the same A100-40GB via 4-bit weight quantization — tracked in web3guru888/ATLAS#26.

About ATLAS

ATLAS (Active-inference Training with Learned Adaptive Stigmergy) is a next-generation LLM framework built in pure Rust with zero external crate dependencies — the SQLite principle applied to AI infrastructure. It fuses:

GraphPalace — Stigmergic memory palace with pheromone-guided navigation
ASTRA — Live discovery engine hitting NASA, WHO, World Bank APIs
TRM-CausalValidator — 7M-param recursive validator
Champagnat n-Morphic Framework — biologically-grounded training dynamics

22 crates. 627 tests. One coherent system. Zero external Rust dependencies.

Website: atlasagi.org · Observatory: Interactive Demo · Live API: atlas.thebeastagi.com · Organization: OpenHub Research · Author: Robin Dey

Citation

@software{atlas2026,
  title       = {ATLAS: Active-inference Training with Learned Adaptive Stigmergy},
  author      = {Robin Dey},
  year        = {2026},
  institution = {OpenHub Research, Thailand},
  url         = {https://github.com/web3guru888/ATLAS},
  note        = {Pure Rust LLM framework. v4.2.0: 22 crates, 627 tests,
                 OLMo-3-7B-Think at HF-reference fidelity on A100 (BF16,
                 full GPU attention, reasoning API). GSM8K 88%, MMLU 54%,
                 HumanEval 73.3% pass@1 through the ATLAS serving stack.}
}