On-device intelligence

The fastest AI ever built for the device in your pocket.

A 1B fp16 model holding 256K-token context in 4GB of RAM. It runs entirely on-device — no network, no queue, no bill.

262,144 tokens resident · 3.1GB peak footprint · full fp16 weights

9:41
Edge256K CONTEXT

Summarize every contract I've signed this year.

CONTEXT0 / 262,144
MEMORY0.0 / 4.0 GB
ingesting · 214 pagesoffline

256K

Token context window, resident in RAM

4GB

Total memory budget — weights, cache, runtime

1B fp16

Full-precision weights. No int4 shortcuts

0 bytes

Sent to the cloud. Ever

The memory math

256K context. 4GB of RAM. It fits.

A 1B fp16 model is 2GB of weights. Dense attention adds ~192KB of KV per token — 51.5GB at full context, thirteen times the entire budget. Latent Graph Attention routes the cache along learned edges at ~2KB per token, and the whole footprint lands at 3.1GB.

ANTILATTICE EDGE @ 256K — ONE BUDGET0.0 / 4.0GB
Weights — 1B fp16 — 0.0GBRouted KV @ 256K — 0.0GBRuntime + activations — 0.0GBFree — 0.0GB
DENSE fp16 KV @ 256K — THIRTEEN BUDGETS51.5GB

The cache alone outweighs the phone thirteen times over. Squeeze the same dense model into one budget and you fit roughly 8K tokens — Edge holds 256K, a 32× larger window.

How it works

Attention that fits.

01

Dense

Every pair. Every byte.

Standard attention stores KV for every token it sees. At 256K, a 1B model's cache alone would pass 51GB — no phone was ever going to hold that.

192KB / token

02

Learned

The model finds what matters.

Latent Graph Attention builds a token graph as it reads — the relationships that carry meaning, and nothing else.

graph built on the fly

03

Routed

The cache collapses to its edges.

KV survives only along routed edges. The cache shrinks from 51.5GB to 0.5GB, and 256K context fits beside full fp16 weights.

~2KB / token

Measured on-device

78% of short-context speed — at 256K.

8K
Dense · 100
Edge · 100 · parity
32K
Dense — memory-infeasible
Edge · 96
128K
Dense — memory-infeasible
Edge · 88
256K
Dense — memory-infeasible
Edge · 78

Internal benchmarking on a 2026 flagship smartphone with a 4GB memory budget, normalized to short-context generation speed. Dense fp16 KV exhausts the budget before 16K tokens; Antilattice Edge keeps serving to 256K.

Result

32×

more context than dense fp16 fits in the same 4GB budget — and still generating at 78% of short-context speed, with the radio off.

78 tok/s
Join the beta

Why on-device

The cloud was never the only option.

Private by architecture

Prompts, files, and history never leave the hardware. Privacy is a property of the system, not a policy.

Offline is a feature

Airplane mode, dead zones, remote field sites — full-context reasoning with the radio off.

Free at the margin

No per-token bills, no rate limits, no keys to rotate. Once it's on device, inference costs battery — nothing else.

Full precision, not int4

Quantization trades quality for space. Routed KV makes that trade unnecessary — fp16 on a phone.

Get started

Same intelligence. None of the datacenter.

We build frontier models that live entirely on the device. If your product needs intelligence that never leaves the hardware, we want to hear from you.