• Konic Uno-1Open-weight family — download, self-host, evaluate.
  • Konic Duo-1Enterprise production family — annual enterprise licence, on-prem.
  • Konic Tres-1Mission-critical tier, highest accuracy bar.
  • All model familiesCompare Uno-1, Duo-1, and Tres-1 — deployment and licence options.
  • Custom LLM DevelopmentLLMs built for your agentic pipelines from company data and requirements.
  • Open Models on HFExplore open-weight releases on Hugging Face.
  • ResearchBenchmarks, compression notes, and release write-ups from the lab.
  • Optimized LFM2.5-VL-3B: FFN Width Pruned, Distillation Aligned, INT4 QuantizedWe surgically compress Liquid AI’s LFM2.5-VL-3B — an architecture-searched hybrid conv+attention vision-language model — by cutting FFN width where the search never optimized it: joint-SwiGLU Wanda pruning (10752→8192 and →7168), distillation-to-baseline LoRA recovery, and hand-rolled W4A16 GPTQ + W8 mixed-precision quantization. All three tiers are near-lossless against the base on our paired eval shards — PPL ratios at or below baseline (0.79–0.85), top-5 token agreement ≥ 0.95, quantization adding only +0.02–0.06 nats — across 5.30 GB (−15%), 4.92 GB (−21%), and 1.93 GB packed / 2.22 GB (Konic Optimized) — native INT4/INT8 compressed-tensors in vLLM (−69%). Live comparison on the smallest tier preserves scenes, facts, and tool calling — 10/10 tool rounds, including correct abstention where the base over-triggered. Recorded runs, not general benchmarks.
  • LFM2.5 Encoder 230M + SigLIP2: A Compact Multimodal EncoderWe augment Liquid AI’s LFM2.5 Encoder 230M — a 230M-parameter bidirectional masked-language encoder — with a SigLIP2 vision tower and 32 learned soft tokens to build an encoder-only multimodal model for retrieval and image-text matching. Clean image-only retrieval on 12,500 held-out MONET pairs reaches 0.1194 image→text R@1 with the BF16 reference; the GPTQ INT4 release retains 0.1091 while shrinking the package from 923.65 MB to 370.46 MB (−59.9%). Cyclic-negative matching AUROC is 0.9733; text-nearest hard negatives and image-conditioned masked-token prediction remain at chance, and the model does not generate.
  • Two Stages, Much Smaller MoE: REAP Expert Pruning Followed by AWQ INT4 QuantizationWe chain two complementary compression stages on Liquid LFM2.5-8B-A1B — REAP CUDA expert pruning (32→16 experts across 22 MoE layers) then external AWQ INT4 quantization (W4A16_ASYM, group 128). The published packed artifact is 1.15B packed-weight equivalent / 2.79 GB; recorded MATH500 and BFCLv3 results use a separate 9.18 GB AWQ-scaled BF16 derivative for vLLM evaluation, not direct packed-INT4 runtime. These are recorded run summaries, not general benchmarks.
  • From-Scratch AWQ INT4 Quantization on Qwen3-8BWe validate a from-scratch, pure-PyTorch AWQ implementation on Qwen3-8B: group-wise INT4 with per-channel AWQ scaling produces a 4.0× smaller model (13.9 GB → 3.5 GB linear weights) at 1.034× FP16 perplexity on WikiText-2 (10.08 vs 9.75), loaded and run in a real INT4 GEMM runtime. The decisive factor is norm-folding the AWQ scale — 20× more accurate per weight than weight-dequantization.
  • On-Prem LLM GuidesDeployment, cost, data sovereignty, and air-gapped LLM guides.
  • LLM Data Sovereignty: Why Enterprises Keep Models In-HouseData sovereignty is the reason most regulated enterprises cannot use hosted LLM APIs: the moment proprietary data crosses a network boundary, control over it is shared. This guide explains what data sovereignty means for AI, why it is driving on-prem adoption, and how to evaluate a deployment against your sovereignty requirements.
  • Air-Gapped LLM Deployment: What It Means and When You Need ItAn air-gapped LLM runs on infrastructure with no connection to the public internet — the model, the data, and the serving stack all live inside your boundary. This guide explains what air-gapped deployment actually requires, which industries need it, and the practical constraints of running a model with no external dependencies.
  • How to Deploy an LLM On-Premise: A Practical GuideDeploying an LLM on your own infrastructure is a sequence of concrete decisions: pick the model, size the hardware, choose a serving runtime, quantize for your GPU, and wire in monitoring. This guide walks each step with the trade-offs that actually matter for a production on-prem deployment.
  • On-Prem LLM vs API: When to Self-Host Your Language ModelsAPI-based LLMs are fast to adopt but scale poorly on cost, latency, and data control. On-prem LLMs trade setup effort for predictable economics, lower per-token cost at volume, and data that never leaves your boundary. This guide breaks down the decision across cost, latency, privacy, compliance, and operational effort — and when each path is the right call.
  • Book a demoTalk with the team about your workload.
  • GitHubOpen research and tooling.
  • Hugging FaceModels and model cards.
  • XFollow @koniclabs on X.
Pricing
Models on HFGitHubX
Book a demo
Book a demo

Glossary

On-prem LLM terms, defined.

