./init_foundation.sh --family jLFM --mode sovereign

Stop Predicting Tokens.
Navigate Latent Space.

jLFM (JEPA Liquid Foundation Model) is a compact, local-first model family that replaces brute-force token autoregression with Joint-Embedding Predictive world modeling and continuous-time Liquid Neural Networks. Built to generate, decide, and execute from consumer GPUs down to bare-metal FPGAs.

jLFM — amber halftone eye banner — FIG_00 // LATENT_OBSERVER● REC

Latent World Model Closed-Form Continuous-Time (CfC) Zero Cloud Rents Sub-50M Decision Engine OSS FPGA Neural Engine

Explore The 3 Cores ↓ [ Inspect CLI Preview ] Request Early Access ↗

// 01 · MODEL LINEUP

One Latent Core. Three Execution Targets.

Every jLFM variant shares the same bidirectional semantic chunk encoder and continuous-time liquid state integrator—swapping only the readout head for generation, typed decisions, or silicon execution.

CORE_01 // GENERATIVE Pre-Release

JLD

JEPA Liquid Decoder · Generative LM

A hierarchical generative model that plans ahead in chunk-level latent space before decoding tokens locally. By predicting semantic trajectories first, JLD avoids flat token-by-token drift under a strict 200M parameter cap.

├─ Latent Horizon Planning: Predicts future semantic chunks via a stacked CfC liquid core before emitting prose.
├─ 32× Context Compression: Compresses token windows into dense latent vectors with anti-collapse regularization.
└─ Local-First Footprint: Runs effortlessly on edge GPUs, Apple Silicon, and homelab nodes.

<200M Param Cap

JEPA+AR Hybrid Core

Stream Output

CORE_02 // DISCRIMINATIVE System-1 Engine

JLC

JEPA Liquid Choice · Typed Decision Model

Our sovereign, self-hostable answer to TypeSafe’s Jev. State goes in; calibrated typed decisions come out in a single forward pass. No prose generation, no chain-of-thought tax, and 0% off-schema hallucination.

├─ 3 Native Primitives: Evaluate Noul (binary probability), Choice (categorical), and Score (ordinal rubrics) in parallel.
├─ Calibrated by Design: Trained with proper scoring rules (Brier + Ordinal RPS) so a 0.85 confidence means 85% empirical accuracy.
└─ Zero Output Token Cost: Score 20+ routing, guardrail, or RAG reranking questions in one pass.

<50M Param Cap

1-Pass Parallel Eval

Typed JSON Out

CORE_03 // HARDWARE + SDK Silicon Target

JL-FPGA

Hardware JLC + OSS Neural Engine SDK

A general-purpose, quantized edition of JLC engineered for low-power FPGAs, bundled with an open-source Neural Engine SDK. Bring deterministic, microsecond-class System-1 decisions straight to the physical edge.

├─ KV-Cache Free Recurrence: Liquid CfC state integration keeps memory bandwidth flat and deterministic on BRAM/SRAM.
├─ OSS Neural Engine SDK: Open Verilog/SystemVerilog cores, compiler toolchain, and zero-dependency C/Rust host drivers.
└─ Physical Edge Ready: Built for robotics, industrial safety interlocks, SDR/network packet gating, and autonomous hardware.

INT8/FP16 Quantized

OSS SDK Rust / C / RTL

Deterministic Latency

// 02 · THE TOPOLOGY

How the jLFM Pipeline Operates

No deep-dive equations—just the architectural separation of concerns that lets one backbone power text generation, typed classification, and FPGA acceleration.

// INPUT STREAM // SHARED WORLD MODEL // SPECIALIZED READOUT HEADS ┌──────────────────────────────────────┐ ┌─► [ JLD: CAUSAL CHUNK DECODER ] ┌─────────────────────────┐ │ 1. BIDIRECTIONAL CHUNK ENCODER │ │ Streams coherent text conditioned │ RAW CONTEXT / STATE │ ─────► │ Compresses K-token windows into │ ─────────┤ on predicted latent trajectories. │ Text · JSON · Telemetry│ │ normalized semantic latents (z_t). │ │ └─────────────────────────┘ └──────────────────┬───────────────────┘ ├─► [ JLC: PARALLEL DECISION HEAD ] │ │ Single-pass cross-attention over ▼ │ Noul · Choice · Score questions. ┌──────────────────────────────────────┐ │ │ 2. LIQUID CfC STATE INTEGRATOR │ ─────────┴─► [ JL-FPGA: OSS NEURAL ENGINE ] │ Continuous-time recurrent dynamics │ Hardware-mapped state core + │ track global state & predict z_t+1. │ deterministic decision bus over SPI/PCIe. └──────────────────────────────────────┘

// 03 · SEE IT IN ACTION

Switch Target Interfaces

Preview how each jLFM target is invoked in practice—from Python CLI inference to embedded Rust SDK calls.

zsh · jlfm-cli — jlc decide LOCAL · ZERO-CLOUD

// 04 · RELEASE ROLLOUT

WHAT WE'RE SHIPPING

├─PHASE 01 · JLC-50M Open Weights & CLI Single-file PyTorch reference + calibrated Noul/Choice/Score evaluation suite.

├─PHASE 02 · JLD-200M Generative Checkpoint Pretrained latent-planning text model with open training & ablation scripts.

├─PHASE 03 · JL-FPGA Bitstreams & OSS Neural Engine SDK Synthesizable Verilog cores for edge FPGAs (Gowin Tang / Xilinx) + Rust host crate.

└─PHASE 04 · Technical Report & Calibration Benchmarks Full architectural breakdown, ECE calibration curves, and latency benchmarks.

// SOVEREIGN AI STATE

NO API TAX. YOUR SILICON.

You shouldn't need a 70B cloud model or a proprietary per-token API just to route an agent, verify a guardrail, or run local generation. jLFM is engineered to be owned end-to-end.

Custody

Self-Hosted

Cloud Rents

$0.00

JLC Size

49.3M Params

Hardware SDK

Open Source

Get_In_Touch →

Stop Predicting Tokens. Navigate Latent Space.