engram 0.1 / models from problems.
you describe it. the lab runs it.

  1. 1.
  2. 2. spam, fraud, churn, routing
  3. 3.
  4. 4. images, audio, transcription, detection
  5. 5. your own fine-tuned LLM
  6. 6. swap an $8k/month prompt for a model you own
  7. 7.
  8. 8. your problem here
  9. 9.
  10. 10.
  11. 11. it either works, or it tells you why not

Engram scopes the problem, finds or labels the data, runs competing designs side by side on Modal, evaluates them honestly and hands back an endpoint and a bundle.

Your coding agent calls it like any other tool — and your own Claude or Codex account does the thinking.

For e.g. the first call is one line. The scope, the data, the labels, the synthetic gap-filling, the search, the verdict: all of it is behind it, in the cloud, while you keep working. You come back to a number you can trust, or a reason it cannot be done.

PROBLEM IN, MODEL OUT.

The point of the first run is not the model. It is the answer to one question: is there anything in this data that a model can learn, and how sure are we? Everything else follows from that.

every score shows its work: duplicates removed before the split, the holdout carved off first and never touched, synthetic rows kept out of it, a baseline beside every number. When the data cannot support a model, the verdict says so, and says what would fix it.

$ curl -fsSL https://engram-production-c697.up.railway.app/install.sh | sh
  1. 1.
  2. 2. install the cli
  3. 3.
  4. 4. engram login, engram connect claude
  5. 5. engram solve "…" --data file.csv --min-score 0.9
  6. 6.
  7. 7.

Sized to the job. A classifier can be a few hundred kilobytes and answer in milliseconds. A fine-tuned language model can be billions of parameters on a rented H100. Either way, trained on a Tuesday afternoon and answering requests by Wednesday.

WHY NOBODY OWNS THEIR MODEL.

doing it yourself

  1. 01find or buy a dataset
  2. 02clean it, dedupe it, balance it
  3. 03label what is unlabeled
  4. 04pick a model family
  5. 05pretrain or fine-tune?
  6. 06compare designs, tune settings
  7. 07rent gpus, mount volumes
  8. 08hold out a test set you did not peek at
  9. 09package it, serve it, scale it
  10. 10watch it drift, retrain it
  11. 11hire the people who do all of the above

That is why most teams rent intelligence by the token instead. It is the right call to start. It stops being the right call when it becomes the biggest line on the bill, when the vendor retires the model you built on, or when the data cannot leave the building.

with engram:
one sentence.

A model trained on your own examples, from a tiny classifier up to a fine-tuned open LLM, often beats a general model at your task and costs far less per call. You just never had a way to get one without a team.

THE MARKUP. THE IDLE BILL.

5×–50×

Compute Comparison puts the per-token markup of managed APIs over raw GPU compute at 5 to 50 times:

“managed APIs (OpenAI, Anthropic, Google) charge a per-token markup of 5–50× over raw GPU compute cost”
computecomparison.com: llm api vs self-hosted cost

the other half of
the bill is waiting.

A GPU you rent by the hour costs the same whether it serves a million requests or none:

“You are paying for the capacity regardless of whether you process one token or one billion tokens.”
lyceum.technology: open source vs closed api cost

your engram inference never sits idle

Endpoints scale to zero. When nobody is calling your model, nothing is running, and nothing is billed for waiting.

  • no calls, no machine

    A quiet night, a weekend, a feature nobody has launched yet: the endpoint is asleep, not running up hours.

  • wakes on the next request

    The first call after a quiet spell starts the model. Every call after that is fast while it stays warm.

  • scales with demand

    Busy periods get more capacity automatically. You never size a fleet, rent a card for a peak, or pay for it all month.

the raw-compute side of that markup, without the idle hours. you can watch it in the dashboard: try a model after a quiet spell and the response time shows the wake-up.

WHAT YOU GET BY OWNING IT.

Six reasons teams want their own model.

three ways teams solve it today

pay per token

build in-house

engram

first month

$0 to start

hires, gpu contracts

pay per job, estimate shown first

