Model reference · open weights

Surjo

Available as managed deployment LLMs SurjoLabs Text gen 1 variants 590 dl/mo

Surjo is an open-weight language model from SurjoLabs. AxForge deploys and operates it for you on dedicated EU-owned hardware — with the licence handled where one is required.

Available as managed deployment — configured and operated for you on dedicated EU hardware, quoted per deployment.

What it is

Released bySurjoLabs
TypeLanguage models
TaskText gen
Parameters (lead)54M
Context2k tokens
Released2026-09-05
Popularity590 downloads / month
LicenceOpen weights

About

What Surjo is

Surjo-50M

Surjo-50M is a 53.8M-parameter hybrid recurrent language model developed by SurjoLabs. Built on the Gen-3 Surjo architecture, it couples Gated DeltaNet-2 (GDN-2) linear attention with full attention (XSA).

By executing a weight-tied recurrent core across 2 passes, the model reaches an effective computational depth of 18 layers while retaining the memory footprint and latency profile of a 10-layer physical model.

Instruction-Tuned Variant: For conversational use, instruction following, and a 2048-token context window, see Surjo-50M-SFT-Only.

Read the full model card

Model Specifications

AttributeSpecification
Parameters53.8M
ArchitectureHybrid GDN-2 + XSA (Subtractive Attention)
Physical Layers10 (1 Prelude + 8 Recurrent Trunk + 1 Coda)
Effective Depth18 Layers (2 Recurrent Passes)
Hidden Size512
Intermediate Size1536
Attention ConfigurationGQA (8 Query heads, 4 KV heads; Head Dim: 64)
Linear AttentionGDN-2 (K: 64, V: 64, 8 V-Heads)
Context Length1024 tokens pretraining (2048 max)
Vocabulary32,768 (Custom BPE, tied embeddings)

Evaluation Results

BenchmarkScore
PIQA63.11%
ARC-Easy44.99%
ArithMark-337.90%
HellaSwag31.37%
ARC-Challenge25.94%
Int Index16.40

Architecture Details

Surjo Gen-3 combines fast recurrent sequence processing with full-attention boundary layers:

  • Prelude (Layer 0): Standard attention with subtractive value projection (XSA) to anchor context.
  • Recurrent Core (Layers 1–8, tied 2× passes): Two interleaved groups consisting of 3× GDN-2 linear attention layers followed by 1× XSA full attention layer. GDN-2 uses chunked/fused recurrent kernels via Flash Linear Attention (FLA).
  • Coda (Layer 9): Terminal full-attention XSA layer.
  • Tied Head: The output projection shares weights with the 32,768-token embedding layer.

Pretraining

  • Dataset (20B tokens):
    • 60% FinePhrase
    • 20% DCLM
    • 10% FineMath
    • 10% Cornstack Python
  • Training Schedule: 20,000 steps (~1M tokens/step) at a sequence length of 1024 tokens.
  • Optimizer: Hybrid Muon (peak lr = 0.02) and AdamW (peak lr = 0.0036).

Usage

Requirements

pip install torch transformers accelerate
pip install -U git+https://github.com/fla-org/flash-linear-attention

Generation Example

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "SurjoLabs/Surjo-50m"

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto",
    trust_remote_code=True,
)

prompt = "The secret to scaling small language models is"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=64,
        do_sample=True,
        temperature=0.7,
        top_p=0.9,
        repetition_penalty=1.1,
    )

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Citation & License

This project is released under the Apache 2.0 License.

@software{surjo50m2026,
  author = {SurjoLabs},
  title = {Surjo-50M: Hybrid Recurrent Language Model},
  year = {2026},
  url = {https://huggingface.co/SurjoLabs/Surjo-50m}
}

From the published model card. Full card on the HuggingFace links in the sidebar.

Using it via the API

Call it like any OpenAI endpoint

Once AxForge deploys surjo for you, it answers on the OpenAI-compatible API — the same base URL and keys as every other model. (surjo below is illustrative; you get the exact model name on deployment.)

$ curl -sS https://api.axforge.ai/v1/chat/completions \
  -H "Authorization: Bearer $AXFORGE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"surjo","messages":[{"role":"user","content":"Hello"}]}'

Create an account — your API key is available in the console. 3M free tokens every 30 days with every new account.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms