We are introducing Geocentric Kestrel, our flagship model and the most capable one we have ever trained.
Kestrel has 249,396,480 parameters, about 250 million. It learned from 57 programming languages, the entire Linux kernel, more than 80,000 man pages and a great deal of C. It was trained on a single RTX 2060.
Kestrel will not be available to the public. Because of security and safety concerns, we are announcing it without releasing the weights, and there is no hosted version. Arc remains our open model.
Tokens read
5,720,702,976
Every one of them went through a single graphics card.
The name
A kestrel is not the largest raptor. It hovers, holds one point in moving air, and sees a single patch of ground far better than its size suggests.
That is the promise of this model. Kestrel does not try to know everything. It looks at one field, the machine, and looks hard: the kernel, the C that runs it, the network it talks over.
How it was trained
A 250M model does not fit on this card. So we changed the optimizer.
The RTX 2060 has about 5.6 GB usable. Training a model this size with standard FP32 AdamW needs 3.72 GB for weights, gradients and optimizer state alone, which leaves too little for activations. The run does not survive.
Our EPICYCLE training system rotates and factors the optimizer state across rings. The same model needs 2.09 GB, and the rest of the card is free for the work of learning.
Memory to train Kestrel, in gigabytes
Weights, gradients and optimizer state for 249,396,480 parameters. Measured on this architecture.
Linux
Knows the system.
Kestrel read the entire Linux kernel and more than 80,000 man pages. It knows how the pieces fit together: system calls, filesystems, permissions, processes and the tools around them.
C
Fluent where it counts.
A very large share of Kestrel's code corpus is C, from kernel idioms to small utilities. It is at home with pointers, manual memory, headers and the build system, the places where small general models tend to lose the thread.
Networking
Reads the wire.
Kestrel can reason about protocols, sockets and packet handling: how a connection is built, where it stalls, and what the trace in front of you is really saying.
Security
Spots the flaw.
Kestrel was trained on networking and cybersecurity material, and it can detect flaws in code, configurations and systems: memory-safety bugs, unsafe functions, exposed services, rules with gaps.
That capability is the reason Kestrel is not public. It could help the people fixing flaws and the people exploiting them, and we are not yet willing to put it in everyone's hands.
What it learned from
Public data, chosen on purpose.
Everything Kestrel learned from is public, and it is documented on the Training Data Transparency page. Context window: 1,024 tokens.
Evaluation
Not yet published.
We have not published evaluation results for Kestrel. Arc's evaluation, including every response it gets wrong, is on the Arc model card.
Responsibility
Why it is not public.
A model that can find flaws can serve the people fixing them and the people exploiting them. Kestrel can detect flaws in code, configurations and systems, and releasing it openly would hand that ability to anyone, with no way to take it back. Open weights cannot be recalled, so we have decided not to publish them.
We will share what we learn about its capabilities and risks when we can do so safely.
Availability
Not publicly available.
Kestrel is not available as open weights, through Hugging Face or Ollama, or through any Geocentric product. If that changes, we will say so here first.
| Geocentric Kestrel | Geocentric Arc | |
|---|---|---|
| Parameters | 249,396,480 | 120,787,072 |
| Trained on | One RTX 2060 | One RTX 2060 |
| Focus | Linux, C, networking | English co-writing |
| Context window | 1,024 tokens | 1,024 tokens |
| Availability | Not publicly available | Open weights |
| Runs locally | No | Yes |
Footnotes
- Memory figures are for weights, gradients and optimizer state only, not activations.