at volume

grows with every call

fixed and low per call

your own model, sized to the job, hosted or yours

your data

leaves the building

stays home

model and weights are yours to self-host

lock-in

their model, their prices

none

none: code, weights and bundle download

first model in

an afternoon

weeks to months

minutes to hours

skills needed

an http request

mlops, data eng, ml

one sentence

an api is still the right tool for open-ended chat, one-off jobs, and anything you call a few hundred times. engram is for the job you repeat, and are about to pay for a million times: your own classifier, extractor, transcriber or fine-tuned language model.

WITHOUT ENGRAM. WITH ENGRAM.

You can do every step yourself, and so can your agent. It is the steps nobody wants to own, and the ones where marking your own homework is the risk, that Engram takes off your plate.

without engram

with engram

starting point

a plan, a pipeline and weeks of setup

one sentence

your agent

writes the integration, then hits a wall: no gpu, no data, no evaluation, no hosting

calls Engram as tools (MCP, --json, a skill). No markup on the intelligence

compute

rent gpus, size them, queue for capacity, mount volumes. Easy only if you already know a platform like Modal

L4 up to 8 H100s, picked from the model size, nothing to set up

test set

the code that trains also grades, so the held-out set is only as honest as you are

split off before any design is chosen, never seen by the code, scored by Engram. The verdict can say no

designs

pick one, tune it by hand

several train side by side, cross-validated, the winner picked by evidence, with a spend limit

data

find it, clean it, label it, hope the labels are right

web, public or verified synthetic data, labeled by your AI, with accuracy you can measure against people

an existing model

script each framework, chase versions, guess what the change cost

quantize, merge, distill or remove refusals from a pre-built image, with quality, size, memory and speed measured before and after

cost and safety

a guess, then a bill. Generated code runs on your machine

an estimate first, a cap, a hard stop, isolated sandboxes, licenses checked on the server

the result

you host it and pay for an always-on gpu

an endpoint that scales to zero, plus weights, code, a Dockerfile and a model card to take with you

staying current

watch for drift, retrain by hand

one command retrains on fresh data while the old model keeps serving. Drift checks for classifiers

ONE CALL. WHOLE LAB.

No scripts, no GPUs to rent, no datasets to wrangle. The agent that found the problem asks for the model and gets it back.

you "flag marketplace listings that are spam". the data is listings.csv.
● delivered · p50 3.1 ms · ~$0.0011

six stages. none of them yours.

  1. scope

    Your Claude or Codex account reads the problem and your data profile, picks the framing, metric and candidate designs — or says plainly that ML is the wrong tool.

  2. get data

    Use your upload, label it with your own AI account, or source a permissively licensed public dataset with recorded provenance.

  3. fill gaps

    Under-represented classes get synthetic examples — added to training folds only, never to the test set.

  4. compare designs

    Competing pipelines train side by side on Modal. You choose the splits, the reshuffles, parallel or one at a time, and a spend limit.

  5. evaluate honestly

    One look at an untouched holdout, a bootstrap confidence interval, a baseline, leakage and duplicate checks, latency on real inputs.

  6. bake & deploy

    A live endpoint plus a self-contained bundle: model, predict.py, serve.py, Dockerfile and a model card you can hand to a client.

YOUR AI.
OUR LAB.

Connect once with engram connect . Planning, labeling, synthetic examples and the evaluation report run on your own subscription, in an isolated per-user session. Engram supplies the compute, the dataset sourcing, the parallel design search, the evaluation harness and the hosting.

No account connected? Labeled uploads and public sourcing still work with the deterministic planner.

  • your agent decides framing · metric · designs · labels
  • engram executes profiling · sourcing · training · packaging
  • you receive endpoint · bundle · model card · report
  • never:
  • test-set peeking
  • synthetic rows in evaluation
  • unlicensed data

WHAT ENGRAM CAN BUILD.

Describe the job in one sentence. Engram builds the right kind of model for it: a classifier a few hundred kilobytes in size that runs on a CPU, or an open language model of up to 70 billion parameters fine-tuned on your data on a rack of GPUs. You never choose the architecture, the hardware or the training recipe.

