Laplace-1-Atlas

Foresight before action.

The flagship causal-interventional decision model for the second workforce.

Why Laplace · Evaluation · Decision Forge · Usage · Model details · Limitations

We ought then to regard the present state of the universe as the effect of its anterior state and as the cause of the one which is to follow.

— Pierre-Simon Laplace, A Philosophical Essay on Probabilities, 1814

Laplace-1-Atlas is the flagship of Laplace-1, a family of causal-interventional decision models. Large models think and generate. Laplace foresees what an action will do inside an organization, and uses that foresight to make the decisions organizations hand to people and agents: who does the work, who sees the information, what runs, and what is accepted.

Highlights

• First on 7 of 9 decision benchmarks against models from OpenAI, Perplexity, Cloudflare, TypeSafe, ByteDance, and Alibaba (ties counted).
• 89.4% on TrustDecision, +5.4 points over the next-best model and +10.7 over Jev 1.14.
• Ahead of Jev 1.14 on 8 of 9 benchmarks, and ahead of Perplexity's Decider v1.2 on 7 of 9.
• Unshaken by distribution shift: 95.6% on AgentDecisionBench L2 common, 95.5% on L2 shift.
• A decision is one forward pass. Hand Laplace a set of candidates and read a distribution over them from the next-token logits, with no sampling and no parsing.
• Open weights, Apache-2.0. Complete BF16 weights and tokenizer. No adapter, no gated access.

Why Laplace

Every leap in human cooperation, from tribes to the joint-stock company to the internet, was an expansion of trust among strangers. The next leap is already here: organizations of people and agents, where agents will soon outnumber people. Agents are wired into every tool through A2A and MCP, yet nothing tells them, or the people who delegate to them, what an action will do before it runs. Intelligence is no longer scarce. Trust is.

Trust begins with foresight. Language models learned from text, and world models are learning from video, but public data is observational: it never records what an action caused inside an organization. Laplace learns the interventional distribution

$$ p\left(s' \mid \mathrm{do}(a),, s,, C\right) $$

the next state of an organization $s$ after a candidate action $a$, under the chain of authority $C$ behind the agent. Foresight is what every act of delegation needs. Laplace turns it into the four decisions an organization makes whenever people and agents work together:

The better an organization can foresee the consequence of each decision, the more of its work it can hand to agents.

The full story of Laplace will be told in our upcoming technical blog.

Meet Laplace-1

Laplace-1 is the first public release of the Laplace program, in two sizes:

Both models expose two inference primitives:

• Candidate scoring. Give it a state, a question, and candidates. It returns a distribution over exactly those candidates in a single forward pass: routing, access decisions, escalation, and next-action selection.
• Outcome prediction. Give it explicit environment rules, context, and an action. It generates the next observation, so you see the consequence before the action happens.

Evaluation

_{Scores in %. Bold marks the best score in each row, ties included. "—" means the score is not published or the model does not support the setting.}

What the numbers say

• Trust is where the gap is widest. TrustDecision is the closest benchmark to Laplace's purpose, and it is where Atlas leads by the most: 89.4%, +5.4 over Decider v1.2 and +10.7 over Jev 1.14. This is the capability general-purpose models do not get from public data.
• Robust under shift. From AgentDecisionBench L2 common to shift, Atlas moves by 0.1 points. A judge that only works on familiar inputs is not a judge.
• Knowing when to act. On When2Call, Atlas scores 89.9%, 15.4 points above GPT-6 Luna Decisions. Not acting is a decision too.
• Organizations are the frontier. Atlas is first on COMPASS. OrgAccess remains unsolved: no model in this comparison clears 46%, and Atlas sits 0.9 points behind the leader. That open frontier is exactly why Laplace learns inside organizations.
• Where we trail. JEVal is Atlas's one gap against both Decider v1.2 (−3.0) and Jev 1.14 (−0.8). We report it because a model card that hides its weaknesses is not one you should trust.

The Decision Forge data protocol treats public test sets, including COMPASS and OrgAccess, as evaluation-only: their answers and any derivative examples are excluded from training data.

Where the judgment comes from: Decision Forge

The data Laplace needs does not exist on the public web. It lives inside organizations, in three forms:

The judgment standard is sovereign: two organizations can judge the same action in opposite ways, and both can be right. There is no universal "correct decision" to learn once and ship to everyone.

Decision Forge, our open-source data layer, compiles an organization's own documents into verified decision training data. Every label traces back to a rule, and every rule to a sentence in a source document. The core runs offline, inside the organization's own walls, and every example belongs to one of the same four decisions Laplace makes. Its decision export uses the same candidate-readout contract as Laplace-1's candidate scoring: single-token labels under the native chat template, read out at the final prompt position. The data pipeline and the model speak the same language.

The more accurately Laplace judges, the more authority organizations delegate. More delegation produces more receipts, and more receipts teach Laplace the organization better.

Usage

Laplace supports two text inference modes:

• Candidate scoring: provide a state, a question, and candidate descriptions. The model returns a distribution over the supplied candidates using a single forward pass. Use this mode for classification, routing, access decisions, and next-action selection.
• Outcome prediction: provide explicit environment rules, context, and an action, then generate a textual prediction of the next observation.

Both repositories contain complete model weights and tokenizer files; no separate adapter is required. The examples below use PyTorch, Transformers, and Accelerate, with BF16 weights and automatic device placement. Atlas requires a Transformers version providing Qwen3_5ForConditionalGeneration. Vector uses the custom model implementation supplied with its repository through trust_remote_code=True.

Load the model and score candidates

The helper below uses the native chat template with thinking disabled. Candidate keys are stable application identifiers; temporary single-token labels are assigned internally and mapped back to those keys.

"""Text-only Laplace inference examples. Does not execute selected actions."""
import json
import string

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


def load_laplace(model_id="JuneoAI/Laplace-1-Vector"):
    if model_id == "JuneoAI/Laplace-1-Atlas":
        from transformers import Qwen3_5ForConditionalGeneration
        model_class = Qwen3_5ForConditionalGeneration
        kwargs = {"attn_implementation": "sdpa"}
    elif model_id == "JuneoAI/Laplace-1-Vector":
        model_class = AutoModelForCausalLM
        kwargs = {"trust_remote_code": True, "attn_implementation": "eager"}
    else:
        raise ValueError("Choose Laplace-1-Atlas or Laplace-1-Vector.")
    tokenizer = AutoTokenizer.from_pretrained(
        model_id, trust_remote_code=model_id == "JuneoAI/Laplace-1-Vector"
    )
    model = model_class.from_pretrained(
        model_id, dtype=torch.bfloat16, device_map="auto", **kwargs
    ).eval()
    return tokenizer, model


def encode_messages(tokenizer, messages):
    text = tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True,
        enable_thinking=False,
    )
    return tokenizer(text, add_special_tokens=False, return_tensors="pt")


