Medicine has one. Law has one. Code has several. Marketing, the biggest discretionary spend in business, has none. We are building it in the open, measuring it against an exam we published first, and giving the whole thing away.
Apache 2.0. Free to download, free to run offline, free to sell what you build with it.
01The gap
Every serious field has its own model. Marketing does not.
Marketing is the largest discretionary spend in business and the only major field without an open model of its own. Every tool in the category, Jasper and Copy.ai and AdCreative among them, rents a general model from someone else and marks it up. We are building the one nobody else bothered to, and giving it away.
MedicineMed-PaLM, BioGPT, BioMedLM
LawChatLaw, DISC-LawLLM, PKUlaw
FinanceBloombergGPT, FinGPT
CodeCode Llama, DeepSeek Coder
ScienceGalactica
Marketingnothing open exists
02What it does
Five jobs marketers do every day
Five jobs, done in milliseconds on your own machine, at zero marginal cost, with your data never leaving it. Run it ten million times and the bill is the same as running it once. It will not out-think Claude at open reasoning, and we publish exactly where it loses, but on repetitive structured work it is faster, cheaper and more consistent than anything you are renting.
creative_tag
Tag ad creative
Show it an ad. It tells you the hook, the angle, who it speaks to, what it offers, and where it sits in the funnel. Always the same labels, so you can count them.
ad_copy
Write ad copy
Say what you are selling and to whom. Get a headline, body text, and button label that already fit the platform's character limits.
metric_diagnosis
Diagnose a campaignbase model
Paste your numbers. It names what is broken and what to fix first. If there is too little data to tell, it says so rather than guessing. Our own adapter lost this job to the plain base model nine to one under blind judging, so this one ships as the base with a task prompt.
lead_qualify
Score a lead
Give it what you know about a lead. Get a score, a band, and the exact signals behind it. It never invents a reason it cannot point to.
chat
Answer questionsbase model
Ask anything about marketing. Get a direct answer, or a question back when a number it needs is missing. We do not claim to beat the base model here: one run had the base ahead, a later one had us ahead seven to three, and a ten-item slice cannot separate them.
ad_policy
Predict ad rejectionsmaybe
Would this creative be rejected, and why. Nothing does this today. We are still deciding whether it makes the first release.
Liveruns today, on your machine
Works with the tools you already use
Serve it locally and it speaks the OpenAI protocol, so the only line that changes is the base URL. No key, no account, no request leaving your machine, and the same code works with llama.cpp, Ollama, LM Studio or vLLM.
We have not built a hosted endpoint and are not promising one. This is the whole product: a 2.3 GB file and a server you already have.
python
# one time
llama-server -m gloofy-1-nano-Q4_K_M.gguf --port 8080
# then, from anywhere in your stack
from openai import OpenAI
client = OpenAI(
base_url="http://127.0.0.1:8080/v1",
api_key="not-needed",
)
client.chat.completions.create(
model="gloofy-1-nano",
messages=[{"role": "user",
"content": "Tag: Still paying 3% on card payments?"}],
)
# {"hook": "question", "angle": "pain_relief",
# "persona": "business_owner", "offer": "lead_magnet",
# "funnel_stage": "consideration"}
03The numbers
Every specification, and what each one means
Most model cards publish a table like this and explain none of it. Ours comes with plain English underneath every row, and the size was not chosen by taste: we trained the same data at 1.7B, 4B and 8B and measured that 8B bought nothing over 4B. So 4B ships, at half the download, for the same accuracy.
Specification
gloofy-1-nano
Parameters
4.0B
Architecture
Dense
Context window
32,768 tokens
Vocabulary
151,936
Download (4-bit)
~2.5 GB
Runs on a laptop
8 GB RAM
Licence
Apache 2.0
Built from
Qwen3-4B
Parameters
The adjustable numbers inside the model, learned during training. More usually means smarter, but slower and dearer to run. Ours has 8.2 billion. The largest open model today has 2.8 trillion.
Context window
How much text it can hold in mind at once. 32,768 tokens is roughly 90 pages. Go past it and the earliest text falls out of view.
Tokens
Models cannot read letters. Text is chopped into word-sized pieces first, and a token is one piece. Roughly four characters of English each.
Dense vs mixture-of-experts
Dense means every parameter is used for every word. Mixture-of-experts models switch on only a slice at a time, which is how a 2.8-trillion model can be affordable to run. Ours is dense because at this size it is simpler and faster.
Quantization
Storing each number with less detail so the file shrinks. Four-bit makes the download about four times smaller and costs a little accuracy. It is why an 8-billion model fits on a laptop.
Apache 2.0
A licence that lets you use it commercially, change it, and ship it inside your own product, without asking us or paying anyone.
04Models
Three entries, one of them not a model
Named now so the plan can be judged later. Every gloofy-1 weight goes on Hugging Face under Apache 2.0: download it, fork it, run it offline, sell what you build with it, and owe us nothing. A model you cannot hold is not infrastructure, it is a subscription. The second is older and does not belong to that line, so its licence is Meta’s rather than ours and every card below says which it carries. The third has no weights at all: we trained it, the untrained base beat it, and shipping the prompt instead of the model was the honest answer and the cheaper one.
Released, Apache 2.0, on Hugging Face. On the re-adjudicated exam v3.3 (the earlier one was ~19% mislabeled), the clean-label models place second and third of eight: gloofy-14B at 0.816 and gloofy-4B at 0.808, tied with Mistral Large 3 (675B, 0.825) within measurement error and ahead of Kimi, Gemma, Llama and GPT-OSS. Clean Opus training labels are the lever, not size. The published r25 4B scores 0.796 on the clean exam; its q4_k_m GGUF is measured, not inferred. All artifacts are on Hugging Face.
Older, and outside the marketing line: an emotional companion model with six personas, built on Llama 3.1 rather than Qwen3, so Meta's terms apply instead of Apache 2.0. It runs nothing here, it was never benchmarked, and the notebook holding its exact recipe did not survive. Published anyway, because weights nobody can download help nobody.
A composition LoRA on Qwen-Image that improves safe-band placement without cutting the product. Measured correctly, after a first harness loaded the wrong architecture and is retracted: 0.566 of image saliency inside Meta's 9:16 safe band across three seeds, up +0.045 from the base 0.521, keeping 100% of the subject. A naive crop gets higher alignment (0.596) but discards ~24% of the product, so the honest claim is best-placement-without-cropping, not a win over cropping.
Livecomposition adapterApache 2.0
05marketing-bench
The test comes out before the model
Medicine has a shared exam written by 262 doctors. Law has one. Marketing had nothing, so we built it: three exam series, 371 questions, 917 real ads labelled by three blind annotators each, and a published human ceiling for every set. It goes public BEFORE our model does, so we cannot quietly rewrite the questions to flatter our own answers.
Public, with five exams and every version kept
587 items across five series: one frozen forever for comparability, one stratified, one of 150 real published ads. When better labelling rules invalidated an answer key we re-keyed it and shipped BOTH versions, because the same model scores 0.46 on the old key and 0.64 on the corrected one. Benchmarks that quietly swap their answers are worthless, and almost all of them do it.
We publish our own losses
Claude, GPT-5.5 and Gemini 3.6 all beat gloofy on our own exam, 0.916, 0.792 and 0.817 against our 0.675, and the table says so in the same size type as everything else. Every competitor in this category benchmarks itself on an eval nobody outside the company can see. Ours ships with the harness, the data and the exact command to reproduce it.
Wider than our own model
It tests marketing work in general, not the slice we happen to be good at. A test written around its own author is advertising with a table in it.
Ceilings published, and named honestly
Every item is labelled by three blind annotators, which are Claude agents rather than people, and we say so rather than implying a panel of humans. They agree 91 percent of the time on real ads and 87 percent on boundary leads, so we publish a ceiling per task instead of one flattering number, and we state that Claude is therefore graded against a key its own family wrote.
06API
The score ships inside the response
gloofy-image is served behind a key you issue yourself: one call to get a key, one call to generate. Every image comes back with its measured safe-band score, so a pipeline can gate on passes_safe_zone instead of trusting the model. Beta: one GPU, about 45 seconds an image, 50 images a day per key.
# 1. issue yourself a key (one per email, shown once)
curl -X POST https://api.gloofy.ai/v1/keys \
-H 'content-type: application/json' -d '{"email":"you@company.com"}'
# 2. generate a 9:16 ad creative with the composition LoRA
curl -X POST https://api.gloofy.ai/v1/generate \
-H "X-API-Key: gk_..." -H 'content-type: application/json' \
-d '{"prompt":"matte black water bottle on wet slate, dawn light","safe_zone":true}'
# 3. the part no other image API returns
"compliance": {
"in_band": 0.671, // fraction of attention inside Meta's live area
"safe_band": [0.14, 0.65], // what platform chrome does not cover
"passes_safe_zone": true // gate your pipeline on this
}
The compliance block is the product. Generation is a commodity; the measured guarantee that the subject sits where the placement can show it is not, and it is scored by the same instrument as the benchmark above, not by the model grading itself. This endpoint is what overads' creative studio calls internally: same key system, same score, gated on the same number.
07Build log
Built in the open, from the first line of code
Twenty rounds of measured experiments, every one published with its real numbers, including the four conclusions we had to retract when a variance test proved them noise. We audit our own benchmark and print what the audit finds. Name another model project that does.
12 entriesscroll sideways
the base won four of five
We found out when fine-tuning is actually worth it
Five jobs, each measured against the untrained model we built from. We lost four of them. On campaign setup the plain base named the right country's currency three quarters of the time against our third, and never once fell into the repetitive stalling ours did in one answer of every five. We won hooks, thirty six to nine. Facts belong in the instructions, and training on them costs a model its ability to follow instructions at all. Only the tacit things, like what makes six words land, have to be learned.
our ceiling was never human
The baselines beat us, and exposed a false label of ours
Three problems surfaced, all ours. The exam never listed its own field names, so GPT and Gemini invented their own schema. Claude then beat a ceiling we had called human: our annotators are Claude agents, so it was graded against a key its own family wrote. And gloofy fell seven points when asked in unfamiliar words, which was prompt familiarity, not judgment.
0.34 swing from a random seed
We retracted six rounds of conclusions
Three runs on identical data, differing only by random seed, scored 0.56, 0.78 and 0.44 on the same ten-item slice. Aggregates barely moved, so those hold, but every per-slice story we had told about which data round fixed what was noise dressed as causation. Four published conclusions withdrawn. The check should have been our first experiment, not our twentieth.
3 validation examples
Every stopping decision was made on noise
The splitter was reserving exactly three examples for validation against 803 for training. A loss computed on three items moves more with which three landed in the split than with the model, so the curve we had read for a dozen rounds was mostly random. One checkpoint chosen by that broken signal scored 0.42 where a differently-stopped run scored 0.66.
0.46 to 0.64, same model
The exam had drifted, not the model
A data round that should have helped appeared to hurt one stratum. Our labelling rules had improved months earlier and the answer key never followed, so the model was marked wrong for agreeing with our own current annotators. Re-keying by fresh consensus moved it from 0.46 to 0.64 without touching a weight. Both keys ship, versioned with the rules that made them.
1.7B 0.71, 4B 0.75, 8B 0.75
The scaling curve flattened at 4B
Identical data, identical steps, three model sizes. Doubling 4B to 8B bought nothing, and asked again later with the prompt confound removed, 8B came back worse at 0.741 against 0.780. The bigger model learns the training data better and generalises no better, which is the signature of a data ceiling rather than a capacity one. 4B ships, at half the download.
lead score 0.64 to 0.81
Specialists beat one shared adapter
Five tasks had spent four rounds stealing capacity from each other inside one adapter, every gain paid for by another task's loss. Training one adapter per task ended it: both specialists converged where the combined model never had, and lead scoring jumped seventeen points. Adapters are small, so serving a family of them costs no more than serving one.
tags 0.71, leads 0.72
A stratified exam, and what it exposed
Built a second exam of 126 fresh items, stratified so every cell is separately measurable, with three blind annotators labelling each one. It immediately showed what the average had been hiding: obvious hot leads score perfectly, twelve out of twelve, while anything near a band boundary is a coin flip. Two different problems had been averaged into one number.
0.751 to 0.683, then 0.717
More data made the model worse
Adding 200 examples dropped every score. We blamed training past the optimum, retrained for 47 percent fewer steps, and got the best model so far. Later we found the validation curve behind that diagnosis was computed on three examples, so the reasoning was thin even though the fix worked. Kept here as recorded rather than quietly tidied up afterwards.
ad copy 13 of 13
Judged blind, in both orders
Three judges compared our model against the untrained one on 39 questions, each shown twice with the answers swapped so position could not decide it. Our model swept ad copy and lost open conversation to the model it was built from. Campaign diagnosis it lost nine to one, so that job now ships as the untrained base rather than our own adapter.
84 labels corrected
The day label quality beat model size
Doubling the training data bought nothing. A model with 2.4 times the parameters bought almost nothing either. Fixing 84 inconsistent labels, found by having three annotators judge the same ads blind and comparing where they disagreed, bought more than both changes combined. Past a certain point the quality of your data simply is the model.
3.2M parameters, 287 seconds
A language model from absolutely nothing
A small model trained on Shakespeare, on a laptop, in under five minutes, with every line of the architecture written by hand first. Nobody told it that plays put speaker names in capitals on their own line. It worked that out unaided from one megabyte of text, which is the moment the whole thing stopped being abstract.
08Promises
Written down early so we can be held to them
marketing-bench v3.3 · re-adjudicated exam150 real published ads · exact facet accuracy
Mistral Large 3
0.825
675B, the leader. 48x larger than our best model, and ahead by 0.009 — inside sampling noise at n=150
gloofy-14B
0.816
14B, free, offline, trained on clean Opus labels. Second, tied with the 675B leader within measurement error, ahead of every other model
gloofy-4B
0.808
4B, free, offline, clean labels. Third — a laptop-runnable model beating Kimi, Gemma, Llama and GPT-OSS, close behind the two leaders
gloofy-4B (r25, published)
0.796
the older 4B on noisier cross-family labels. Clean labels are the +0.012 to gloofy-4B above
Kimi K2.5
0.791
large MoE, below both gloofy models on the clean exam
Gemma 3 27B
0.731
27B
Llama 3 70B
0.725
70B
GPT-OSS 120B
0.701
120B reasoning model — 73,669 output tokens for the lowest score here
A 14B open model, free and offline, sits second — tied with Mistral Large 3 at 675 billion parameters, 48 times its size, and ahead of every other model we measured. The 4B is a hair behind in third. What they cost to run ten million times is nothing, and they never send an ad to anyone else's server. Every number ships with the harness and the exact command to reproduce it.
This board corrects an earlier one, and the correction is the story. We used to show a 4B “tied for first” at 0.792 — but the exam it ran on was about 19 percent mislabeled. Claude Opus, 96.7 percent self-consistent, confidently overrode 142 of 750 gold fields, and re-scoring Mistral on the clean key lifted it +0.052: proof the errors were the key's, not the model's. On the clean exam gloofy is second, not first. The old number was noisy-exam inflation, and we are publishing the fix rather than quietly swapping it.
What actually moved the needle was label quality, not size. The two gloofy leaders were trained on ads labelled by Opus — the same clean annotator — and that alone lifted the 4B from 0.796 to 0.808; the 14B adds 0.008 more. A distilled model matches the frontier when its teacher is clean. At n=150 the top three are within measurement error, so “tied with the leader” is honest and “the winner” would not be.
composition-bench24 paired prompts · saliency inside Meta's 9:16 safe band
crop a taller render
0.596
generate tall, then slide a window to the best-aligned crop. Highest alignment here, but keeps only 76% of the subject: it buys that alignment by cutting the product off
gloofy-image
0.566
composition LoRA on Qwen-Image, 3-seed mean (0.569/0.563/0.566). +0.045 over the base, keeps 100% of the subject. Best placement of any method that does NOT cut the product
Qwen-Image, unaided
0.521
the base model with the same prompt. Keeps 100% of the subject, places it worst
A correction, published as one. An earlier version of this board claimed gloofy-image scored 0.653 and beat cropping. That number came from an evaluation that loaded the wrong model architecture (SDXL, not the Qwen-Image the adapter was trained on), so it never measured the real model. Re-run correctly, the picture is more honest and less flattering to us: cropping gets the best alignment.
What gloofy-image actually earns is narrower and real: +0.045 of safe-band alignment over the base model, 0.521 to 0.566 across three seeds, while keeping 100 percent of the subject. Cropping scores higher, 0.596, but retains only 76 percent: it moves the product into the safe band by cutting part of it off. So the honest claim is not that we beat cropping. It is that gloofy-image gives the best placement of any method that does not cut your product, which for an ad is the constraint that matters.
This is the second attempt. The first shipped as a prompt and lost, because Meta's safe zones are two numbers and two numbers belong in a prompt. Where the subject LANDS is not a number you can state, and no prompt we wrote moved it; a LoRA does. That is the same dividing line the rest of this project keeps finding: state what can be stated, train only what cannot.
Free forever, in writing
Published on Hugging Face for anyone to download. If we ever switch the website off, the model still works on your own machine.
No paywall
There is no paid plan and none is planned. If that ever changes, the free downloads do not.
No customer data
Nothing from any company or customer is used to train it. Every example is written by us or already public.
Honest about its size
This is a small model. It will not beat Claude or Gemini at general thinking, and this site will never suggest it does.