300 KB classifier70B-parameter LLMthe span

  1. 01 / 06

    CLASSIFY

    cpu · seconds to minutes · a few hundred KB

    you givetext or a table, with the right answers

    you geta model that sorts, scores and predicts: spam, routing, churn, fraud, price

    engram solve "route tickets to billing, technical, sales or urgent" --data tickets.csv
  2. 02 / 06

    SEE & HEAR

    gpu once · minutes · cents

    you givea zip of images or audio, one folder per class

    you geta model that labels pictures and sounds: defects, receipts, species, call types

    engram solve "separate defective from good parts" --data parts.zip
  3. 03 / 06

    EXTRACT & REWRITE

    gpu · minutes · cents to dollars

    you givepairs: the text you have, the text you want

    you geta model that pulls out fields, rewrites in your style, summarises, normalises

    engram solve "pull the invoice number out of the email" --data pairs.csv --type text_generation
  4. 04 / 06

    YOUR OWN LLM

    A10G up to H100 ×8 · hours · priced before it starts

    you giveexamples of the answers you want, or let your agent write them

    you getan open language model fine-tuned to your tone, format or domain, on GPUs up to eight H100s or H200s

    engram solve "answer billing questions in our tone from our past replies" --data replies.csv --type custom
  5. 05 / 06

    DATASETS

    web search + your own AI account · minutes to hours · search spend capped per job

    you givea sentence about the data you need, or raw rows with no labels

    you geta clean, labeled dataset of text, images or audio: public Hugging Face data, raw web data at scale, structured records researched by an agent, verified synthetic examples, or your own rows, with AI labels whose accuracy is measured against a gold set your people label

    engram dataset "billing complaints with the issue type" --source web --labels billing,bug,other --gold-review 100
  6. 06 / 06

    ANYTHING ELSE

    any gpu · up to 23 hours · capped by your --max-cost

    you giveexamples of what right looks like

    you getwhatever your agent builds to get there: transcription, detection, reasoning, ranking, text-to-SQL

    engram solve "transcribe support calls" --data calls.zip --type custom --metric wer

the squares show relative compute, not a measurement. open models only, no gated checkpoints. the largest jobs are priced at gpu cloud list rates and shown in the run log before training starts. we have not run frontier-scale models, and a sandbox lives at most 23 hours.

MOST TEAMS HAVE NO DATA. ENGRAM MAKES IT.

A model is only as good as what it learned from, and most teams do not have a labeled dataset sitting around. Engram builds it: it finds the data, cleans it, labels it with your own AI, and then does the thing nobody does, it measures how good those labels are. seven sources. three kinds of data. one datasheet.

source

what it does

text

image

audio

hugging face

a public dataset, picked and sampled for you

web search

bulk search: many queries, date windows, saturated domains excluded

agent records

typed records researched with evidence, run until the target

verified lists

entities that meet your criteria, enriched with extra columns

your url list

pages fetched as text, or files downloaded from safe public addresses

synthetic

written scenario by scenario, kept only if independent passes agree

your own files

a table, or a zip with one folder per class

  1. 01

    SOURCE

    Any of seven sources, for text, images or audio. Every file keeps its URL, domain and a license class.

  2. 02

    CLEAN

    Exact and near duplicates out (file hashes, perceptual hashes for images), personal data masked, broken files dropped.

  3. 03

    LABEL

    Several independent passes from your own Claude or Codex. Images by CLIP zero-shot. Doubtful rows held back.

  4. 04

    CHECK

    Accuracy measured against a gold set, with an interval. Suspect labels flagged. Train and test never overlap.

  5. 05

    SHIP

    Train, validation and test files, a datasheet, a zip. Or train a model on it with one flag.

LABELS YOU CAN MEASURE.

