Copernicus (31B)

Copernicus (31B)

Returns structured decisions from plain-language context: pick one option, judge a yes or no claim, or score an item against a rubric. For developers building agent routing and classification.

Made by Poindexter-Labs on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Copernicus is a 31B-parameter decision model from Poindexter Labs. Your application sends it a situation and one or more questions, and it answers with an explicit type, such as a chosen option with probabilities, instead of free-form text. A small Python server in the model repository exposes this through a /v1/systemone endpoint.

Who it suits: It suits developers who need a program to act on a model's answer without parsing a written reply.

Industry | Who uses it | How they use it | Example
Customer support | Teams that route tickets | Send a ticket as the situation and ask a choice question | A team asks which of billing, identity or technical should take a ticket
Software development | Developers building agents | Use choice questions for agent routing and tool selection | An agent asks which tool fits a request
Research and verification | People building verification and evidence workflows | Use noul or score questions to judge a claim or an item | A researcher scores an answer against an ordered rubric

Anyone who needs a model that writes free-form replies can skip it, because this one is built to return structured decisions.

Where to use it: It runs as a local server that your own code calls over HTTP.

• Windows, macOS or Linux: download the files with Python and the Hugging Face tools
• Your own application: sends decision requests to the copernicus_server.py endpoint
• The Hugging Face Transformers backend: loads the model inside the server, text only
• SGLang: a separate inference backend that the Copernicus adapter can talk to

Use case | Who | What they get back
Agent routing | Agent builders | A selected option with probabilities and a confidence value
Structured classification | Developers | A choice or a score instead of a written paragraph
Verification and evidence checks | Researchers | A probability that a statement is true

How to set it up: You need a few things first.

• Python 3.10 or newer, and a suitable PyTorch and Transformers environment
• Substantial accelerator memory, since the weights are about 62.5 GB in BF16 or about 15.6 GB at 4-bit as an estimate
• The reference files copernicus_server.py and copernicus_layout.py, placed together in your working directory
• SGLang installed separately, only if you choose that backend

1. Install the Python dependencies.
2. Download the model files.
3. Put copernicus_server.py and copernicus_layout.py together in one working directory.
4. Start the server with the backend you picked.
5. Check that it answers on its health and models endpoints.

pip install -U huggingface_hub
hf download Poindexter-Labs/Copernicus-31B
pip install -U torch transformers accelerate requests

How to use it: Start the server, then send it decision requests. The card's first option loads the checkpoint inside the server through Hugging Face Transformers and handles text questions.

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

The second option starts SGLang in its own terminal, then runs the same script with the sglang backend and the address of that SGLang process. After either option, check the /health and /v1/models endpoints, then post a request to /v1/systemone. Each request holds a state and a set of named questions, and each question has a type, instructions and criteria.

Type | Purpose | Output
choice | Pick one option from an explicit set | Selected key, probabilities and confidence
noul | Judge a yes or no proposition | Probability that it is true
score | Assess an item against an ordered rubric | Expected score, level probabilities and confidence

Tool | What it does
copernicus_server.py | Runs the API server with the hf or sglang backend
copernicus_layout.py | Part of the reference implementation, kept beside the server
/v1/systemone | Takes a state plus questions and returns structured answers
/health and /v1/models | Let you verify that the server is up

Example: A customer says they were charged twice for one order. You post that as the state, with one choice question asking which team should handle it, and the options billing, identity and technical. A choice answer comes back with the selected key, the probabilities and a confidence value. The card marks its own sample response as illustrative, not measured.

For newcomers and experts: Think of this as a model that answers pick-one questions in a form a program can read. You give it a short situation and the options, and it returns the choice plus numbers for how sure it is. Your first small step is to start the server with the Hugging Face backend and check its health endpoint.

It is built on PelaAI/KnowLine-31B-Gen1 and exposes a decision interface instead of chat. The Transformers path runs in-process, while the SGLang path splits the adapter and the inference engine into two processes. The trade-off is hardware: a 31B checkpoint needs a lot of accelerator memory, so precision and GPU choices matter.

Your app sends a state and questions
copernicus_server.py handles the request
The 31B model runs through HF or SGLang
You get structured answers back

Good to know:

• The card advises testing for your own task before relying on it in production.
• The Transformers path is text only. The SGLang route needs a compatible SGLang version and enough GPU memory.
• Research and prototyping are the uses the card has in mind, for example routing between agents or choosing a tool.

Title: Weight size in GB
BF16: 62.5 GB
4-bit estimate: 15.6 GB

• License: Apache 2.0, as the Hugging Face record lists it.
• Cost to run: none named, no API key, account or paid service is mentioned.
• Data it reaches: it downloads files from Hugging Face. In the card's examples the server listens on a local address and receives the text you send it.
• Not for: production use without your own task-specific evaluation, as the card advises.

On Hugging Face, 13 November 2026

• Task: text classification
• Library: transformers
• Parameters: 31.3B
• Weights: about 62.5 GB in BF16; about 15.6 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 75
• Likes: 3
• License: apache-2.0
• Languages: en
• Based on: PelaAI/KnowLine-31B-Gen1
• Tags: transformers, safetensors, gemma4, image-text-to-text, decision-model, decision-index, multimodal, system-one, text-classification

Links

• Model: https://huggingface.co/Poindexter-Labs/Copernicus-31B
• Files: https://huggingface.co/Poindexter-Labs/Copernicus-31B/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Poindexter-Labs/Copernicus-31B

Then follow the usage in its model card. Nothing in this kit runs by itself.