Fifty 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 engineering.
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.
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.
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