Copernicus (57B)

A system-one decision model by Poindexter Labs.

Website · Quickstart · API Reference · Citation

Overview

Copernicus (57B) is a decision model developed by Poindexter Labs for applications that need structured decisions from natural-language context. It provides explicit answer types and probability distributions over the choices supplied by an application.

Copernicus combines two decision models, one Gemma-based and one Qwen-based. Its two-part inference design is inspired by REAX 1.3. The accompanying server exposes a /v1/systemone-compatible endpoint for text-based decisions:

Type	Purpose	Output
`choice`	Select one option from an explicit set.	Selected key and option probabilities.
`noul`	Evaluate a yes/no proposition.	Probability of `true`.
`score`	Assess an item against an ordered rubric.	Expected score and level probabilities.

The model can support research and prototyping in agent routing, tool selection, classification, verification and other decision-oriented applications. Evaluate its suitability for your own use case.

Model Details

Field	Value
Model	Copernicus (57B)
Developed by	Poindexter Labs
Organization	poindexterlabs.ai
Parameters	Approximately 57 billion across two components
Primary interface	Structured decision requests (`/v1/systemone`)
Supported answer types	`choice`, `noul`, `score`
Input	Text and JSON-serializable structured context
Reference implementation	Copernicus Engine
License	Apache License 2.0

Quickstart

The example below runs the published model on one CUDA GPU using the Copernicus Engine. The reference setup uses Linux, Python 3.11, a CUDA 13-compatible NVIDIA driver and a 96 GB NVIDIA GPU. Model files require approximately 110 GB of disk space; allow additional room for packages and temporary files. Model loading and quantization can take several minutes.

1. Install dependencies and download the model

git clone https://github.com/poindexter-stk/copernicus-engine.git
git -C copernicus-engine checkout 673b7dc
git clone https://github.com/reaxlabs/reax-subnet.git
git -C reax-subnet checkout 0c1efcc7abad11c56eefc866334aab4b01ec38ec

python3.11 -m venv .venv
source .venv/bin/activate
python -m pip install 'torch==2.11.0' --index-url https://download.pytorch.org/whl/cu130
python -m pip install 'transformers==5.14.1' 'accelerate==1.15.0' \
  'safetensors==0.8.0' 'kernels==0.16.0' 'huggingface-hub==1.33.0' \
  requests pillow

hf download Poindexter-Labs/Copernicus-57B --local-dir ./copernicus-model

If a CUDA-enabled PyTorch build is already installed, use a build compatible with your NVIDIA driver and system. The runtime requires both part-g/ and part-q/ from the model repository.

2. Start the server

Run these commands from the directory containing the two cloned repositories:

export PYTHONPATH="$PWD/reax-subnet/src${PYTHONPATH:+:$PYTHONPATH}"
export LOCAL_KERNELS="kernels-community/finegrained-fp8=$PWD/copernicus-engine/reax13/third_party/finegrained-fp8"
export HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1

python copernicus-engine/reax13/copernicus_serve.py \
  --model "$PWD/copernicus-model" \
  --host 127.0.0.1 \
  --port 8080

Keep this terminal open. The server is ready once it prints the local endpoint address. The default configuration uses one GPU visible as cuda:0.

3. Verify the server

In another terminal:

curl -s http://127.0.0.1:8080/healthz

4. Make your first decision

curl -s http://127.0.0.1:8080/v1/systemone \
  -H 'Content-Type: application/json' \
  -d '{
    "state": "A support request is about a duplicate payment, not an account login problem.",
    "questions": {
      "route": {
        "type": "choice",
        "instructions": "Which team should receive this request?",
        "criteria": {
          "billing": "Handles invoices, charges, and refunds",
          "identity": "Handles account access and passwords",
          "technical": "Handles application defects"
        }
      }
    }
  }'

The response contains a model and an answers object. Each choice answer contains the selected key and probabilities for all provided options. Output values vary with the input.

Python Example

import requests

payload = {
    "state": {"order": {"payment_received": True, "items_available": False}},
    "questions": {
        "can_ship": {
            "type": "noul",
            "instructions": "Is this order ready to ship?",
            "criteria": {
                "true": "The order can be shipped now.",
                "false": "The order cannot be shipped yet.",
            },
        },
        "urgency": {
            "type": "score",
            "instructions": "How urgently should inventory operations review this order?",
            "criteria": ["Low urgency", "Normal urgency", "High urgency"],
        },
    },
}

response = requests.post(
    "http://127.0.0.1:8080/v1/systemone", json=payload, timeout=1800
)
response.raise_for_status()
print(response.json()["answers"])

API Reference

`POST /v1/systemone`

Provide a state and a mapping of question IDs to questions:

{
  "state": "Relevant context or structured data",
  "questions": {
    "question_id": {
      "type": "choice",
      "instructions": "What should happen next?",
      "criteria": {
        "option_a": "First permitted action",
        "option_b": "Second permitted action"
      }
    }
  }
}

state: Text, structured data, or conversation messages.
questions: A non-empty object keyed by question ID, with up to 64 questions per request.
instructions: The question or rubric to apply.
criteria: A dictionary of 2–255 choices for choice; an ordered list of 2–10 levels for score; optional true and false descriptions for noul.
model (optional): Set to copernicus-57b if provided.

The response contains model and answers. For choice, choice is the highest-probability option and probabilities contains each option. For noul, noul is the probability of true. For score, score is the probability-weighted expected level index, with its distribution in probabilities.

`GET /healthz`

Returns the server's health and readiness status.

Serving options

python copernicus-engine/reax13/copernicus_serve.py --help

The reference server processes one external request at a time. The default input-size proxy limit is 40,000 tokens, and each rendered model input is limited to 32,768 tokens. Requests that exceed a limit are refused rather than truncated. Long or multi-question requests may take substantially longer than a single short request.

Evaluation

Measure	Result	Basis
Public Decision Index 0.3	75.34	Poindexter Labs' full public-suite run, 140,178 requests.
Latency median / mean / p80	270 / 827 / 839 ms	Poindexter Labs' 300-request public-suite sample, one NVIDIA RTX PRO 6000.

These are self-reported measurements, not the leaderboard maintainers' independent private evaluation or latency measurement. Performance depends on the workload and environment.

Intended Uses

Structured classification and routing with explicit options.
Decision support for software workflows and agent orchestration.
Research into decision models and probability distributions.
Verification and rubric-driven evaluation with appropriate validation.

Limitations and Responsible Use

A well-formed answer can still be wrong, particularly with ambiguous, incomplete, adversarial or unfamiliar inputs.
Probabilities are not guaranteed to be calibrated; validate calibration for your own tasks.
Answer options, their wording and ordering can affect results.
The reference server is text-only and does not accept image assets.
Independently assess reliability before using the model in consequential workflows; outputs should not be the sole basis for high-stakes decisions.
The reference HTTP server has no built-in authentication or rate limiting. Keep it bound to localhost unless suitable access controls are in place.

License

Copernicus (57B) is released under the Apache License 2.0. See LICENSE and the included third-party notices for details.

Citation

@misc{poindexterlabs_copernicus_57b_2026,
  title        = {Copernicus (57B)},
  author       = {{Poindexter Labs}},
  year         = {2026},
  howpublished = {Hugging Face Model Card},
  url          = {https://huggingface.co/Poindexter-Labs/Copernicus-57B}
}

Organization

Developed by Poindexter Labs. Learn more at poindexterlabs.ai.

Downloads last month: -; Downloads are not tracked for this model. How to track

Poindexter-Labs
/

Copernicus-57B