Ingest-time event memory

Memory that computes.

Engrammatic turns streams of events — log lines, bid requests, sensor traces, agent turns — into fixed-width binary fingerprints. Comparing them is an integer operation, so novelty, similarity and recall run at wire speed on commodity CPUs, with no model to retrain and no GPU in the path.

Open the console See the four products Watch it work · four short films
An arriving event, the memory it is measured against, and the distance between them — recomputed continuously.
Fingerprint
fixed width, set once
Compare cost
one integer op
Score latency
sub-millisecond
Retraining
none

The primitive

One representation. Every product on this page.

One fixed-width fingerprint can stand for a field, an event, or an entire history, and stay distinguishable from every other one. That is what lets a comparison replace a search — and it is the same representation under all four products.

Encode

event → fingerprint

A record becomes one fixed-width vector, whatever its shape or field count. The width never grows with the data, so memory per stream is a constant you choose up front.

Compose

structure preserved

Fields combine into a record and records into a history without losing which value belonged to which field. Order can be preserved too, so a sequence is distinguishable from its own shuffle.

Compare

one integer op

Similarity is a distance between two fingerprints, computed as one integer operation. Millions of comparisons per second per core, deterministic and auditable.

Freeze

immutable contract

An encoding is published as a sealed, versioned artifact. The same input gives the same fingerprint on any machine, forever — so a score you can reproduce is a score you can defend in an audit.

Why this is cheap. Conventional detection asks a question of stored data and pays per query. Engrammatic pays once, at ingest, to place each event in a space where the question is already answered by proximity. That trade is what moves per-event cost from dollars per million to cents — and it is also why we are honest about where it does not help: a threshold on a 5xx spike, a z-score on a numeric outlier, or a signature rule for a known attack are simpler and better. Our edge is cheap combinatorial novelty over many fields at once.

Products

The same mathematics engine powers every product.

Each product uses related binary-memory primitives with a different encoding contract, console and deployment shape. Each has its own pricing model and evidence trail.

Streaming / observability

Real-time data stream analysis

Every event — a log line, a bid request, a sensor trace — is fingerprinted as it arrives and scored against everything the stream has already absorbed. Genuinely novel shapes stand out immediately — no regex library to maintain, no index to rebuild, and no query bill that grows with retention.

  • Dedupe and cluster at ingest, before storage costs accrue
  • A novelty score per line, against a rolling picture of the stream
  • Constant memory per stream — the running summary never grows

Example use cases

  • Log lines and traces. Dedupe, cluster and score at ingest, beside the log platform rather than in place of it; genuinely novel shapes stand out with no regex library to maintain and no query bill that grows with retention.
  • RTB ad filtering. A bid request is a set of fields — geo, device, publisher, hour. Fingerprint the whole request once and score it inside the auction window, at the edge, with no feature store in the path: hundreds of thousands of events per second per node through the shipped scorer, well inside a 10 ms budget.
  • Online defect analytics. Absorb sensor traces from known-good runs into a golden fingerprint per station; every new unit is then one comparison, drift shows as rising distance well before it shows as scrap, and it is small enough to run on the line controller.
Stream Monitor● SAMPLE
ingest 412,806 lines/s
novelty p99 0.31 (calm)
clusters 47 active
 
> 17:42:08 OOMKilled pod/scorer-7f
dist 0.48 ▲ NOVEL — alerted
> 17:42:09 GET /health 200
dist 0.09 routine
Open the Stream Console → Request a briefing →
How is this different from a Bloom filter?

A Bloom filter answers one question — have I seen this exact item before? — in constant space, and it answers it very well. It has no notion of almost: change one byte of a log line and it is a brand-new item. Engrammatic keeps the constant-space property but makes the answer graded, so a line that is nearly like a million others scores low and a line that is unlike anything scores high. Use a Bloom filter for exact membership; use this when "new-ish" is the thing you care about.

Does it replace our log platform?

No — it sits beside it. Hydrolix, Splunk, Datadog and friends store, index and let you query. We score at ingest so that far less has to be queried later. The integration is a tap on the stream, not a migration.

Why not just a threshold or a count-min sketch?