AI labels only tell you what the labeler thinks. So Engram checks them against people, three ways, and writes the result down.

  • hand-labeled gold set

    A random sample, confident or not, goes to your people to label without seeing the AI's answer. Unbiased accuracy, with a 95% interval.

  • your own gold file

    Bring examples whose answers you know. They are labeled blind and scored, with recall per label.

  • spot checks and review

    Doubtful rows are held out until a person decides them. A random sample of confident rows measures how right the AI really is.

an excerpt of a datasheet · numbers illustrative

## Label quality
- Method: 3-pass AI labeling, claude + codex
- Hand-labeled gold set: people labeled 100 random
  rows without seeing the AI's label; the AI
  agreed on 94% (95% CI 0.88 to 0.97)
- 7 low-confidence rows held out for review

## Cleaning
- Exact duplicates removed: 12; near: 31
- PII masked: EMAIL 48, PHONE 9, CARD 2
- Labels flagged as suspect: 5
- Train/test overlap: 0

## Provenance
- 214 domains, license mix recorded per document

YOUR PEOPLE.
NOT OURS.

Engram does not rent you a labeling workforce. It gives your own teammates, domain experts or contractors a link. No account, no install: they type a name and label rows on a phone. Gold rows hide the AI's answer, images show up as pictures, audio plays in the page, and the dashboard counts who decided what.

$ engram review ds_9a1f --share

  send this to your labelers (no account needed):
  https://…/review/Xq3…

$ engram review ds_9a1f --apply
  rebuilt ds_9a1f: 1,184 rows, accuracy measured

revoke the link whenever you like.

one sentence in, a dataset out

text from the web

engram dataset "billing complaints with the issue type" \
  --source web --labels billing,bug,other --gold-review 100

records with evidence

engram dataset "seed-stage companies building AI coding agents:
  name, site, what they do" --source agent --effort high

images

engram dataset "photos of cracked and intact phone screens" \
  --source hf --modality image --labels cracked,intact

your files, labeled

engram label "urgent means the customer cannot use the product" \
  --data tickets.csv --labels urgent,normal --gold gold.csv

licenses are a setting, not a gate. By default Engram keeps everything it finds, raw data and all, and records each document's license class so you can filter later. One switch keeps only open-licensed sources. Downloads only touch public addresses, size-limited. Train a model on the result with --dataset, or just download the zip.

THE MODEL EXISTS. CHANGE IT. MEASURE IT.

Frameworks exist for good reasons: the numerics of quantization, the kernels, the architectures and tokenizers are easy to get subtly wrong. So Engram uses them instead of rewriting them, and adds the part nobody does by hand: it runs the original and the result through the same predictor and tells you what the change cost. four operations. one measured verdict.

  1. 01

    QUANTIZE

    bitsandbytes · llama.cpp · gptq · awq

    4-bit and 8-bit, GGUF for Ollama and llama.cpp, GPTQ and AWQ. Reports how much quality the smaller model kept.

  2. 02

    MERGE

    mergekit

    Linear, slerp, ties, dare_ties, task arithmetic. Compared against every source, so you know if the merge helped.

  3. 03

    DISTILL

    peft

    A big model answers your prompts, a small one learns from the answers. Reports the share of the gap it closed.

  4. 04

    ABLITERATE

    heretic · directional ablation

    Removes refusals from open-weight models, with an acknowledgement. Refusals and KL measured before and after.

WHAT IT COST.

A smaller model is only a good trade if you know what it gave up. Every operation reports the same things, measured the same way, before and after, and the verdict is allowed to say no.

  • quality kept

    Your task score after over before, with a 95% interval, when you give example prompts. Without them, the likelihood of general text, and the report says your task was not measured.

  • size, memory, speed

    Bytes on disk, peak GPU memory, tokens per second and latency of both models.

  • how far it moved

    KL divergence of the next-token distribution from the original. For refusal removal, refusals before and after on held-out prompts.

quantize · bitsandbytes 4-bit · measured on your prompts

$ engram ops quantize owner/your-model --method bnb-4bit

               original    result
  size         0.99 GB     0.47 GB
  perplexity   22.49       25.29
  KL diverge.  -           0.332
  GPU memory   1.55 GB     1.05 GB
  quality kept             88.9%