def decision_messages(tokenizer, state, question, choices):
    """choices maps stable application keys to textual candidate descriptions."""
    if not choices:
        raise ValueError("Supply at least one candidate.")
    keys = list(choices)
    names = list(string.ascii_uppercase) + [
        a + b for a in string.ascii_uppercase for b in string.ascii_uppercase
    ]
    labels, token_ids, seen = [], [], set()
    for name in names:
        ids = tokenizer.encode(name, add_special_tokens=False)
        if len(ids) == 1 and ids[0] not in seen:
            labels.append(name)
            token_ids.append(ids[0])
            seen.add(ids[0])
            if len(labels) == len(keys):
                break
    if len(labels) != len(keys):
        raise ValueError("Not enough distinct single-token candidate labels.")
    payload = {
        "state": state,
        "question": question,
        "candidates": [
            {"letter": label, "description": choices[key]}
            for label, key in zip(labels, keys)
        ],
    }
    messages = [
        {
            "role": "system",
            "content": "Choose the supported answer from the supplied candidates. "
            "Output only its letter.\nReturn exactly one supplied candidate label.",
        },
        {"role": "user", "content": json.dumps(payload, ensure_ascii=False)},
    ]
    return messages, keys, token_ids


@torch.inference_mode()
def score_candidates(tokenizer, model, state, question, choices):
    messages, keys, candidate_ids = decision_messages(
        tokenizer, state, question, choices
    )
    inputs = encode_messages(tokenizer, messages).to(
        model.get_input_embeddings().weight.device
    )
    # One forward pass; read only the logits for the next token.
    logits = model(**inputs, use_cache=False, logits_to_keep=1).logits[0, -1]
    scores = logits[candidate_ids].float()
    if not torch.isfinite(scores).all():
        raise RuntimeError("Non-finite candidate logits.")
    probabilities = scores.softmax(dim=-1).cpu().tolist()
    return {
        "choice": keys[max(range(len(keys)), key=lambda i: probabilities[i])],
        "probabilities": dict(zip(keys, probabilities)),
    }


@torch.inference_mode()
def predict_observation(tokenizer, model, rules, context, max_new_tokens=256):
    messages = [
        {"role": "system", "content": rules},
        {"role": "user", "content": json.dumps(context, ensure_ascii=False)},
    ]
    inputs = encode_messages(tokenizer, messages).to(
        model.get_input_embeddings().weight.device
    )
    output = model.generate(
        **inputs, max_new_tokens=max_new_tokens, do_sample=False,
        pad_token_id=tokenizer.eos_token_id,
    )
    return tokenizer.decode(
        output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True
    ).strip()

tokenizer, model = load_laplace("JuneoAI/Laplace-1-Atlas")
# For Vector, use: load_laplace("JuneoAI/Laplace-1-Vector")

result = score_candidates(
    tokenizer,
    model,
    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.",
    },
)
print(result["choice"])
print(result["probabilities"])