For a single field, use them — a threshold on a 5xx rate is simpler, cheaper and better, and a sketch is excellent for heavy hitters. The gap they leave is a combination that is individually unremarkable: this user, from this region, on this endpoint, at this hour. Scoring combinations is what one fingerprint per event buys you.

Request a briefing

Watch it work. Three short films, narrated and subtitled, recorded on the Stream Console exactly as it ships: a sample file to a validated job, that job to a clean stream, and the same job to an accountable stream with receipts you can bill.

1 · Create a job and validate it

4:18

Start here. A new workspace picks a template and a bundled sample, builds an encoder, compares it with four simple baselines on held-out data, seals the winner, attaches it to a job and validates it through the real batch API. It ends on the evidence page and billing.

Open with chapters →

2 · Connect a clean stream (Mode A)

4:10

A validated job becomes a live filter. Choose an operating point from the run's operating-points table, issue one key, run three commands, and watch the scorer flag events at line rate while keeping nothing. Each control is highlighted on screen as it is used.

Open with chapters →

3 · Connect an accountable stream (Mode B)

4:07

The same job, connected so that every event the scorer scores is receipted back as an exact count. Name the stream, set how often it sends a receipt, issue one key and run the same three commands; then see the stream under Live streams, close it, and watch the tally and Billing reflect exactly the events the receipts carried.

Open with chapters →

AI infrastructure

LLM Memory Sidecar

Large cold or resumed histories can make agents repeat expensive model work. Your client still sends its full history; the local sidecar selects a task-relevant working set before calling vLLM. Opt-in adaptive profiles retain a bounded in-memory prompt checkpoint. The goal is more accepted agent work per GPU—not just a shorter prompt. Compare native serving, your current compaction, lexical retrieval and HDC on your work.

2 → 16
Conditional optimization target, not a measured gain
1
Default live admission; raise only after a passing test
1 container
Beside your vLLM
  • One container beside your vLLM, with a local status dashboard and install guide
  • Model weights stay unchanged; early access targets text-only generic-renderer vLLM Chat Completions
  • Licensed per GPU card in each served model replica — no usage metering; the minimum is every card in one served replica
  • Annual licence from $500 (A6000) to $8,250 (B300) per GPU; H100 $2,000. A 90-day pilot is a quarter of that, credited in full if you convert — full rate card under “How is it priced?”
Your evaluation path● PILOT PLAN
01 / fit Size your GPU + model
02 / run Install and start in shadow
 
03 / see Open the local dashboard
04 / test Quality · latency · total cost
05 / buy License validated deployments
 
data stays on your infrastructure

If your measured baseline is two long-context sessions, test toward sixteen on the same GPU—or stop at the highest ceiling that passes your gates. This is a joint target, not a universal baseline, throughput promise or guaranteed saving. Evaluation is free.

Open Memory Console → Fleet Audit → Help & FAQ → Request a briefing →
Is this just RAG with extra steps?

No. RAG fetches documents a model has never seen. The sidecar manages the session's own history — what this agent already did, read and decided — and decides what still has to be resident on the GPU this turn. The two compose: teams run retrieval for knowledge and the sidecar for working memory.

Won't a bigger context window make this unnecessary?

A bigger window makes the problem more expensive, not smaller. Memory on the card is the constraint, and it is spent per concurrent session — a card holds roughly a fixed budget of live context however you divide it. Doubling the window roughly halves the sessions. The wall moves with newer architectures; it does not disappear.

Does an agent with a rewritten context still finish the job?

That is the pilot's first gate. Freeze representative tasks and correctness checks, then compare native serving, current compaction, lexical retrieval and HDC with the same model, output allowance and serving flags. Repeat cold and warm multi-turn sessions. A successful request is not a completed task, and fewer prompt tokens do not prove quality or cost savings. Keep native when it meets your goals better.

How is it priced?