Working definitions for the vocabulary of private LLM deployment — the same terms used across Konic research, model pages, and commercial terms. Written to be quoted: one self-contained paragraph each.

On-prem (on-premise)
On-premise means the model runs on infrastructure you own — your data center, private cloud, or edge hardware — under your keys, networking, and data plane. Inference happens inside your boundary, so data never leaves and cost does not scale per token.
#on-prem
Air-gapped
Air-gapped means the model, data, and serving stack run with no connection to the public internet, fully isolated inside your security perimeter. Regulated workloads that forbid external dependencies need every artifact — weights, runtime, updates — to be operable offline.
#air-gapped
Data sovereignty
Data sovereignty means an organization's data, prompts, and model outputs remain under its legal and operational jurisdiction, with no third-party API provider sharing control. Keeping models in-house keeps proprietary data inside the compliance perimeter and leaves long-term ownership of the AI system with the operator.
#data-sovereignty
Private cloud
A private cloud deployment runs the model in a dedicated VPC or tenant inside a cloud provider, rather than on the provider’s shared inference API. It keeps the data plane inside your account while letting you reuse managed networking, storage, and observability.
#private-cloud
Annual licence (no per-token cost)
An annual licence is a commercial model where a model family is licensed per host for a year and deployed on infrastructure you own. Cost does not scale with tokens served, so unit economics improve with usage instead of degrading, and spend is forecastable from the number of hosts.
#annual-licence
Quantization
Quantization stores model weights in a lower-precision format than the training precision, most commonly INT4 or INT8 instead of FP16. A well-executed INT4 build cuts weight memory roughly 4x at near-parity perplexity, which is what makes on-prem GPU footprints affordable.
#quantization
AWQ (Activation-aware Weight Quantization)
AWQ is an INT4 quantization method that scales up the weight channels aligned with large-magnitude activations before quantizing, protecting the small fraction of weights that influence outputs most. Konic publishes from-scratch AWQ implementations with reproducible perplexity results.
#awq
GPTQ
GPTQ is a post-training quantization method that quantizes weights column by column and compensates the remaining weights using second-order information from a calibration set. It is widely used to produce INT4 artifacts that load into standard GPU inference runtimes.
#gptq
Pruning
Pruning removes parameters from a trained model — whole layers, attention heads, feed-forward width, or experts — then recovers quality with continued training. Structured pruning such as FFN-width reduction shrinks the compute graph itself, so it reduces latency rather than only memory.
#pruning
REAP (Router-weighted Expert Activation Pruning)
REAP is a compression method for Mixture-of-Experts models that removes whole experts, ranked by the router-weighted magnitude of the activations they receive on a calibration set. It keeps the experts that actually fire for the target workload instead of the ones that merely hold the most weights.
#reap
Mixture-of-Experts (MoE)
A Mixture-of-Experts model replaces a dense feed-forward layer with many parallel expert networks plus a router that activates only a few per token. Total parameter count is much larger than the compute per token, which makes MoE models memory-bound and a natural target for expert pruning and quantization.
#moe
Distillation
Distillation trains a smaller or compressed model against the outputs of a larger teacher rather than against hard labels alone. Distillation alignment recovers quality after pruning, so the compressed artifact tracks the baseline output distribution instead of only matching a single loss number.
#distillation
INT4
INT4 is a 4-bit integer weight format. Weights are grouped and each group carries its own scale, which keeps precision acceptable while cutting memory to roughly a quarter of FP16. INT4 models normally need a runtime with native INT4 kernels, such as vLLM with compressed-tensors support.
#int4
vLLM
vLLM is an open-source inference server for large language models, best known for paged attention and high-throughput continuous batching. Konic publishes deployment artifacts that load directly into vLLM, including native INT4 and mixed-precision compressed-tensors builds.
#vllm
Time to first token (TTFT)
Time to first token is the latency between a request arriving and the model emitting its first output token. It is dominated by prompt prefill and is the metric users perceive as responsiveness in interactive assistant and agent workloads.
#ttft
Total cost of ownership (TCO)
Total cost of ownership for an LLM deployment includes hardware or reserved capacity, serving engineering, evaluation, monitoring, and the commercial licence — not just the per-token price of an API. On-prem deployments trade a higher fixed cost for a cost curve that flattens as usage grows.
#tco

Looking for the machine-readable version? The same definitions ship in llms-full.txt and as model pages with published benchmark tables.

Konic

Compact production-optimized LLMs on infrastructure you own.

NVIDIA Inception Program memberAnnouncement (LinkedIn)

Models

  • Konic Models
  • Custom LLM Development
  • Pricing
  • Open Models

Research

  • How We Build
  • About Konic
  • Glossary
  • Research
  • Optimized LFM2.5-VL-3B: FFN Width Pruned, Distillation Aligned, INT4 Quantized
  • LFM2.5 Encoder 230M + SigLIP2: A Compact Multimodal Encoder
  • Two Stages, Much Smaller MoE: REAP Expert Pruning Followed by AWQ INT4 Quantization

Guides

  • On-Prem LLM Guides
  • LLM Data Sovereignty: Why Enterprises Keep Models In-House
  • Air-Gapped LLM Deployment: What It Means and When You Need It
  • How to Deploy an LLM On-Premise: A Practical Guide

Connect

  • Book a demo