Sixty owned primitives, frameworks, and architectures for training, creating, and fine-tuning frontier models — Hyperbridge's in-house counterpart to the open LoRA / QLoRA / RLHF ecosystem. Every name here is coined and owned; every mechanism underneath is real, current engineering — now grounded in the 2026 SOTA and a dedicated Acceleration Frontier for the 100× speedups.
Owned & operated by Hyperbridge Digital · The forge for sovereign models — train, create, fine-tune.
Bend a frozen giant to your domain without retraining it — low-rank grafts, quantized adapters, and surgical weight edits that ship in megabytes, not gigabytes.
Inject a sovereign low-rank delta into frozen weights — train 0.2% of params, keep all the capability.
LoRA is like editing a blueprint by annotating in the margins — the original is untouched, the delta is thin, and you can swap annotations per job.
Graft trainable adapters onto a 4-bit frozen base — fine-tune giant models on a single GPU.
QLoRA is like renting a tiny apartment by compressing your furniture to 4-bit flatpacks — you assemble only the piece you need right now.
The tempered evolution of QLoRA — quantization-aware grafts on a rotated 4-bit base, hardened with fused kernels and low-rank gradients. ~10× leaner, faster and sharper than vanilla QLoRA.
Don't just freeze the giant in 4-bit and bolt on adapters — temper it: rotate out the outliers, pre-pay the quantization error into the adapter at init, decompose the update, and fuse every kernel, so the whole loop runs an order of magnitude leaner.
Decompose each weight into magnitude and direction — tune both, fine-tune like full training.
DoRA adjusts a compass needle by changing both its length and its direction independently, rather than nudging the whole needle as one object.
Steer a frozen model with learned virtual tokens prepended to every attention layer — no weights touched.
Prefix-tuning staples a learned memo to the top of every blueprint page — the plans are untouched but the worker reads context first at every step.
The math of folding trained adapters back into base weights — and weighted-merging many into one.
Merging adapters is like mixing paint — weighted blending is cheap, but once colors conflict, averaging smears both rather than keeping either sharp.
Drive weights and KV-cache to 4 bits and below without losing the plot. Post-training quant, pruning, and quantization-aware training.
4-bit information-theoretic weight casting that holds accuracy where naive INT4 collapses.
NF4 is a ruler whose tick marks cluster near zero and spread at the extremes, matching where most weight values actually land.
Quantize the quantization metadata itself to claw back the last fraction of a bit.
Double quantization is quantizing your receipts after you've already quantized your groceries — real savings, but only if the receipts were a big share of the wallet.
Post-training low-bit quant that compensates each weight against its neighbors' error.
GPTQ is a row of dominoes — knock each weight into its nearest quantized slot, then nudge downstream weights to absorb the topple before moving on.
Hardware-aligned 2:4 structured sparsity that physically halves the weight matrix.
2:4 sparsity enforces that no more than 2 of every 4 weights survive, so the hardware can skip the absent ones without even looking.
Per-channel low-bit KV-cache quant that lets context length scale past the memory wall.
KV-cache quantization stores attention history in shorthand — you lose nuance but the binder fits in the bag and you reconstruct on demand.
The model is the dataset. Curation, dedup, synthetic generation, tokenization, and curriculum — the upstream that decides everything downstream.
Near-duplicate culling at corpus scale via fingerprint-band collision.
A probabilistic fingerprint that turns document similarity into a coin-flip collision: shared content lands in the same bucket.
Self-instruct synthetic data forged from a seed of human exemplars.
A snowball rolling downhill: seed a teacher with a few human examples and let it write its own training data, expanding with each pass.
A byte-level merge lattice that learns the model's vocabulary from the corpus.
A greedy zipper that repeatedly snaps the two most common adjacent symbols together until the vocabulary is full — frequency becomes merge order.
The per-source sampling weights that govern what the model actually sees.
Domain weights are the dial setting how many effective epochs each source sees, independent of its raw token count.
Difficulty-ordered data scheduling from easy foundations to hard frontier.
Teach the model like a student: start with solved examples, introduce hard problems only once the fundamentals are solid.
Teach taste, not just tokens. Reward models, direct preference optimization, and constitutional self-critique.
Self-critique loops temper a model against your written charter, no human raters needed.
The model becomes its own editor: it reads a principle, critiques its own draft, then rewrites to comply before a judge scores the pair.
A frozen scalar critic over the policy that scores human-ranked pairs into a reward field.
A learned scorecard that reads two responses and assigns numbers so the human-preferred one always comes out higher — trained purely on comparisons.
Skip the reward model — optimize the policy straight from preference pairs in closed form.
Rewrite the RLHF objective algebraically until the reward model cancels out, leaving a classification loss that nudges the policy straight from preference pairs.
The signed preference gap a model holds between a winning and losing response.
The margin is the scoreboard gap — not just whether pairs rank correctly, but how confidently and widening a separation training is actually achieving.
Sample N, keep the best by reward, fine-tune on the survivors — alignment without RL.
Generate a shortlist per question, let a judge pick the best, train only on winners — iterate until top answers come from scratch.
Pour a large model into a small one; fuse many checkpoints into one. Logit distillation and weight-space merging.
Pour a teacher's full belief into a smaller student through soft-label flux.
The teacher whispers not just the answer but its full confidence distribution, giving the student far richer signal than a one-hot label.
Match the teacher's hidden geometry, not just its words.
Copy not just the teacher's essay answers but its scratch-pad, forcing the student through the same intermediate steps.
Fuse many fine-tunes into one checkpoint by reconciling their task vectors.
Arithmetic on skill deltas: add the skills you want, subtract what you don't, then reconcile sign conflicts before applying the result.
Average many checkpoints into one stronger model — no inference-time cost.
Independently fine-tuned runs of the same init land in one loss basin, so their centroid is flatter and more general than any single run.
Upcycle a dense checkpoint into a sparse Mixture-of-Experts.
Clone the dense FFN into N expert slots and train a router to divide labor — parameters multiply, but each token pays for only two experts.
Give the model the world it wasn't trained on. Vector retrieval, external memory, and attention that scales to book-length context.
A two-stage retrieval lattice that grounds generation in your own corpus, not the model's guesses.
A library lookup bolted onto a frozen LLM: the retriever finds the relevant pages and the model reads them, instead of recalling from weights.
Dense semantic vectors that let meaning, not keywords, drive retrieval.
A bi-encoder maps every text to a point where semantic closeness is geometric closeness — retrieval becomes nearest-neighbor search on that map.
Stretch a trained context window far past its native length without retraining from scratch.
A frequency-band zoom-out: compress the slow rotations that overflow the original window while leaving the fast local-position signal intact.
Persist and stream attention state so long sessions never recompute history.
Keep a few initial anchor tokens plus a sliding window of recent ones — anchors stabilize the softmax while older history is dropped, not approximated.
A cross-encoder second pass that re-scores candidates so only the truly relevant reach the model.
The bi-encoder casts a wide net for recall; the cross-encoder hand-inspects each pair together, catching subtle mismatches independent encodings miss.
Tokens per dollar. Speculative decoding, paged attention, continuous batching, and routing cascades.
A small drafter sprints ahead; the sovereign model verifies in one pass.
A fast sketch artist drafts a sentence while the expert only nods yes/no at each word — parallelizing what was serial.
Virtual-memory paging for the KV cache: no fragmentation, near-zero waste.
OS virtual memory for the attention cache: sequences own logical page tables, not contiguous RAM, so fragmentation drops to near zero.
Sequences join and leave the batch every step; the GPU never idles.
Rather than waiting for the whole table to finish before seating new guests, seat one diner the instant any seat opens.
Split each layer across GPUs, stage the layers in a pipeline — weave both.
Tensor parallelism splits one wide highway across lanes within a node; pipeline parallelism is a relay-race baton pass between nodes.
IO-aware attention that never writes the full score matrix to HBM.
Compute attention scores tile by tile in fast scratchpad memory, accumulating on the fly, so the full score matrix never touches slow global memory.
The bones. Sparse experts, attention variants, positional schemes, and the scaling laws that govern them.
The sovereign decoder backbone every Kynetra model is forged on.
A plain left-to-right stack of read-then-think blocks — attention gathers context, the MLP processes it, residuals keep gradients alive across hundreds of layers.
Sparse expert routing — vast capacity, lean per-token compute.
Instead of every token passing through one big FFN, a traffic cop routes each to two of many specialists — total knowledge grows, per-token work stays fixed.
Share the keys, free the cache — attention that scales at inference.
Many query heads share one set of keys and values per group, like many readers sharing a single annotated reference copy.
Rotary phase encoding that lets context stretch far past training length.
Each attention score comes from the angle between two rotating clock hands — relative position emerges from phase, not from added position vectors.
Compute-optimal sizing and staged curriculum — train the right model, the right way.
Chinchilla's insight: at fixed compute, halving params while doubling tokens beats scaling params alone — size and data must grow together.
If you can't measure it, you can't ship it. Eval harnesses, judges, drift detection, and full lineage.
A sovereign, versioned eval lattice that scores every checkpoint on the same sealed bench.
A sealed, version-controlled test suite that scores every checkpoint under identical frozen conditions, so results are actually comparable.
Ensemble LLM-as-judge with calibrated rubrics, position-swapping, and human anchor points.
Using a strong model as a stand-in human rater — valid only once you've measured how closely its preferences track real humans on your task.
A single faithfulness score: how much of an answer is grounded in cited evidence.
Decompose an answer into individual factual claims, then check each against sources — fact-checking made computable.
Tamper-evident provenance DAG linking every weight to the data, code, and config that forged it.
A tamper-evident paper trail for your model — every artifact is hashed and chained so you can prove what went in and trace any flaw to its source.
Continuous telemetry that catches input drift and quality regressions before users do.
A statistical smoke detector for production — it alarms when today's inputs or outputs look meaningfully different from the baseline you trust.
Train on your terms, behind your walls. Guardrails, sovereign / air-gapped pipelines, and sharded orchestration at scale.
A layered guardrail mesh that filters inputs and outputs before they ever reach the user.
A fast, separately-updatable guard in front of and behind the model — it enforces policy without touching base weights.
Adversarial-prompt defense that hardens models against jailbreaks and injection.
Adversarial fine-tuning is a vaccination — it builds refusal immunity by repeatedly exposing the model to attack patterns before deployment.
Air-gapped, on-prem training topology where data and weights never leave the perimeter.
Air-gap the whole training environment the way classified facilities air-gap networks — nothing leaves the perimeter, so the perimeter is the boundary.
Fully-sharded parallelism that splits weights, gradients and optimizer state across the cluster.
Instead of every GPU holding a full model copy, each holds one slice — shards assemble just-in-time per layer, then discard.
A durable, resumable training checkpoint that restores the full run state byte-for-byte.
A checkpoint is a save-game: it captures everything needed to resume exactly — weights, optimizer, RNG state, and data position.
The 100× layer — hardware-native low precision, KV-cache reuse, disaggregated serving, and linear-time attention that collapse latency and cost. The cross-cutting frontier that makes every stage above faster.
Run the math in the 8- and 4-bit floats the silicon speaks natively — double the throughput, half the memory.
Stop translating to a language the chip doesn't speak — do the arithmetic in the low-bit float the Tensor Cores run natively.
Trade quadratic attention for linear-time recurrence — constant memory, book-length context, no KV-cache blowup.
Instead of re-reading the whole page for every new word, keep a running summary in a fixed-size notebook and glance back only occasionally.
Compress keys and values into a tiny latent — shrink the KV cache 5–13× and serve far bigger batches.
Store one compressed thumbnail per token and re-expand it per head on demand, instead of warehousing every head's full-resolution key and value.
Compute a prompt prefix once, reuse it everywhere — system prompts, few-shots and RAG context stop re-paying prefill.
Memoize the prompt: the model does the expensive reading of a shared prefix once, then replays it for every request that starts the same way.
Run prefill and decode on separate GPU pools — kill the interference, scale each phase on its own.
Stop making one kitchen both prep and plate every order — give prep (prefill) and plating (decode) their own stations so a rush in one doesn't jam the other.
The self-driving forge — a fleet that trains, serves, and improves itself with no human labels. Self-play, multi-agent debate distillation, self-edits, and online learning from serving feedback, conducted by a 100-worker meta-orchestrator toward a growth target. The loop that turns a static model zoo into a compounding one.
A 100-worker meta-orchestrator that trains, scores, promotes, and compounds a fleet of models toward a 100× growth target — no human labels required.
OptimusForge is a compound-interest account for model capability: the orchestrator reinvests every improvement back into the fleet, so small daily gains stack into an order-of-magnitude shift over a month.
One model plays questioner, responder, and verifier against itself — bootstrapping capability from a seed, with no human labels.
Crucible Selfplay is a sparring gym where the fighter trains against an opponent that gets exactly as hard as they are ready for — coach, fighter, and referee are all the same person, improving together.
A panel of teachers debates the student's own outputs and delivers confidence-weighted token-level supervision — breaking the single-teacher ceiling.
Tribunal Distill is a peer review panel for every generated sentence — the student submits its draft, reviewers argue, and only the points of genuine consensus make it into the revision guidance.
The model writes its own training data, hyperparameters, and augmentation directives — then fine-tunes on them, closing the loop with outer RL that rewards self-edits that improve downstream eval.
Edictforge Selfedit is a student who grades their own last exam, writes their own remedial exercises, and then retakes a different sealed test — the outer grade is the only honest signal in the loop.
The model evolves during inference — serving-time accept/reject feedback drives policy updates without touching frozen weights.
Driftloom Online is a chef who adjusts their mise en place after every plate comes back from the dining room — the kitchen (frozen weights) never changes, but the prep (drafter policy) adapts in real time to what diners are actually accepting.
KYNETRA FOUNDRY was imagined, named, and architected under the creative leadership of KR and CS — the founding minds who shaped every pillar, coined every primitive, and set the doctrine this catalogue is built on.
Vision, naming systems, and the forge doctrine.
Engineering grounding, pillar structure, and rigor.
Creative leadership · KR & CS — for Hyperbridge Digital