below bar at the default 95%.
small models lose more than large ones.
the point is that you see the number
before you ship the model.

REFUSALS ARE
A SETTING.

Removing a model's refusals is a real need for medical, legal and security work, and for alignment research. It is also the operation most open to misuse, so it has rules: open-weight models whose license allows modification, your explicit acknowledgement, refusals and KL divergence measured before and after, and a model card that says what was done. Heretic runs unmodified, as its own command.

$ engram ops abliterate owner/your-model \
    --method direction --i-understand

  refusals      98% → 3%
  KL            0.100
  quality kept  97.5%

refusals are counted with a keyword rule on held-out prompts. every run prints its own numbers.

AGENTS WRITE CODE. THEY CAN'T TRAIN A MODEL.

Claude, Codex and Cursor will happily write the integration. Ask them for the model itself and they hit a wall: no gpu, no dataset, no evaluation harness, no place to host the result. Engram is that missing half, exposed as tools an agent can call.

you  "users are spamming listings. deal with it."

agent   reads the repo, finds listings.csv
agent   calls engram_solve(task, data_path, target)
engram  plans, trains, evaluates, deploys
agent   gets back:
  {"verdict": "delivered", "metric": "f1_macro",
   "holdout_score": 0.94, "baseline_score": 0.47,
   "model": {"endpoint": ".../models/mdl_…/predict"}}

agent   wires the endpoint into your app
you      review one pull request
  • machine-readable

    The commands speak --json. Results are verdicts and numbers an agent can branch on, not progress bars.

  • errors that tell it what to fix

    Not "failed". "Output column 'price' not found. Columns: [...]". The agent corrects the data and re-runs.

  • long jobs don't block

    engram_status polls. A custom job that takes hours reports its estimate, then the agent comes back for the result.

  • it knows when to ask

    engram init installs a skill that teaches the agent when a problem is a model problem, and to read a below_bar verdict as a warning, not a green light.

the example above is illustrative: the shape of the result is real, the numbers are not from a customer.

One sentence and a folder of examples. Same honest evaluation every time: a held-out test set, a baseline, a confidence interval, and a verdict that is allowed to say no.

classifycheap, fast, runs on cpu

  • trust & safety

    engram solve "" --data listings.csv --min-score 0.9

    → a few-millisecond classifier that replaces a per-listing LLM call

  • support

    engram solve "" --data tickets.csv --target team

    → routing on day one, with a per-team confusion matrix to show where it is weak

  • voice of customer

    engram solve "" --data reviews.csv

    → sentiment and intent on every review, without a per-review API bill

  • moderation

    engram solve "" --data comments.csv

    → a first pass that sends only the hard cases to people

  • documents

    engram solve "" --data docs.csv

    → document typing at ingestion time, in milliseconds

  • engineering

    engram solve "" --data logs.csv

    → triage that learns your own logs, not someone else's

predict & monitortables in, numbers and flags out

  • growth

    engram solve "" --data accounts.csv --target churned

    → a tabular model, leakage-checked, with the columns that drive it

  • payments

    engram solve "" --data payments.csv --target fraud

    → a fraud signal with precision and recall per class, not one flattering number

  • operations

    engram solve "" --data trips.csv --target minutes

    → a regression with an honest error bar, not just an R²

  • supply chain

    engram solve "" --data sku_weeks.csv --target units

    → demand from lag features you already have in a table

  • industrial

    engram solve "" --data sensors.csv --target failed

    → predictive maintenance as a classifier on features you already log

  • sales

    engram solve "" --data leads.csv --target won

    → a ranking your reps can trust, with the leakage warnings to prove it

see & hearfrozen pretrained encoders, gpu once

  • manufacturing

    engram solve "" --data parts.zip

    → folders in, endpoint out: send a photo, get a label and a confidence

  • marketplaces

    engram solve "" --data photos.zip

    → auto-categorisation from the image alone

  • finance ops

    engram solve "" --data uploads.zip

    → a gate in front of your expensive OCR step

  • content

    engram solve "" --data calls.zip --type audio_classification

    → audio the same way, scored on files it never heard