One auto-renewing annual licence for each GPU card in every model replica served through the sidecar, charged in advance. The annual rate card is A6000 $500; RTX 6000 Ada and L40S $750; A100 $1,250; H100 $2,000; H200 $4,250; B200 $5,750; and B300 $8,250 per GPU. A pilot does not need a year: the 90-day evaluation licence is a quarter of the card's annual rate ($500 for an H100), charged in advance, and does not auto-renew; take an annual licence within 30 days of it ending and the whole of what you paid is credited against that invoice. No usage component or overage; the minimum while subscribed is every GPU card in one served replica (one card for a single-card replica, all of them for a sharded replica). Your renewal total changes when your declared deployment count changes; quantity adjustments are prorated by Stripe. Cancel in Stripe before renewal to prevent the next annual charge. Contact us to move an active licence to another card class. Air-gapped and regulated sites report nothing outward.

You tell us the count and we take it on trust. The sidecar runs inside your network and we have no view of your fleet; we would rather say that than pretend to check. The Fleet Audit quotes the number before you talk to anyone.

Request a briefing

Watch how to. One short film, narrated and subtitled, recorded on the console exactly as it ships: size a deployment in Fleet Audit, carry the profile into the console, get the source bundle, install it in shadow beside your own vLLM, connect one agent, open the installed local dashboard, and read what the licence buys. Every capacity and money figure on screen is modelled or estimated, and the film says so.

Size, install and license the Memory Sidecar

4:40

Fleet Audit, the evaluation workspace, the three memory profiles, the source bundle, the install block, one agent connected, the local dashboard in shadow, calibration and staged live admission, and the per-card annual licence.

Open with chapters →

AcceleratorsResearch

Compiled LLM models to FPGA

An open-weight model recompiled so that it runs as HDC operations instead of matrix multiplication. The matrix multiply is not accelerated — it is gone. And once it is gone, so is the reason to own a GPU: the model runs on FPGAs, the accelerators AWS and Azure already rent and many regulated sites already own, or on hardware you buy outright. The point is to divorce your models from GPU infrastructure entirely.

  • No MatMul, therefore no GPU — the model becomes integer and lookup work
  • Breaks the dependency on one vendor's accelerators and their lead times
  • Runs the open models you already run — no bespoke architecture to adopt
  • Composes with the sidecar, so a compiled model still serves many sessions
Compiler Programme◆ RESEARCH
target open-weight models
substrate FPGA · no GPU
matmul eliminated by design
 
math design complete
synthesis not started
model Qwen3.8-27B
device none in hand
 
figures none, by design

We are taking a small number of design partners with FPGA capacity or a strong reason to want one.

Request a briefing →
Why FPGAs rather than GPUs?

Not as a replacement — as an option you can own. GPU supply is contested and rented by the hour; FPGA capacity is comparatively available, sits in clouds already, and can be bought outright. If a model can be compiled into the integer form our engine already uses, that hardware becomes viable for inference you control.

How far along is this?

Early, and we would rather say so. The mathematics is worked through and the design is written down. Nothing has been synthesised. Nothing has been simulated for bit-exactness against a reference model. No device is in hand running any part of this. There is therefore no throughput, latency, power or cost figure for this programme anywhere — if you ever see one attributed to us, it did not come from us. The compiler arm page carries the full list.

What would make this a product?

Two gates, in order. First, a compiled model reproducing a reference model's outputs in simulation — that checkpoint comes before any question of timing, area or a device, and it has not been reached. Then a compiled open model running on a board, measured, with quality that holds against the original. Neither is in flight today.

Request a briefing

Perception / security

Video analysis

Encode frame descriptors so that a clip becomes a single order-aware vector. Match scenes, spot loops and tampering, and find near-duplicates across months of archive — without a GPU and without keeping the frames.

  • Order is part of the fingerprint, so cuts and splices break similarity
  • Near-duplicate scene search across very large archives
  • Fingerprints, not frames — private by construction
Scene Matcher● SAMPLE
archive 31,996 hrs indexed
query cam_12 17:40–17:41
 
match 0.93 cam_12 (yesterday)
↳ LOOP SUSPECTED
match 0.71 cam_07 17:39 adjacent
scan 4,100× realtime
Request a briefing →
Is this a replacement for object detection?

No, and it works well downstream of one. A detector tells you what is in a frame; this tells you whether a stretch of footage resembles another stretch, in order. Loop detection, tamper checks and near-duplicate search are the jobs it does that a per-frame detector structurally cannot.

