Engrammatic flags anomalies, novelty and fraud at ingest time — before events hit your query engine — for $0.30–$1.00 per million events instead of the $3–$10 that query-based detection costs. It runs on commodity AWS CPU/Spot today and sits alongside your log platform, not in place of it.
Finding meaning in a stream today means stopping it, decompressing it, loading it into RAM, and running heavy models or repeated scans against an always-on hot cluster. The detection work happens late — in the most expensive place possible.
Query-based detection re-scans and decompresses the same events for every rule and lookback window.
Sub-second answers require keeping huge amounts of data hot — you rent peak capacity 24/7.
The rough all-in cost of query-based anomaly/fraud detection at scale. It scales the wrong way.
Most teams approximate ingest-time novelty detection with blunter tools. Here's what you'd otherwise reach for — and the gap each one leaves.
Prometheus, CloudWatch, CDN analytics. Cheap — but per-metric. A brand-new field combination that's individually normal sails straight through, and you live in threshold-maintenance.
Splunk, Elastic, Datadog, Hydrolix. Flexible — but it re-scans hot data repeatedly, runs after ingest, and bills per query/GB. ~$3–$10 / M events.
FAISS, Milvus, Pinecone. Catches novelty — but embedding inference per event, GPU, ANN index rebuilds and drift. Expensive at wire speed.
Flink + RRCF / River. It works — but now you build and operate a detection platform. We're the kernel (XOR + popcount), not a platform you run.
Encode each event once at ingest and score combinatorial novelty with XOR + popcount — for $0.30–$1.00 / M events. No always-on query cluster, no GPU, no index rebuilds. It sits alongside your stack: your dashboards still graph, your store still queries — we just catch the never-seen-before thing first, at the cheapest possible point.
Use the right tool. A 5xx spike → a threshold. A single numeric outlier → a z-score (it'll beat us, and we'll say so). A known attack → a WAF. Use Engrammatic for the never-seen-before combination none of those catch.
You could build this. You don't have to. The math fits on a napkin — the results live in the details: encoder design, memory policies, drift handling, false-positive burndown. Engrammatic is a standing team of humans and AI agents working the HDC frontier every day, and every encoder improvement, benchmark and hard-won default ships straight into your detection path. Renting that expertise is faster — and cheaper — than retracing the path yourself.
Engrammatic sits in the data path. Pre-built encoders turn each event into a 10,240-bit binary hypervector instantly. Similarity is just XOR + popcount — one of the cheapest things a CPU (or, next, an FPGA) can do.
A coprocessor, not a replacement. Your log platform stays the system of record for storage, SQL, dashboards and compliance. Engrammatic just does the expensive detection earlier and cheaper.
Engrammatic is a hosted detection API with a zero-dependency Python client. pip install engrammatic, sign in with Google for an API key — new accounts get $5 of starting credit — and point a stream at it. Production runs on capacity-optimized AWS Spot. The embedded/local engine is not in the public package: if you need in-VPC scoring, talk to us — that's a design-partner conversation, not a pip install.
pip install → sign in for a key ($5 credit) → detect() against the hosted API → benchmark your own logs.
Zero-dependency Python client from PyPI. Sign in with Google for an API key — new accounts get $5 of starting credit.
Request a sandbox key, send events to the endpoint, see anomalies and your live bill. Metered per million events — no commitment.
A capacity-optimized C7a/C7i Spot pool, in your AWS account or ours. Hard budget caps, SLA on the Scale tier.
Interruptible ≠ unreliable. Compute is disposable; memory is replicated and rebuildable, so a Spot reclaim is a non-event. Need a hard guarantee? The managed tier keeps a warm fallback and an SLA.
Pre-filter and triage logs at ingest. Catch novel patterns and cut hot-storage/query spend 5–10×.
Real-time fraud and abuse detection on transactions and events — high value for payments and web3.
Flag never-before-seen behavior the moment it appears, with stable recall as memory fills.
Persistent, associative memory for long-running AI agents — the hippocampus to the LLM's cortex.
Turn market / tick streams into risk vectors and react before the data lands.
Encode FASTA / sequence data into hypervectors for fast associative search.
Repeated scans · decompression · always-on hot clusters · cost grows with every rule and lookback.
Encode once · ANN shortlist · bitwise comparison · runs on interruptible Spot capacity.
A ~$10/hour Spot budget in us-east-1 supports roughly 500–700 vCPUs and on the order of 100M–500M Hamming comparisons/second. We bill per million events above that cost — the savings are yours.
Rough monthly economics at your scale — using the same illustrative $/M rates on this page. The real number comes from a benchmark on your own logs.
Estimate only, from illustrative $/M figures — not a quote. Volume economics vary with event shape, namespaces and tier. Validate with a benchmark on your own data.
open the console → benchmark your logsFive primitives — encode · bind · bundle · write · query — plus a one-line detect(). Run it in-process for benchmarking, or point it at the hosted service.
Top up by card today — USDC/USDT coming soon; usage burns it down. No invoices, no surprises. Volume lowers your rate.
Top up by card in the console today. USDC/USDT (Base · Arbitrum · Solana · Tron · Ethereum) coming with a real processor. Teams can pay by invoice (ACH / wire).
To create an account you sign in with Google; card top-ups are handled by Stripe. We run a light-touch check (email + sanctions screening — wallet attestation comes with the stablecoin rail). That’s it.
Engrammatic is built to be purchased and operated by autonomous agents, not just humans. Discover the service, read pricing, self-fund with stablecoins after a light KYC (payment rail in preview — card top-up is live today), and start calling the API — end to end, no human in the loop.
discover the agent.json manifest → self-fund with USDC → detect, metered per event. · rail in preview
A manifest at /.well-known/agent.json describes capabilities, pricing, payment assets/chains and endpoints.
One call creates an agent account and returns a stablecoin top-up invoice (rail in preview). On confirmation, credits post and the agent starts detecting.
Get access and run your own logs through Engrammatic to get cost-per-million-events, p50/p99 latency, and detection quality vs your current approach. We run a reproducible benchmark harness — it ships to design partners — and we're straight about the trade-offs: a tuned batch baseline can beat us on raw AUC, and we'll tell you when it does. Our edge is different: per-event combinatorial novelty, scored online in ~0.6 ms as events arrive — the never-co-occurred combination a batch model isn't watching for, caught at the cheapest point in your pipeline. Don't take our word for it — run it on your own data.
sign in with Google — every new account starts with $5 of sandbox credit. Questions? hello@engrammatic.ai
GPUs are engines of imagination — powerful but amnesic. Engrammatic is the engine of fact: structured, lightning-fast, deterministic memory and reasoning that lives outside the model and persists across sessions. We start narrow — ingest-time detection on cheap CPU — and expand toward FPGA-accelerated reasoning-memory: the hippocampus to the LLM's cortex. Detection today funds the state layer of tomorrow.
Engrammatic is early — we're running design-partner pilots, not pretending to be a mature SaaS. Here's exactly what that means for your data and your security review.
For design partners, in-VPC deployment runs the engine inside your network — raw events never leave. The hosted API scores events in memory and persists only compact hypervectors, not your logs.
SOC 2 Type II is on the roadmap; a DPA is available on request. We collect only the minimum required for sanctions/AML and delete verification artifacts after screening.
Python SDK available today — pip install engrammatic. The reproducible benchmark harness ships to design partners. Hosted API and managed Spot are in design-partner preview. No fabricated customer logos here — references will appear as pilots convert.
No. Engrammatic is a coprocessor that runs detection at ingest time. Your platform stays the system of record for storage, SQL analytics, dashboards and compliance — we just make the expensive part cheaper and earlier.
A way of representing data as very high-dimensional binary vectors (here, 10,240 bits). Similarity becomes XOR + popcount — extremely cheap and parallel on CPUs today and FPGAs next — so you can compare and recall at the speed of the stream.
Query-based detection repeatedly scans and decompresses data on always-on hot clusters. Engrammatic encodes each event once, shortlists candidates, and compares bitwise — and runs on interruptible Spot capacity. Always validate with your own data via a benchmark.
Today you top up by card in the console. Stablecoins are next, because: usage-metered, global, developer- and agent-friendly billing is a poor fit for cards — prepaid USDC/USDT removes chargebacks and FX friction. We run a light-touch KYC (email + sanctions screening) and collect nothing beyond what compliance requires.
Yes — that's a first-class path. Agents discover the service via /.well-known/agent.json, self-fund with a single purchase call, and call the metered API. See the "For AI agents" section.
v1 runs on CPU/Spot to validate quality and economics fast. FPGA (e.g. AWS F2) is the roadmap for workloads where CPU caps out and for the agent reasoning-memory product — proven on CPU first to de-risk the hardware spend.