The runtime · Models
Every model, on purpose.
Perslis does not pick a favourite model and hope. It drives a curated roster — American and Chinese frontier models, airtight local models, and a symbolic engine with no LLM at all — and routes each request to the one that is actually best for the job.
No single model is best at everything, and the frontier moves every month. So Perslis is model-agnostic by construction: it speaks to each provider through one uniform protocol, and assigns every model a role — build, review, adversary, deep reasoning, a mandatory final gate on high-stakes work — instead of trusting one brain. When a model refuses or stalls, it hot-swaps to another mid-request. When correctness matters, a symbolic engine (Jeeves) checks the reasoning with no LLM in the loop. And for private or regulated data, an airtight tier runs entirely on your own machine — nothing leaves. You bring the keys; you own the routing; no vendor owns you.
Figure 1 — The roster at a glance. Every model earns its place by the role it plays in the loop, not by brand.
Why every single one
Picking one model is a bet you keep losing. The best coder this quarter is not the best reasoner; the model that writes beautifully is not the one that catches its own errors; the cheapest model that is right 95% of the time is not the one you want signing off a legal answer. Perslis treats models the way a good team treats people — by role:
- A builder drafts the work — fast, local-first where it can be.
- Reviewers critique it — ideally from a different lab, so blind spots don't overlap.
- An adversary tries to break it — red-teaming, not rubber-stamping.
- A final gate — the strongest available model — signs off anything high-stakes.
- A symbolic oracle checks the logic for contradictions with no LLM at all.
Using American and Chinese frontier models is not a slogan — it is how you get independent review. Two models from the same lab share training data and share mistakes; a DeepSeek reviewing an OpenAI build disagrees for real reasons. That disagreement is the signal.
🇺🇸 American frontier
OpenAI — GPT-5.5
The default final gate. When a task is flagged high-risk — a legal or compliance answer, an irreversible change, anything that ships to a real person — Perslis requires a frontier model to sign off, and GPT-5.5 is the strongest generalist for that seat. It is broad, steady, and rarely the reason a plan falls over.
Why Perslis uses it: the mandatory high-risk final gate. It is the last reviewer before "done," and it is deliberately a different model from whoever built the work.
Anthropic — Claude
The careful builder and long-form reasoner. Claude is strong at reading large, messy contexts, writing that a human actually wants to read, and following intricate instructions without cutting corners — which makes it a first-class choice for building and for high-trust drafting.
Why Perslis uses it: an alternative frontier builder/reviewer, and the hot-swap target when another model refuses or drifts. Two frontiers means one is always available.
Google — Gemini 2.5 Flash
The balanced default. Flash is fast and inexpensive while staying genuinely capable, so it carries the everyday load — status work, summaries, routine builds — where paying frontier prices would be waste.
Why Perslis uses it: the default profile for ordinary work. Good enough to be trusted, cheap enough to be the baseline, fast enough to feel instant.
xAI — Grok
The adversary. Grok is pointed at a finished piece of work with one instruction: try to break it. It defaults to skeptical, which is exactly what you want from a red-teamer — a reviewer whose job is to refute, not to agree.
Why Perslis uses it: the adversarial seat in the review council. When Perslis needs a finding disproven before it trusts it, this is the model it hands the claim to.
🇨🇳 Chinese frontier
DeepSeek — DeepSeek Reasoner
The critic. DeepSeek's reasoning models are exceptionally strong at step-by-step verification and at finding the flaw in an argument, at a fraction of frontier cost. From a different lab and a different training corpus than the American models, its disagreements are independent — the most valuable kind.
Why Perslis uses it: the primary reviewer in the council. It cross-checks an American build with a genuinely different mind, which is where real errors surface.
Xiaomi — MiMo
The deep reasoner. MiMo is routed to the hard, tangled problems — architecture, root-cause analysis, multi-step planning — where you want a model that will sit with the problem rather than answer the first thing that sounds right.
Why Perslis uses it: the "deep" profile for complex reasoning tasks, and a second independent Chinese perspective alongside DeepSeek.
Alibaba — Qwen (2.5 Coder)
The local-first builder — and one of the airtight models below. Qwen Coder is small enough to run on your own machine yet strong enough to draft real code, so Perslis reaches for it first on coding work: the fast, private option before it spends a token on a paid API.
Why Perslis uses it: local-first coding through Ollama. It keeps everyday work fast, free, and airtight, escalating to a cloud model only when the job needs it.
Moonshot — Kimi
The long-context specialist. Kimi's very large context window suits whole-repository reads and long-document work, giving Perslis another independent Chinese option for tasks that are more about breadth than depth.
Why Perslis uses it: an optional reviewer/reader for very large inputs, and more redundancy in the roster so no one provider is a single point of failure.
🔒 Airtight models
An airtight model is one where nothing leaves your machine — no API call, no network, no third party. Perslis runs these through a local server (Ollama), so the model weights, your prompt, and the answer all stay on hardware you control. That is what makes Perslis usable on data that legally or practically cannot go to a cloud: patient records, privileged material, classified or air-gapped systems, or simply a laptop with no internet.
- Local LLMs — Qwen, Llama-class, and other Ollama-hosted models run entirely offline. Slower and smaller than the frontier, but private and free, and often all a task needs.
- Jeeves — the symbolic engine below is airtight by nature: it has no model to call and no network to reach. It is deterministic and offline, end to end.
First-party airtight model — TinkyBrain v6
Perslis has no model to sell — but that doesn't mean we don't build them. TinkyBrain v6 is a first-party, fully open on-device model we trained for the airtight tier: a 25.5M-parameter transformer that runs entirely offline, small enough to answer on a 2017 Kindle Fire in under three seconds and on a modern ARM64 phone in about a second. It ships as quantised ONNX — a 24 MB int8 build — with no network, no keys, and no data leaving the device. It is a concrete proof of the airtight claim: a real model you can download, inspect, and run yourself.
Its job is augmentative and alternative communication (AAC): given a prompt it generates six semantically distinct response tiles, so a non-verbal user — a child with autism or apraxia, a stroke survivor with aphasia — can tap to speak. That is a domain where the airtight tier isn't a preference but a requirement: the data is personal, and it must never leave the device.
Figure 2 — TinkyBrain v6 at a glance. A model small enough to be genuinely airtight, and good enough to be genuinely useful.
| Spec | TinkyBrain v6 |
|---|---|
| Architecture | Transformer — 6 layers, 8 heads, depth 512, feed-forward 1024 |
| Parameters | 25.5M |
| Vocabulary / context | 12,599 tokens (PEEL conditioning markers) · 64-token max sequence |
| Formats | ONNX — int8 quantised (24 MB, production) and fp32 (reference) |
| Training | 41,519 child-corpus conversational pairs · 161 min on an M4 |
| Quality | Diversity 0.975 · Coherence 0.838 |
| Speed | ~2.9s / 6 tiles on a 2017 Kindle Fire · 0.6–1.2s on modern ARM64 |
| Runtime | ONNX Runtime — offline, no keys, no network |
| License | CC-BY-NC-SA 4.0 (non-commercial; commercial use by permission) |
View TinkyBrain v6 on Hugging Face — weights, tokenizer, and model card →
Why Perslis uses it: it is the airtight tier made concrete. When a task is small, sensitive, and offline — the AAC case is the archetype — Perslis can route to a first-party model that provably keeps everything on the device, and point at open weights anyone can audit.
🧠 Symbolic — Jeeves (no LLM)
Every model above is a neural network that predicts the next token — brilliant, but probabilistic, and capable of being confidently wrong. Jeeves is different in kind. It is a symbolic engine: a deterministic rule-and-knowledge-graph system with no LLM in the loop at all. It does not guess. Given the same facts, it returns the same answer, every time, with an explanation you can trace rule by rule.
In the loop, Jeeves runs as an oracle and a contradiction checker. When an LLM proposes an answer, Jeeves can test it against a body of known facts and rules: does this conclusion follow? Does it contradict something we already hold true? Because it is symbolic, its verdict is not another opinion to weigh — it is a proof, or a counter-example. That is exactly the check a probabilistic model cannot give about itself.
Why Perslis uses it: correctness you can trust needs something outside the neural network to check it. Jeeves is that something — a fast, offline, deterministic second opinion that turns "the model said so" into "here is why it holds." It is also fully airtight: no keys, no network, no data leaving.
The point
The roster is the product's spine. Any one model will fail you eventually — refuse, hallucinate, get deprecated, price you out, or simply have a bad day. Perslis is built so that never matters: a different model picks up the work, a model from another lab checks it, a symbolic engine proves the parts that must be proven, and an airtight tier handles anything that cannot leave the building. You are not betting on a model. You are running a team.