text in, text outfine-tuned on your examples

  • back office

    engram solve "" --data pairs.csv --type text_generation

    → extraction scored against your own reference outputs

  • product

    engram solve "" --data notes.csv --type text_generation

    → a fine-tuned text model that imitates your examples, with the worst misses listed

  • catalog

    engram solve "" --data titles.csv --type text_generation

    → clean, consistent titles without a per-title API bill

your own language modellora on open llms, a100 and h100 when it needs them

  • support

    engram solve "" --data replies.csv --type custom

    → an open LLM fine-tuned on your replies, scored on held-out tickets

  • agents

    engram solve "" --data calls.csv --type custom --metric exact_match

    → structured output your agent can trust, checked against known answers

  • cost

    engram solve "" --data labeled.csv --type custom

    → distil an expensive prompt into a model you host: same task, no per-call bill

  • domain

    engram solve "" --data qa.csv --type custom --metric rouge_l

    → domain Q&A from your examples, with every failure listed in the report

  • reasoning

    engram solve "" --data problems.csv --type custom --metric exact_match

    → fine-tuned for the final answer, scored on problems it never saw

change a modelbitsandbytes, llama.cpp, mergekit, heretic: measured before and after

  • shrink

    engram ops quantize Qwen/Qwen2.5-7B-Instruct --method bnb-4bit --data tickets.csv

    → a quarter of the memory, with the quality it kept measured on your own tickets

  • merge

    engram ops merge owner/support-ft owner/code-ft --method slerp

    → two fine-tunes in one model, and whether it beats each of them

  • distill

    engram ops distill --teacher Qwen/Qwen2.5-7B-Instruct --student Qwen/Qwen2.5-3B-Instruct --data prompts.csv

    → a small model taught by a big one, with the share of the gap it closed

  • refusals

    engram ops abliterate Qwen/Qwen2.5-7B-Instruct --i-understand

    → less over-refusal for medical, legal or security work: refusals and KL divergence before and after

make the datano model needed: web, hugging face, synthetic or yours, labeled and measured

  • support

    engram dataset "" --source web --labels billing,bug,other --gold-review 100

    → thousands of real passages from the web, labeled by your AI, with accuracy measured by your own people

  • sales & research

    engram dataset "" --source agent --effort high

    → structured records with evidence URLs, researched in repeated runs until the target

  • vision

    engram dataset "" --source hf --modality image --labels cracked,intact

    → a public image dataset picked, sampled, de-duplicated and split, with the license recorded

  • audio

    engram dataset "" --source hf --modality audio --rows 600

    → clips validated and split, with durations and sources in the datasheet

  • rare cases

    engram dataset "" --source synthetic --labels fraud,legit

    → examples your agent writes, kept only if independent passes agree on the label

  • your own rows

    engram label "" --data tickets.csv --labels urgent,normal --gold gold.csv

    → AI labels for the data you already have, scored against examples you know are right

  • extraction

    engram dataset "" --source urls --data urls.csv

    → structured fields extracted from every page on your list

anything elseyour agent writes the code, engram scores it

  • voice

    engram solve "" --data calls.zip --type custom --metric wer

    → a transcription pipeline with a word error rate on held-out calls

  • vision

    engram solve "" --data shots.zip --type custom --metric box_f1

    → detection scored by box overlap, not by how the demo looks

  • reasoning

    engram solve "" --type custom

    → no examples? your agent writes them, and the report says the score only measures agreement with it

  • data tools

    engram solve "" --data questions.csv --type custom

    → checked against the answers you already know

three verdicts. the third one saves you a client.

DELIVERED

Beats the baseline and meets your bar on data it never saw. Endpoint is live, bundle is ready.

BELOW BAR

Useful, but misses your quality or latency target. Use it for triage, not automatic decisions.

INFEASIBLE

The data has no signal, or ML is the wrong tool. You get the reason instead of a model that only looks finished.