How does it detect a looped or spliced feed?

Because sequence order is folded into the fingerprint, a segment that is byte-different but temporally identical to an earlier segment scores as a near-exact match — which is precisely the signature of a replayed loop. A splice shows up as a discontinuity where continuity is expected.

What is actually stored?

Fixed-width fingerprints and timestamps. Frames are not retained and cannot be reconstructed from a vector, which is what makes long retention windows affordable and reviewable under a privacy policy.

Request a briefing

Platform

Three consoles, one engine.

The products above ship on different clocks. We would rather say which is which than present a roadmap as a catalogue.

Available now

Stream Console

Profile a sample, publish a sealed encoding version, attach it to a job and run it in shadow mode before anything reaches production. Serves log processing, RTB filtering, defect analytics and video today. Metered per million scored events, monthly in arrears, from $0.30 to $1.00 per million on three plans; nothing is invoiced until you start one.

Open the console → · Watch it work →

Runnable early access

Memory Console

Configure a memory profile, run a source package beside your own vLLM, and inspect its local dashboard. Compare native, current compaction, lexical and HDC on real tasks before licensing the GPU cards that serve through it. Start in shadow; evaluation is free.

Open Memory →

Research

Compiler Console

An active programme compiling open-weight models into an integer, lookup-driven form suited to FPGAs — the same accelerators clouds already rent. If it lands, customers host recompiled open models on their own or rented FPGAs, with the memory sidecar alongside. Design work only: nothing is synthesised, nothing is simulated for bit-exactness against a reference model, no device is running any part of it, and we will not quote a number until that changes.

What is measured, and what is not. Memory's 2 → 16 goal is a conditional optimization target. Fleet Audit shows sizing scenarios, not measured customer savings. Every buyer must validate quality, latency and total cost on representative work. Not yet generalised: other cards, models, chat renderers, multimodal inputs, high-concurrency voice workloads, and every FPGA throughput or cost figure. Those remain evaluation targets, not promises. Monitor panels on this page are labelled lab references or illustrative output, never live customer data.

About

The people who built the layer underneath, building the next one.

Engrammatic is a New York company working on a single idea: that the representation modern AI computes over can be far cheaper than the one the industry settled on — and that the way to prove it is to measure, publish, and let buyers check the arithmetic themselves.

Academia
Mathematicians

Professors working in the mathematics this whole approach comes out of. They are the reason the encoding has proofs behind it rather than heuristics, and the reason we know precisely where it stops working.

Ex-Meta
PyTorch engineers

Built the framework layer a generation of models runs on. They know what it takes for an inference change to be adopted rather than admired — which is why the sidecar is a container and a base URL, not an SDK to integrate against.

Ex-Meta · FPGA industry
Silicon & embedded architect

Designs FPGA and embedded systems for production, with time inside a major FPGA manufacturer. The compiler programme exists because someone here has actually shipped hardware, and says so honestly when it is not ready.

Ex-Google · Ex-Meta
Systems engineers

Distributed systems and serving infrastructure at scale. They keep the work anchored to the thing customers actually pay for: cost per event, sessions per model replica, cards per deployment, and a number you can reproduce on your own hardware.

New York City

Invest

Engrammatic is raising a Series A.

We have a measured result, a product shipping against it, and a research programme that would make the economics structural rather than incremental. If that is the kind of thing you back, we would like to talk.

  • A measured wedge, not a thesis. The stream engine's detection results are measured on public datasets and reproducible from the console; the Memory Sidecar's capacity range is modelled from a measured single-card baseline, and the public Fleet Audit says exactly which is which — anyone can check us.
  • Per-GPU licence, recognised annually. $500–$8,250 per GPU-year, depending on card class and invoiced in advance against a count the customer declares — no metering to build and no usage to reconcile. Under-provisioned fleets still get a clear quote where savings-share pricing would have charged nothing.
  • Four products on one primitive. The same engine serves observability, adtech, manufacturing, perception, AI infrastructure and accelerators — different buyers, one core.
  • A hardware option with real optionality. If the compiler programme lands, open models run on accelerators customers can own outright.
  • A team that has shipped this layer before — see above.