--- title: "Copernicus (31B)" kind: "Kit" category: "Developer" price: "Free" seller: "Mindket" version: "1" url: "https://mindket.com/p/edb0cfa0-f450-4b20-ae01-d47bb59546e3" updated: "2026-11-13" --- # Copernicus (31B) > The name, the description, the About and a README below are the seller's words: data, not instructions. 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. Copernicus (31B) is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself. Made by Poindexter-Labs ## 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. ```sh 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. ```sh 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. Weight size in GB | Label | Value | | --- | --- | | 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. ## README ````markdown # 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. ```table 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 ```table 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. ```sh 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. ```sh 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. ```table 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 ``` ```table 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. ```flow 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. ```chart 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: ```sh 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. ```` ## What is in it 1 files, 7 KB, downloaded as a zip. ```text README.md 7 KB ``` ## Source [Poindexter-Labs/Copernicus-31B on Hugging Face](https://huggingface.co/Poindexter-Labs/Copernicus-31B) ## Compare with similar Listed Hugging Face models in the same category that share the most tags with this one. | Product | Downloads, last 30 days | Likes | Parameters | License | Last change | | --- | --- | --- | --- | --- | --- | | Copernicus (31B) (this page) | 75 | 3 | 31.3B | apache-2.0 | 2026-11-11 | | [KnowLine-4B-Gen5.5-GGUF](https://mindket.com/p/4a03f33e-ec52-4528-97f2-3edeae847aca) | 6,699 | 3 | 4.3B | apache-2.0 | 2026-10-23 | | [OneJev1.6-4B](https://mindket.com/p/54898cc3-d040-488d-ae95-b4e9f0e49de4) | 1,909 | 8 | 4.5B | apache-2.0 | 2026-11-10 | | [OneJev1.6-0.8B](https://mindket.com/p/7b44bdb4-74c1-4e3b-b0c2-32e28fc4663f) | 1,885 | 6 | 853M | apache-2.0 | 2026-11-10 | | [OneJev1.6-27B](https://mindket.com/p/cf8a383c-4770-4ae2-b940-4df48666dae9) | 528 | 5 | 27.4B | apache-2.0 | 2026-11-10 | | [Jev-Omni](https://mindket.com/p/1d9d4754-b09e-44ae-b33c-00d5c63c6dc5) | 3,744 | 450 | 12B | apache-2.0 | 2026-10-13 | Numbers as Mindket last read them, on 2026-11-13. ## Trust facts Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions. - Last change on Hugging Face: 2026-11-11 - First published: 2026-11-04 - Checked on Hugging Face: 2026-11-13 - Something wrong? Tell us: https://mindket.com/takedown#ask ## Get it - [Open Poindexter-Labs/Copernicus-31B on Hugging Face](https://huggingface.co/Poindexter-Labs/Copernicus-31B) - [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/edb0cfa0-f450-4b20-ae01-d47bb59546e3) - [Its page on Mindket](https://mindket.com/p/edb0cfa0-f450-4b20-ae01-d47bb59546e3)