choice is the application key with the highest score. probabilities contains the softmax-normalized next-token logits restricted to the supplied candidate labels. These values are relative to this candidate set, not a calibrated guarantee of correctness. The model does not generate a probability JSON; the client constructs the result from logits. Include a reject, abstain, or request-more-information option when the task requires one.

Changing candidate order requires changing the label-to-key mapping consistently. Do not hard-code tokenizer IDs or score the tokens of full candidate descriptions with this method.

One interface, four decisions

Every decision Laplace makes has the same shape: a state, a question, and the candidates your application allows. Here the same helper allocates work: choosing who should own a new sales lead under the organization's own routing rules.

owner = score_candidates(
    tokenizer,
    model,
    state={
        "lead": {
            "industry": "power utilities",
            "region": "East",
            "estimated_value_cny": 3200000,
            "stage": "new",
        },
        "policy": [
            "Leads above 1,000,000 CNY go to a senior account manager.",
            "Account managers only take leads in their own region.",
            "Prefer the manager with the most experience in the lead's industry.",
        ],
    },
    question="Who should own this lead?",
    choices={
        "li": "Li Wei: senior account manager, East region, 12 closed deals in power utilities.",
        "zhang": "Zhang Min: account manager, East region, 2 closed deals in power utilities.",
        "chen": "Chen Jie: senior account manager, South region, 9 closed deals in power utilities.",
    },
)
print(owner["choice"], owner["probabilities"])

The other three decisions change only the question and the candidates:

The model scores; it never executes. Your application decides what each choice means, including the probability below which a decision goes to a person.

Predict a next observation

Use generation when the desired output is a textual next-observation prediction rather than a candidate distribution. Supply the relevant rules explicitly. This example describes a small illustrative environment; it does not run a live action.

rules = (
    "Predict the next environment observation after the supplied action. "
    "Return only JSON. The state contains owner, open, and severity. "
    "The resolve action sets open=false and preserves the other fields. "
    'The observation format is {"state": {"owner": ..., '
    '"open": ..., "severity": ...}}. Do not add fields.'
)
context = {
    "state": {"owner": "operator", "open": True, "severity": "normal"},
    "history": [],
    "action": {"kind": "resolve"},
}
text = predict_observation(tokenizer, model, rules, context)
print(text)

A predicted observation is model-generated text, not confirmation that an external system performed an action. If consuming it as JSON, parse and validate its schema before use; generation alone does not enforce the schema.

The chat template is rendered first and then tokenized with add_special_tokens=False to avoid adding duplicate special tokens. See the Transformers chat-template documentation.

Model details

Intended use and limitations

Built for: the four decisions organizations delegate to people and agents (allocating work, sharing information, acting, and evaluating outcomes), and predicting the next state of an explicitly described environment.

Laplace advises; your system decides.

• A judgment layer, not an enforcement layer. Laplace does not execute actions and does not replace access control, authentication, or audit logging. Keep deterministic permission checks in place. Laplace decides what to do within them.
• Probabilities are relative. Candidate probabilities are normalized over the candidates you supply. They are not a calibrated probability of being correct. Calibrate thresholds on your own held-out decisions before you automate on them, and always offer a hand-back or request-more-information option when the stakes call for one.
• Your standard is not universal. Laplace-1 is trained for general and organizational decision making. An organization's own standard ($\ell$) differs from every other's. Put the governing rules in the state, and evaluate on your own cases before deployment.
• Predictions are not receipts. A predicted observation is text, not evidence that anything happened. Validate structured outputs against a schema.
• Hard frontiers remain. As OrgAccess shows, fine-grained organizational access reasoning is far from solved, for Laplace and for every model in this comparison.
• Text-first. The vision encoder is inherited from the base model. The decision results reported here are text-only.

Do not use Laplace-1 as the sole safeguard for irreversible, safety-critical, financial, medical, or legal actions. In those settings, a person keeps the final decision.

The world we are building

Humans keep the right to decide. Agents earn the right to act. An organization can then entrust its work to far more agents than it has people, because:

• every action is foreseen before it happens;
• every delegation narrows authority as work passes from hand to hand, and never widens it;
• every contribution is measured and credited once the work is done.

Payment networks authorize every transaction before it clears. We are building the same layer for every agent action: a judgment made in real time, by the organization's own standard, before the action happens.

We are building the trust layer that lets human organizations keep pace with machine intelligence.

Citation

@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-Atlas}},
  note         = {Model family: Laplace-1-Atlas (27B), Laplace-1-Vector (4B)}
}

License

Laplace-1-Atlas is released under the Apache-2.0 License. It is built on Qwen/Qwen3.8-27B; the upstream license notices are retained in this repository.

Contact

Partnerships, deployments, and research collaboration: business@juneo.ai

Building on Decision Forge? Open an issue or discussion at Juneo-Lab/decision-forge.