Poindexter-Labs/Copernicus-31B

Copernicus (31B)

A system-one decision model by Poindexter Labs.

Website · Quickstart · API Reference · Citation

Overview

Copernicus is a 31-billion-parameter model developed by Poindexter Labs for applications that need structured decisions from natural-language context. Instead of requiring an application to interpret a free-form response, Copernicus can be served through a decision-oriented interface with explicit answer types and, where applicable, distributions over available choices.

The accompanying Python server exposes a /v1/systemone-compatible endpoint for evaluating a state or conversation against one or more questions. Supported decision types include:

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

Copernicus can support research and prototyping in agent routing, tool selection, structured classification, verification workflows, evidence assessment, and other decision-centric applications. Suitability for any specific production use case should be established through task-specific evaluation.

Model Details

Field	Value
Model	Copernicus (31B)
Developed by	Poindexter Labs
Organization	poindexterlabs.ai
Parameters	Approximately 31 billion
Primary interface	Structured decision requests (/v1/systemone)
Supported answer types	choice, noul, score
Reference implementation	copernicus_server.py and copernicus_layout.py

Quickstart

The commands below use the official Hugging Face model repository: Poindexter-Labs/Copernicus-31B.

1. Install dependencies

Python 3.10+ and a suitable PyTorch/Transformers environment are recommended. Serving a 31B checkpoint requires substantial accelerator memory; plan hardware and precision settings accordingly.

pip install -U torch transformers accelerate requests

Place the following files together in your working directory:

copernicus/
├── copernicus_server.py
└── copernicus_layout.py

2. Start a server

Option A — Hugging Face Transformers (text-only):

python copernicus_server.py \
  --model Poindexter-Labs/Copernicus-31B \
  --backend hf \
  --host 127.0.0.1 \
  --port 8080

This path loads the checkpoint in-process and supports text-based choice, noul, and score questions.

Option B — SGLang (separate inference backend):

Start SGLang in a separate terminal with a configuration appropriate for your available GPUs:

python -m sglang.launch_server \
  --model-path Poindexter-Labs/Copernicus-31B \
  --host 127.0.0.1 \
  --port 9080

Then run the Copernicus API adapter:

python copernicus_server.py \
  --model Poindexter-Labs/Copernicus-31B \
  --backend sglang \
  --url http://127.0.0.1:9080 \
  --box-coords yxyx \
  --host 127.0.0.1 \
  --port 8080

Install a compatible version of SGLang separately. The example command assumes that its model loader supports the published checkpoint and that available GPU memory is sufficient. The API adapter and the underlying inference engine are separate processes in this configuration.

3. Verify the server

curl http://127.0.0.1:8080/health
curl http://127.0.0.1:8080/v1/models

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 has this structure (the values below are illustrative, not measured model output):

{
  "id": "jev-example",
  "model": "Copernicus-31B",
  "answers": {
    "route": {
      "type": "choice",
      "choice": "billing",
      "probabilities": {
        "billing": 0.91,
        "identity": 0.04,
        "technical": 0.05
      },
      "confidence": 0.69
    }
  },
  "usage": {}
}

Do not treat the example probabilities as validated calibration estimates. Actual responses, token usage, and confidence values depend on the model and runtime.

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=120,
)
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, structured data, or a conversation",
  "questions": {
    "question_id": {
      "type": "choice",
      "instructions": "What should happen next?",
      "criteria": {
        "option_a": "First permitted action",
        "option_b": "Second permitted action"
      }
    }
  }
}

• state: Natural-language text, structured data, or an array of role/content conversation messages.
• questions: A non-empty object keyed by question ID; the reference server accepts up to 64 questions per request.
• instructions: The question or rubric to apply.
• criteria: A dictionary of answer choices for choice; an ordered list of levels for score; optional true/false descriptions for noul.
• assets (optional): Named image assets for supported multimodal requests. This capability depends on the backend; see limitations below.
• model (optional): An identifier echoed in the response; it does not switch the checkpoint loaded by the server.

Response fields include id, model, answers, and usage. For choice, the returned choice is the highest-probability key, and probabilities maps each provided key to its estimated probability. For noul, noul is the estimated probability of true. For score, score is the probability-weighted expected rubric index, accompanied by a probability distribution and legend.

GET /health

Returns service status and selected serving configuration.

GET /v1/models

Returns the model identifier exposed by the server.

Serving options

python copernicus_server.py --help

Useful flags include:

Flag	Description
--backend hf / --backend sglang	Select the inference backend.
--temperature 1.0	Control the temperature used when converting option log probabilities into a distribution.
--workers 16	Set parallel question-scoring workers.
--read-twice / --no-read-twice	Enable or disable repeated text-only prompt layout for eligible requests; enabled by default.
--twice-max-tokens 3000	Set the maximum first-pass token count eligible for repeated reading.
--header	Include the request's question stems ahead of the state.
--referenced-fields	Add referenced structured-state values to question prompts.
--box-prompt	Choose a bounding-box prompt style when using a compatible multimodal backend.
--box-coords yxyx	Interpret generated box coordinates as [ymin, xmin, ymax, xmax]. Use with the default locate prompt for Copernicus on SGLang; the API then returns standard normalized top, bottom, left, and right fields.

The reference server scores answer-label token probabilities rather than generating a conventional long-form response. Its output format is designed for applications that require explicit choices.

Intended Uses

• Structured classification and routing with explicitly defined options.
• Decision support for software workflows and agent orchestration.
• Research into probabilistic decision interfaces.
• Verification, ranking, and rubric-driven evaluation with appropriate validation and human oversight.

Limitations and Responsible Use

• No guarantee of correctness. A well-formed decision can still be wrong, including when the input is ambiguous, incomplete, adversarial, or out of distribution.
• Probabilities are not guarantees. Option probabilities and entropy-based confidence should not be interpreted as empirically calibrated risk scores without independent calibration tests.
• Dependence on the options provided. Changing option order, wording, or available alternatives can change the outcome.
• Task-specific evaluation is required. Independently validate reliability, error patterns, robustness, and latency before deploying the model in a consequential workflow.
• Not a substitute for professional judgment. Do not use outputs as the sole basis for decisions affecting medical care, legal rights, employment, credit, public safety, or similarly high-stakes outcomes.
• Multimodal support varies. The supplied Transformers backend supports text-only scoring. Image assets and bounding-box generation depend on a compatible SGLang backend; bounding-box outputs should be considered experimental and independently tested.
• Infrastructure requirements. Memory, speed, throughput, and compatibility vary with quantization, GPU hardware, software versions, and serving configuration.
• Security. The reference HTTP server provides no built-in authentication or rate limiting. Bind to localhost by default and place behind suitable access controls before exposing it to other networks. URL-based asset fetching is disabled by default.

License

Copernicus (31B) is released under the Apache License 2.0.

The model weights and associated model files are distributed under the terms of the Apache 2.0 license. See the LICENSE file for the full license text.

Copyright 2026 Poindexter Labs.

Third-party components and dependencies may be subject to their respective licenses.

Citation

If you use Copernicus in research or software, cite the model card and name Poindexter Labs as the developer:

@misc{poindexterlabs_copernicus_2026,
  title        = {Copernicus (31B)},
  author       = {{Poindexter Labs}},
  year         = {2026},
  howpublished = {Hugging Face Model Card},
  note         = {31B system-one decision model},
  url          = {https://huggingface.co/Poindexter-Labs/Copernicus-31B}
}

Organization

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