honest by design

  • ✕the test set is carved off first and never touched again
  • ✕duplicates are removed before the split, so nothing leaks across it
  • ✕synthetic rows train. they never score.
  • ✕a baseline sits beside every number
  • ✕custom code is scored by engram, never by itself
  • ✕examples written by your agent are flagged, and the score says so

a score without its baseline, its interval and its test set is a marketing number. every report here carries all three.

endpoint

A live URL the moment the verdict lands. It scales to zero when idle, so you pay nothing for quiet hours; the first call after a pause wakes it. Try it from the dashboard.

bundle

Model, predict.py, serve.py, a Dockerfile and a model card in one zip. Run it on your laptop, your cluster or your client's. You are not renting it.

drift

engram drift compares what the model predicts this week with the mix it was tested on, and says stable, watch or drifting. It tells you when to look, not whether it is wrong.

retrain

engram retrain --data fresh.csv reruns the same job on new examples as a new model id. The old one keeps serving while the run log shows whether the score went up or down.

SEE THE BILL BEFORE IT EXISTS.

  • before

    The dashboard shows machines, minutes and dollars before you press go. Custom jobs log your agent's own estimate before training starts.

  • during

    Parallel or one at a time. Sequential stops early the moment your spend limit is reached.

  • a hard no

    Set --max-cost and a job whose estimate is higher refuses to start. Nothing is spent.

  • no clock

    Custom training has no fixed time cap. The agent sizes the work to the problem and tells you how long it expects.

real runs from our own tests, on small datasets: a text-generation fine-tune on a GPU took 97 seconds and about $0.03. Embedding and classifying 80 images took 66 seconds and about $0.01. Your data will differ; the point is you are shown the number first.

terminal

engram solve "route support tickets
  to billing, technical,
  sales or urgent" \
  --data tickets.csv --target team \
  --folds 5 --repeats 3 --max-cost 0.25

claude code · codex · cursor

engram init

# adds a skill so your agent runs the engram CLI.
# then just ask your agent:
# "users are spamming listings, fix it"

any language

curl -X POST $ENGRAM/api/v1/models/$ID/predict \
  -H "Authorization: Bearer $KEY" \
  -d '{"inputs": ["win a free iphone"]}'

FAQ

The questions people ask before they trust a model they did not build, answered without the marketing. Something missing? It is probably in the docs.

01Do I need my own Claude or Codex account?

For the thinking, yes: scoping the problem, labeling data, writing examples and writing the code for custom tasks all run on your own subscription, in an isolated session. Engram supplies the compute, the evaluation and the hosting, so there is no markup on the intelligence. Without an account you can still train on a labeled upload or a public dataset with a deterministic planner.

02What does it cost?

It is a private beta and free for now: you bring the AI account, we cover the compute. Either way you see the price before you spend it: a built-in estimate in the dashboard, your agent's own estimate for custom jobs, a monthly cap, and a max-cost setting that refuses to start a job whose estimate is higher. Web search for datasets is capped per job.

03Where does my data go?

Uploads are stored on Engram's cloud storage, and training, labeling and dataset building run on cloud machines. Planning and labeling go through your own AI account. Nothing is shared between users, and custom code runs in a sandbox that cannot see other people's data. If your data cannot leave your perimeter at inference time, download the bundle and run it yourself: it is weights, code and a Dockerfile.

04Can I take the model with me?

Yes. Every model comes with a downloadable bundle: the weights, the prediction code, a server, a Dockerfile and a model card. Nothing is locked in. A live endpoint is there too, and it scales to zero when nobody is calling it, so quiet hours cost nothing.

05How do I know a score is real?

The test set is split off before any design is chosen and is never used for training. Duplicates are removed before the split, a baseline sits next to every number, and you get a confidence interval and a verdict that is allowed to say no: delivered, below your bar, or infeasible. For custom tasks, Engram runs your agent's predictor on the held-out inputs and scores the outputs itself.

06What can it build?

Classifiers for text and tables, image and audio classifiers, text-to-text models, fine-tuned open language models, and anything else you can show with examples (transcription, detection, reasoning with checkable answers) through custom tasks where your agent writes the code. The GPU options run from a T4 up to eight H100s.

