Member of Technical Staff (Model Quantization & Inference)

We're looking for someone with genuinely deep technical expertise in language models, model compression or low-precision inference.

You might be a researcher who has developed novel quantization techniques, an engineer who has spent years optimizing LLM inference, or someone who has independently built exceptional systems.

We care much more about what you've done and what you understand than your title or credentials.

• Deep understanding of modern transformer-based language models and their inference behavior.
• Strong experience with model quantization, compression or low-precision numerical computation.
• Hands-on experience working with sub-4-bit models, ideally including 1–2-bit quantization.
• Understanding of weight and activation distributions, quantization error, outliers and numerical stability.
• Strong Python and PyTorch skills, including the ability to modify models, training procedures and inference implementations.
• Experience designing and running rigorous experiments, diagnosing model quality regressions and evaluating trade-offs.
• The ability to read research papers critically, develop original ideas and turn them into working implementations.
• A high degree of independence, curiosity and ownership.

We're particularly excited about candidates with a PhD or equivalent depth of research and engineering experience in machine learning, computer architecture, numerical optimization or a related field.

A PhD is not required. Significant original research, open-source contributions or exceptional industry experience can be equally compelling.

• Develop and improve methods for quantizing large language models to sub-4-bit precision, particularly 1–2 bits per weight.
• Investigate binary, ternary, mixed-precision and other hardware-efficient representations.
• Understand and overcome the quality degradation caused by aggressive quantization.

• Explore low-bit activation quantization, including outlier handling, scaling, dynamic ranges and numerical stability.
• Develop methods for reducing KV-cache memory requirements while preserving attention quality and long-context capabilities.
• Investigate alternative attention implementations and model representations that are more efficient in hardware.

• Work across post-training quantization (PTQ), quantization-aware training (QAT), fine-tuning, distillation and retraining where appropriate.
• Develop methods to recover model quality after extreme compression.
• Understand how architectural choices, training procedures and quantization interact.

• Collaborate closely with our FPGA and ASIC engineers to develop models and algorithms that map efficiently onto custom silicon.
• Explore trade-offs between model quality, bit width, computational complexity, storage and hardware efficiency.
• Help determine which operations and numerical representations should be supported directly in hardware.

• Build and improve inference implementations for highly compressed language models.
• Understand and optimize transformer inference, including prefill, decode, attention and KV-cache behavior.
• Design rigorous experiments and evaluations to measure model quality, latency, throughput and resource requirements.

You'll have significant freedom to pursue the approaches that work, whether that means developing new quantization algorithms, modifying model architectures, improving training procedures or rethinking how inference is performed.

• 1-bit, 1.58-bit, binary, ternary or other extreme low-bit language models.
• Research or implementation experience with BitNet, GPTQ, AWQ, QuIP#, AQLM, HQQ or related quantization methods.
• Quantization-aware training, post-training quantization, knowledge distillation or low-bit fine-tuning.
• KV-cache quantization, compressed attention or long-context inference optimization.
• Activation quantization, outlier mitigation, mixed-precision methods or alternative numerical formats.
• Developing or modifying transformer architectures for efficient inference.
• Custom inference kernels using CUDA, Triton or similar low-level frameworks.
• Experience with inference systems such as vLLM, SGLang or llama.cpp.
• Hardware-aware ML, accelerator-aware quantization or collaboration with FPGA/ASIC teams.
• Publications, open-source projects or substantial original technical contributions in any of these areas.

You don't need experience with all of these. Exceptional depth in one area, combined with the ability and ambition to tackle the others, is exactly what we're looking for.

Why Lamb Labs?

Work on fundamental problems. Extreme low-bit inference is still an open research area. You'll have the opportunity to develop new methods rather than simply apply established ones.

Design models and hardware together. Your work won't be constrained by the assumptions of existing GPU architectures. You'll help shape the numerical representations and computations that go into our custom silicon.

Own your work end to end. You'll have the freedom to pursue an idea from first principles through experiments, model training and implementation.

Work with exceptional technical depth. We're building a small team of people who want to solve difficult problems across machine learning and computer architecture.

See research become real hardware. Your work will directly contribute to the models and algorithms implemented in our FPGA prototypes and future ASICs.

We're looking for people who are excited by questions like:

How much intelligence can we preserve in a 1-bit model? Can we quantize activations and KV caches just as aggressively as weights? What if we designed the model around the hardware from the beginning?

If these are the kinds of problems you think about, we'd love to hear from you.

At Lamb Labs, we're building a new AI chip: the Model Processing Unit (MPU).

Modern AI inference is constrained by the cost of moving model weights between memory and compute. We're taking a fundamentally different approach: aggressively compressing and optimizing language models so that their weights and computation can be encoded directly into silicon.

We're developing extremely low-bit language models and custom hardware architectures together, with the goal of making inference orders of magnitude faster and more energy-efficient.

We're a small, research-driven team working at the intersection of machine learning, compilers and computer architecture. We care about fundamental ideas, rigorous experimentation and turning research into working systems.