Four research projects, each with one concrete, measured result instead of a page of adjectives. Where a project's own internal review flagged a limitation or an overclaim risk, that limitation is printed here too — not filed away.
Problem. Attention's cost grows with context length, and most linear-recurrence alternatives trade away exactness for speed — the fast "parallel scan" form of the recurrence doesn't always match what a step-by-step (sequential) computation would have produced.
Approach. ORBIT uses an orthogonal (Cayley/Givens) recurrence combined with a gated delta-rule episodic memory bank, keeping state size constant per step (O(1)) regardless of sequence length.
Status & limitations. ORBIT superseded an earlier internal architecture (codenamed PRISM) after PRISM's own internal critique found several of its mechanisms contributed little in practice. ORBIT has been trained and measured at small scale (up to roughly 28M parameters) on CPU; the 10M–1B parameter range is the design target, not yet an achieved result. Its own benchmark log is explicit that instruction-following is "not yet reliable" — this is a research architecture, not an assistant.
// what we actually measured scan_vs_sequential_rmse ≈ 5e-7 // the fast parallel form matches the exact // step-by-step form to within numerical noise wikitext2_ppl orbit 8.44 baseline 7.53 // published reference, still ahead trained_params ~28.6M largest CPU run to date
// UAX #29 grapheme-boundary conformance pass_rate 94.78% (726 / 766 tests) decode_speed ~316 MB/s (CPU, aggregate) encode_speed ~31 MB/s roundtrip decode(encode(x)) == x
Problem. Most production tokenizers are not byte-exact and are rarely benchmarked against the Unicode text-segmentation standard directly — grapheme-boundary errors quietly corrupt multilingual and emoji-heavy text.
Approach. A tokenizer written in C with a guarantee that decoding an encoding always reproduces the original bytes exactly, benchmarked directly against the Unicode UAX #29 conformance suite rather than an internal proxy metric.
Status & limitations. Real, buildable, independently benchmarked — and by its own documentation "not yet enterprise ready." It trails standard subword tokenizers on plain-text compression by a few percent; its advantage is measured specifically in grapheme-conformance and structured-token handling, not raw compression.
Problem. A model trained on new data typically overwrites what it knew before — "catastrophic forgetting." The usual fix is storing large numbers of raw past examples to replay, which costs memory that scales with how much you want it to remember.
Approach. Instead of replaying raw examples, distill what was learned into a small number of compact prototypes and replay those.
Status & limitations. This result is specific to the Split-MNIST continual-learning benchmark and comes with real run-to-run variance (forgetting measured 98.4–98.9% naive, 23.7–25.4% distilled across runs). Our own internal review of this project was explicit and we're repeating it here rather than softening it: do not read this as a claim about general intelligence, "our own NLP," or a chatbot capability — it is a narrow, specific continual-learning result, evaluated on one standard benchmark.
// Split-MNIST continual learning naive_forgetting ~98.7% distilled_forgetting ~24.8% distilled_memory 10 prototypes, 31 KB raw_replay_memory 200 exemplars, 627 KB // fewer bytes of memory, less forgetting
Problem. An LLM's output is usually trusted directly as the basis for the next action an agent takes — a tool call, a decision, a write. That's the same failure mode as trusting raw sensor data without validation.
Approach. Route model output through typed evidence contracts and validators before it can influence anything, and require a "tool-proof obligation" to discharge before any tool call is allowed to fire. Status: a working, exercised prototype (real session logs exist) — not yet benchmarked, so we're not publishing an accuracy number for it. What we can say is that the mechanism — typed contracts gating tool calls — is implemented and running, not just designed.
A non-Transformer architecture using energy minimization and wave-interference scoring in place of attention — the research line behind our patent-pending NOVA architecture (see Patents & IP). The architecture is implemented in a working engine; we are not yet publishing latency or model-size numbers for it while our internal benchmark methodology is being validated.
A set of smaller internal model variants exploring different efficiency tradeoffs. This is source-and-design-stage work — no benchmarks are published for it yet, so there's nothing to report here beyond the fact that it's ongoing.
This page will be updated as each project's benchmark methodology and results mature — we'd rather publish four honestly-scoped results than fourteen unverified ones.