07Can it fine-tune an LLM?

Yes, as a custom task: your agent writes a LoRA or QLoRA fine-tune of an open model, picks the GPU, and gives you a time and cost estimate before training starts. Sandboxes last at most 23 hours. We have run the full path on small models; very large ones use the same route with bigger GPUs, so read the estimate and set a max cost.

08What if I have no data?

Build it. Engram can pull a public dataset from Hugging Face, search the web in bulk, have an agent research structured records with evidence, fetch the pages on a list of URLs, or have your agent write examples that must pass independent verification. It handles text, images and audio, and gives you train, validation and test files with a datasheet.

09Are AI labels accurate?

Only as accurate as you check. Engram labels with several independent passes and holds doubtful rows back, and it measures accuracy against a gold set: examples you already have, or a random sample that your own people label without seeing the AI's answer. If nothing was checked, the datasheet says so in plain words.

10Who labels the gold set?

You do. Engram does not supply a labeling workforce. On the dataset page you create a review link and send it to teammates, domain experts or contractors. They need no account, they enter a name and label rows, and you apply their decisions when you are ready.

11Is web data licensed?

By default Engram keeps what it finds and records a license class per document, so raw data is not blocked. One setting keeps only open-licensed sources. The classes are a heuristic by domain, not legal advice, and what you do with the data is your decision.

12Can it quantize, merge or distill a model I already have?

Yes. Model operations take an open language model from Hugging Face, apply a known framework (bitsandbytes, llama.cpp for GGUF, llm-compressor for GPTQ and AWQ, mergekit, a LoRA distillation) and measure the result against the original on the same prompts: quality kept with an interval when you give example prompts, size, GPU memory, speed and KL divergence. You get a verdict, a served endpoint and a bundle. The model has to be public on Hugging Face (as safetensors): Engram downloads it by its id, because the work runs in the cloud and cannot see files on your machine. Private, gated and local models are not supported yet. If your model is on your own machine and can be public, push it first with the Hugging Face CLI (hf auth login, then hf upload your-name/your-model ./model-folder) and use that id. Confidential weights cannot be used yet; for those, run the same tools yourself, since the docs list the exact frameworks and settings.

13Can it remove a model's refusals?

Yes, as the abliterate operation, with Heretic or directional ablation. It only runs on open-weight models whose license clearly allows modification, it needs your explicit acknowledgement, it reports refusals before and after with the quality kept, and the model card and report say the model was modified. The refusal count is a keyword rule, so the report shows sample responses to let you judge it.

14How long does a job take?

A classifier on a table or text is minutes. Image, audio and text-generation jobs use a GPU and take minutes to an hour on small data. Custom jobs have no fixed time cap: your agent estimates the time, the run stops at three times that estimate, and nothing runs longer than a sandbox allows.

15What compute does it run on? Do I need GPUs?

You rent nothing and manage nothing. Engram picks the machine for the job and starts it for the run: plain CPUs for classifiers on text and tables, and a GPU for images, audio, text-to-text models and anything custom. For fine-tuning, your agent chooses the card (T4, L4, A10G, L40S, A100, H100 or H200, up to eight at once) and tells you the price first. Machines shut down when the job ends, and endpoints scale to zero when idle. Compute is ours, not yours to bring: if you want to serve a model on your own hardware, download the bundle.

16What happens when a model goes stale?

Every prediction updates a tally of what the model says, and a drift check compares the last week with the mix it was tested on. When it moves, retrain on fresh data with one command. The old model keeps serving until you switch, and the run log shows whether the new score is better or worse.

17Do I have to write code?

No. Describe the problem in a sentence in the dashboard or the CLI, or let your coding agent do it: the CLI or the MCP server lets Claude Code, Codex or Cursor ask for a model or a dataset mid-task and wire the endpoint in. The docs cover the CLI, the REST API and the MCP tools.

private beta. free for now: you bring the ai account, we cover the compute. your first model takes a few minutes.

GET STARTED →