KERN Build with us

A new model class, in the making

Intelligence,
with evidence.

We're building small, local AI models that edit code and check their work against the compiler and tests.

KERN is our first family of VELMs: validated expert language models.

Become a design partner Explore the loop
TypeScript prototype. Built by MoxxyLabs.
FIG. 01 / MODEL + VALIDATOR
tscCOMPILER
vitestTESTS
tsserverLANGUAGE SERVER

01 / TypeScript prototype Architecture preview

Designed for your machine Specialized by language Grounded in real checksSMALL MODEL. CLOSED LOOP.

01 / THE MODEL CLASS

Expertise has a
source of truth.

A VELM combines a specialized language model with the tools that can check its answers.

For code, those tools already exist: the compiler, the language server and your tests. We're making them part of how KERN learns, improves and responds.

Read the whitepaper (PDF, opens in a new tab)
01

Learn from reality.

Compiler diagnostics, types and working fixes become training examples.

DATA
02

Train for the result.

The planned next stage rewards code that passes real checks and behavioral tests.

TRAINING
03

Close the loop.

The runtime we're building checks an edit, feeds back failures and verifies the revision.

INFERENCE

02 / THE PRODUCT IN MOTION

A small edit.
A complete feedback loop.

Fix a type error. Change a function. Repair a failing test. KERN starts with the everyday edits that have a clear way to check the result.

KERN WORKFLOWInteractive illustration · no live inference
src/user.tsTYPESCRIPT

Use the user's name as the display label.

Candidate edit1 FUNCTION

THE VALIDATION LOOP

MODEL OUTPUT

The model proposes a focused change. The verifier gets the candidate next.

Checks provide evidence within their coverage.PROPOSE → CHECK → REFINE → VERIFY

Knowing when to stop is part of the model. We're developing confidence signals so KERN can answer, ask for context or hand off a task that needs a larger model.

03 / LOCAL BY DESIGN

Your code.
Your machine.
Your control.

Built for developers and teams who want useful code intelligence on the hardware they already own.

A model that fits the job.

Our current prototype uses a 1.5B-parameter core. The architecture pairs a shared core with small, swappable language experts.

Inference stays local.

The product is designed to keep code on your machine and work offline, without a cloud inference bill for each edit.

A path into your workflow.

KERN is planned to ship first inside Moxxy (opens in a new tab), our existing open-source CLI and desktop agent harness.

LOCAL RUNTIME + LANGUAGE MODULES ARE IN DEVELOPMENT.

04 / BUILDING IN THE OPEN

Early. Measured.
Moving forward.

Explore the pilot results
CURRENT CORE1.5B

parameters in the first
TypeScript prototype

HELD-OUT PILOT120

tasks, with hidden tests
and a repeatable harness

FIRST SFT RESULTS34.2%

pass@1 on 101 answer tasks
mean of two filtered SFT runs

M1 pilot, October 2026. The untuned 1.5B baseline scored 0% on the same answer tasks. These are early, format-specific results, not a production benchmark or frontier-parity claim. See the method and limitations ↗

NOW / PROTOTYPE

TypeScript first.

Evaluation harness, held-out tasks and the first fine-tuned model. Better data and broader evaluation come next.

NEXT / PRODUCT

Bring the loop home.

Local runtime, verifier feedback, confidence signals and a Moxxy pilot with design partners.

THEN / EXPERTS

Go. Rust. One core.

Swappable language modules, tested against held-out tasks and the larger-model baselines.

LATER / TEAMS

Scale where you work.

Larger models for team hardware, on-prem deployments and an API. Release gates come before expansion.

The bar we’re working toward.

Research targets, not achieved performance. We test each before making a product claim.

70%+of a frontier model’s success rate on scoped code edits, with the same checking budget.

< 3 secresponse time on a laptop. We’ll publish timing by device and edit size.

Know when.Reliable signals to answer, ask for context or hand off beyond the model’s scope.

05 / A FAMILY OF FUTURE EXPERTS

Code is the beginning.
Expertise goes further.

We see VELMs wherever domain knowledge can meet a real check. New domains need the right model core, specialized data and validators built for the work.

EXAMPLE WORKFLOWS

  • Repair a type error

    Update the smallest affected function using compiler diagnostics.

  • Change behavior safely

    Implement a cart total or boundary fix, then run the relevant tests.

WHAT CAN BE CHECKED

Compiler diagnostics, lint, type information and behavioral tests.

TypeScript prototype today. The full runtime loop and Go/Rust experts are in development.

Our ambition extends beyond code. These domains are research directions outside the current code product roadmap, with their own core models and validation limits. Select a domain to explore the idea.

LET'S BUILD WHAT COMES NEXT

Bring your code.
Shape the model.

We're looking for TypeScript teams to help define the first KERN product: the edits that matter, the checks you trust and the way a local model should work.

Become a design partner Early conversations. Direct access to the builders.

Working on small models,
training or local inference?

Talk to the team