Black Sheep AI

Core Cortex · The Reasoning Layer

Frontier reasoningon smallerGPUs

Core Cortex is the reasoning layer of the Bounded AI Architecture (BAA): full-capability frontier models, shrunk to fit smaller GPUs with their reasoning kept and measured. Name the GPU memory you have and we build the model to land on it. Bind a Cortex model to Paddock and it reasons over the modules it is allowed to see. When a better model ships, we compress that one and you bind it instead.

The Reasoning Layer

Bound, not baked in

Cortex holds no facts of its own. Knowledge stays in Paddock's Data Modules, and the model bound on top only reads what its modules allow. That is what makes the reasoning layer swappable.
Stateless

The model holds no facts

Your knowledge lives in modules, permissioned one by one. Cortex reads them at answer time and remembers nothing between questions, so there is nothing in the weights to delete, date, or permission.
Swappable

Swap it in one operation

When a better frontier model ships, we compress that one to the same budget and you bind it in place of the old one. Same modules, same permissions, same citations. Nothing in the plane changes.
Certified

Reasoning kept, and certified

Compression that keeps the size and loses the reasoning is worthless at this layer. Every Cortex build carries Watchman's five certificates, and the reasoning gate is a hard one: fail it and the build does not ship.

Three properties, and the third is the one that surprises people.

What you get

It is fitted to your model

An oscilloscope tracing a signal

It is fitted to your model

Every build is made for the specific model in front of it, rather than produced by one rule applied to every model. That is where the quality you keep comes from.

It lands on your budget

Boxes of different sizes packed into a crate

It lands on your budget

Give us a memory ceiling and the build lands under it, with as much of the model’s quality kept as that budget allows. No trial and error on your side, and no guessing at which settings will fit.

It needs no data

Static noise on a screen

It needs no data

No calibration corpus. Nothing to license, nothing to leak, and no quiet dependence on text that resembles your users’. Nothing of yours is needed to build the model.

Measurements

What we measured

Same model, same file size, same evaluation. The only honest way to compare two compressions.
  • Against the reference implementation

    Matched to within 1.7% of the file size of llama.cpp’s own 3-bit mix on a 27B model, our build scored 5.5% lower perplexity, ahead on 37 of 40 evaluation chunks, which at that sample size is not a coin toss.
  • On a 16 GB card

    That 27B model at 12.6 GB holds a 32,000-token context in 14 GB of VRAM and answers retrieval questions across it perfectly: 32 of 32, including two-hop. At 64K and 128K it still fits, with the cache compressed.
  • Against gradient-based methods

    Matched byte-for-byte against a leading method that needs gradients and far more GPU memory, our build is a statistical tie. We do not claim to beat it. We claim to equal it on models where that method will not fit.

TARGET : 12.6 GB

0 GB16 GB

12.6 GB

MODEL ON DISK

32K

CONTEXT HELD

16 GB

GPU MEMORY

HARDWARE : ONE 16 GB GPU, THE CLASS EVERY CLOUD RENTS BY THE HOUR

Hardware

The hardware you already rent

A 16 GB accelerator is the cheapest useful GPU on every major cloud, and it is the class Cortex targets.

AWS

g4dn.xlarge: 16 GB NVIDIA T4. The entry GPU instance, available in every region and on spot pricing.

Azure

NC4as_T4_v3: 16 GB NVIDIA T4, the smallest GPU size in the NC family.

Google Cloud

g2-standard-4: 24 GB NVIDIA L4, with headroom above what the model needs.

The output is an ordinary GGUF file. It runs under unmodified llama.cpp, Ollama or LM Studio, on any CUDA GPU, with no runtime of ours anywhere in the path. Our published measurements were taken on a 16 GB NVIDIA card on our own hardware; the cloud instances above are the same class of accelerator.

Scale

It does not stop at small models

Eighty compressed models are published and downloadable, and the largest is not a demonstration.
A full rack of storage drives
01

To 447 GB

Trillion-parameter-class mixture-of-experts models, compressed and published: Kimi K2.6, GLM-5.x, DeepSeek-V3.2, a 397B Qwen. These are files people download, not slideware.
A compact desktop workstation
02

Memory that does not scale with the model

You do not need a machine big enough to hold the model. An 803 GB model was analysed in nine minutes on one machine.
A camera lens and film strip
03

Not only language models

The same process ships image and video diffusion models; it is not specific to transformers. We publish those builds; we have not yet published quality measurements for them, so we are not claiming any.