Laplace-1-Vector for Apple Silicon (MLX, bf16)

An MLX conversion of JuneoAI/Laplace-1-Vector (revision 06cea7d), Juneo Lab's 4B decision model built on Spark-X2.6-4B. Hand it a state, a question and a set of candidates, and it returns a probability for each candidate from one forward pass: who should own a task, who may see what, whether to act or ask first, whether a result meets the standard. It can also predict the next state of an environment you describe. At 4B parameters it runs comfortably on a Mac, next to the agent, so the data stays on your machine. This build keeps the full bf16 weights (the reference for the other builds). Size: 8.2 GB.

Published by NetProjects (Internet Projects Ltd). Not affiliated with Juneo Lab or XHToken.

Sibling: Laplace-1-Atlas MLX, the 27B member of the Laplace-1 family.

Build Size JevBench (231 public items) Same top answer as bf16
netprojects/Laplace-1-Vector-MLX-6bit (recommended) 3.3 GB 79.2% 222 / 231
netprojects/Laplace-1-Vector-MLX-8bit 4.4 GB 79.7% 229 / 231
netprojects/Laplace-1-Vector-MLX-4bit 2.3 GB 78.4% 210 / 231
netprojects/Laplace-1-Vector-MLX-bf16 8.2 GB 78.8% reference

For scoring and ranking work, use the 6-bit (recommended) or 8-bit build: both track bf16 closely. The 4-bit build is the smallest option; its accuracy holds, but it changes the top answer on about 9% of JevBench items compared with bf16.

Score candidates

A decision is one forward pass: the model reads the candidates as letters and the next-token logits of those letters give the distribution. This is Juneo's score_candidates helper, ported to mlx-lm with the same prompt.

pip install -U "mlx-lm>=0.32"
import json, string
import mlx.core as mx
from mlx_lm import load

model, tokenizer = load("netprojects/Laplace-1-Vector-MLX-bf16")
SYSTEM = ("Choose the supported answer from the supplied candidates. Output only its letter.\n"
          "Return exactly one supplied candidate label.")

def score_candidates(state, question, choices):
    """choices maps your own keys to candidate descriptions (up to 26)."""
    keys, letters, ids = list(choices), [], []
    for name in string.ascii_uppercase:
        t = tokenizer.encode(name, add_special_tokens=False)
        if len(t) == 1 and t[0] not in ids:
            letters.append(name); ids.append(t[0])
        if len(letters) == len(keys):
            break
    payload = {"state": state, "question": question,
               "candidates": [{"letter": l, "description": choices[k]} for l, k in zip(letters, keys)]}
    messages = [{"role": "system", "content": SYSTEM},
                {"role": "user", "content": json.dumps(payload, ensure_ascii=False)}]
    prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True,
                                           enable_thinking=False, tokenize=False)
    tokens = mx.array(tokenizer.encode(prompt, add_special_tokens=False))[None]
    logits = model(tokens)[0, -1].astype(mx.float32)
    probs = mx.softmax(logits[mx.array(ids)]).tolist()
    best = max(range(len(keys)), key=probs.__getitem__)
    return {"choice": keys[best], "probabilities": dict(zip(keys, probs))}

print(score_candidates(
    state={"permissions": ["read_records"], "request": "Delete a record."},
    question="Which decision is supported by the supplied permissions?",
    choices={"allow": "Allow the request.", "deny": "Deny the request."},
))

The probabilities are relative to the candidates you supply, not a calibrated chance of being correct. Put the rules that govern the decision in the state, and include a hand-back or request-more-information option when the stakes call for one.

Predict the next observation

For outcome prediction, give the environment rules as the system message and the state and action as JSON, with thinking off:

mlx_lm.generate --model netprojects/Laplace-1-Vector-MLX-bf16 --max-tokens 256 \
  --chat-template-config '{"enable_thinking": false}' \
  --system-prompt 'Predict the next environment observation after the supplied action. Return only JSON.' \
  --prompt '{"state": {"owner": "operator", "open": true}, "history": [], "action": {"kind": "resolve"}}'

Or from Python:

from mlx_lm import load, generate

model, tokenizer = load("netprojects/Laplace-1-Vector-MLX-bf16")
messages = [{"role": "user", "content": "In one sentence, when should an agent hand a decision back to a person?"}]
prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True, enable_thinking=False, tokenize=False)
print(generate(model, tokenizer, prompt=prompt, max_tokens=200))

mlx_lm.server serves the model with an OpenAI-compatible API. mlx-lm 0.32 and newer support this architecture (spark2_5) natively, so no trust_remote_code is needed; Python 3.11 or newer. Tested with mlx 0.32.4 and mlx-lm 0.32.2.

What was checked

On a MacBook Pro M5 Max (128 GB), 16 November 2026.

  • Parity with the original model. Each build was compared with Juneo's own model code running in float32 on CPU (Transformers 4.57.1) on 11 prompts, including one of 3,313 tokens. Teacher-forced, the builds pick the same next token as the original on 99.6% (bf16), 98.9% (8-bit), 98.1% (6-bit) and 90.4% (4-bit) of 753 positions; cached decoding agrees with the full forward pass in every build. On 16 candidate-scoring cases, every build picks the same candidate as the original.

  • JevBench. The 231 public items of JevBench (easy, original and hard tiers; MIT). Each item is one candidate-scoring pass with thinking off, using the system prompt above; the highest-probability candidate is compared with the expected answer:

    Build Accuracy easy original hard Same top answer as bf16
    bf16 78.8% 48 / 48 68 / 72 66 / 111 reference
    8-bit 79.7% 48 / 48 69 / 72 67 / 111 229 / 231
    6-bit 79.2% 48 / 48 69 / 72 66 / 111 222 / 231
    4-bit 78.4% 48 / 48 67 / 72 66 / 111 210 / 231

    These figures come from our own candidate-scoring harness and are not directly comparable with the JevBench score in Juneo's model card, which uses Juneo's evaluation setup.

  • Source files. All weight files of the upstream revision match the Hub's SHA-256 hashes.

Intended use

Laplace advises; your system decides. As Juneo's card says, keep deterministic permission checks, authentication and audit logging in place, calibrate thresholds on your own held-out decisions before automating on them, and keep a person on the final decision for irreversible, safety-critical, financial, medical or legal actions. See the original model card for the training data (Decision Forge), the full evaluation and the limitations.

License

Apache-2.0, as the original model and Spark-X2.6-4B. LICENSE is the Apache-2.0 text from the upstream repository and NOTICE describes the conversion and credits Juneo Lab and XHToken. If you use the model, please cite Juneo Lab:

@misc{juneo2026laplace1,
  title        = {Laplace-1: Causal-Interventional Decision Models for Trustworthy Agent Delegation},
  author       = {{Juneo Lab}},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/JuneoAI/Laplace-1-Vector}},
  note         = {Model family: Laplace-1-Atlas (27B), Laplace-1-Vector (4B)}
}

More MLX builds from NetProjects: huggingface.co/netprojects · netprojects.com

Downloads last month
46
Safetensors
Model size
4B params
Tensor type
BF16
·
MLX
Hardware compatibility
Log In to add your hardware

Quantized

Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Model tree for netprojects/Laplace-1-Vector-MLX-bf16

Finetuned
(1)
this model

Collection including netprojects/Laplace-1-Vector-MLX-bf16