engram 0.1 / models from problems.
you describe it. the lab runs it.
- 1.
- 2. spam, fraud, churn, routing
- 3.
- 4. images, audio, transcription, detection
- 5. your own fine-tuned LLM
- 6. swap an $8k/month prompt for a model you own
- 7.
- 8. your problem here
- 9.
- 10.
- 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.
- 2. install the cli
- 3.
- 4. engram login, engram connect claude
- 5. engram solve "…" --data file.csv --min-score 0.9
- 6.
- 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
- 01find or buy a dataset
- 02clean it, dedupe it, balance it
- 03label what is unlabeled
- 04pick a model family
- 05pretrain or fine-tune?
- 06compare designs, tune settings
- 07rent gpus, mount volumes
- 08hold out a test set you did not peek at
- 09package it, serve it, scale it
- 10watch it drift, retrain it
- 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.
cost
Past a certain volume you stop paying per call and start paying per GPU-hour. A small model tuned to your task can replace a flagship API for that task, and the gap grows with every request.
privacy
The bundle is a plain folder: weights, code, Dockerfile. Run it in your own cloud or on a laptop and your customers' data never leaves your perimeter at inference time.
latency
No round trip to a vendor and no shared queue. A classifier answers in milliseconds next to your own code, and you pick the hardware for anything bigger.
control
You pin the weights. A vendor cannot retire, reprice or quietly change the model your product runs on.
ownership
"Our own models, trained on our data" is a different sentence to a customer or an investor than "we call someone's API". It is also an asset, not a bill.
speed
A predictive feature stops being a quarter of hiring and infrastructure. Your team, or your coding agent, asks for it and has an endpoint the same day.
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.
six stages. none of them yours.
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.
get data
Use your upload, label it with your own AI account, or source a permissively licensed public dataset with recorded provenance.
fill gaps
Under-represented classes get synthetic examples — added to training folds only, never to the test set.
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.
evaluate honestly
One look at an untouched holdout, a bootstrap confidence interval, a baseline, leakage and duplicate checks, latency on real inputs.
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
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
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
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
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
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
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
01
SOURCE
Any of seven sources, for text, images or audio. Every file keeps its URL, domain and a license class.
02
CLEAN
Exact and near duplicates out (file hashes, perceptual hashes for images), personal data masked, broken files dropped.
03
LABEL
Several independent passes from your own Claude or Codex. Images by CLIP zero-shot. Doubtful rows held back.
04
CHECK
Accuracy measured against a gold set, with an interval. Suspect labels flagged. Train and test never overlap.
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.
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.
02
MERGE
mergekit
Linear, slerp, ties, dare_ties, task arithmetic. Compared against every source, so you know if the merge helped.
03
DISTILL
peft
A big model answers your prompts, a small one learns from the answers. Reports the share of the gap it closed.
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.