Instructions to use URCHINBABY/URCHIN_BabyLM2026_StrictSmall with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use URCHINBABY/URCHIN_BabyLM2026_StrictSmall with Transformers:

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

pipe = pipeline("text-generation", model="URCHINBABY/URCHIN_BabyLM2026_StrictSmall", trust_remote_code=True)

# Load model directly
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("URCHINBABY/URCHIN_BabyLM2026_StrictSmall", trust_remote_code=True, dtype="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use URCHINBABY/URCHIN_BabyLM2026_StrictSmall with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/URCHINBABY/URCHIN_BabyLM2026_StrictSmall

SGLang

How to use URCHINBABY/URCHIN_BabyLM2026_StrictSmall 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 "URCHINBABY/URCHIN_BabyLM2026_StrictSmall" \
    --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": "URCHINBABY/URCHIN_BabyLM2026_StrictSmall",
		"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 "URCHINBABY/URCHIN_BabyLM2026_StrictSmall" \
        --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": "URCHINBABY/URCHIN_BabyLM2026_StrictSmall",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use URCHINBABY/URCHIN_BabyLM2026_StrictSmall with Docker Model Runner:
```
docker model run hf.co/URCHINBABY/URCHIN_BabyLM2026_StrictSmall
```

URCHIN Strict-Small

URCHIN (Unified Recurrent Connectome with Horizontal Integrate-and-fire Neurons) is a spiking, Dale-constrained recurrent language model for the BabyLM 2026 challenge (Strict-Small track, 10M words), built with the Parallelized Hierarchical Connectome Spiking State-space Model (PHCSSM) as its core architecture. A single cortex region of LIF neurons with a Dale-masked recurrent synapse is iterated K=24 lateral transmission steps per token to a fixed point; a linear head reads the cortex voltage. 4.23M parameters, no attention.

Architecture: A single horizontal layer of Dale's-law excitatory/inhibitory LIF spiking neurons joined only by lateral (horizontal) connections: the same population receives the input current and is read out by a linear voltage head, with no separate input/output population; each token is resolved by a K-iteration fixed-point recurrence over the lateral synapse. No attention, no depth. Custom code (trust_remote_code=True).
Track: BabyLM 2026 Strict-Small (10M words).
Tokenizer: official BabyLM 10M GPT-BERT baseline tokenizer (16384).
Serial (event-driven) variant: serial_urchin.py + configuration_serial_urchin.py provide an RSNN single-time-scan forward (UrchinSerialForCausalLM) reproducing the parallel outputs (score-equivalent), event-driven in O(T), using the SAME model.safetensors weights.

Usage

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("strict_small", trust_remote_code=True).eval()
tok = AutoTokenizer.from_pretrained("strict_small")
ids = tok("The quick brown fox", return_tensors="pt").input_ids
with torch.no_grad():
    logits = model(ids).logits

Intermediate checkpoints

Intermediate training checkpoints are provided as git revisions named chck_<N>M for the BabyLM challenge fast-eval.

License and citation

Released under CC BY-NC 4.0 (attribution required, non-commercial only). If you use this model or code, please cite (see CITATION.cff):

@misc{anonymous2026urchin,
  title        = {URCHIN: A Horizontal Spiking Language Model for Data-Constrained Pretraining},
  author       = {Anonymous},
  year         = {2026},
  howpublished = {under review (anonymized)},
  note         = {URCHIN spiking recurrent language model, BabyLM 2026}
}

Provenance and integrity fingerprints (canary + weight SHA-256) are documented in PROVENANCE.md.

Downloads last month: 885

Safetensors

Model size

4.23M params

Tensor type

F32