Words on these pages

Definitions

Short meanings for the words the other tabs keep using.

LLM: A large language model. A program that finishes text. You give it a start, and it keeps guessing the next piece.
Token: A chunk of text, usually a word or a piece of a word. The model reads and writes tokens, not single letters.
Vocabulary: The fixed list of tokens the model is allowed to write. A guess gives every token in that list a chance.
Vector: A list of numbers standing for one token. Tokens that show up in similar sentences get similar lists.
Embedding: The vector for one token. It is learned during training. It is not a number someone typed in by hand.
Transformer: The 2017 design almost every current LLM uses. A stack of layers, and each layer uses attention.
Pre-training: The long first pass. The weights start random. The only job is to predict the next token on a huge cleaned pile of text.
Post-training: Later passes that teach the model to answer like an assistant. Instruction tuning is one. A preference pass, which keeps the better of two replies, is another.
Backpropagation: The walk that computes the gradient for every weight, so the downhill step knows which way to nudge each number.
Batch: Several requests on the same GPU at once. The chip does their multiplications together, instead of waiting for one reply to finish before starting the next.
Attention: The model looking across the other words in the sentence to decide what the current word means. “Bank” leans on “river” or on “money.”
Layer: One pass of looking and mixing. A large model stacks dozens of layers. The last layer produces a score for every possible next token.
Score: A raw number for one possible next token. Scores can be any size. They are not chances yet.
Chance: A score after it has been turned into a share between 0 and 1. All the chances for the next token add up to 1.
Softmax: The formula that turns scores into chances. It boosts the big scores and shrinks the small ones.
Context: The stretch of text the model can see at once. It cannot see past that stretch.
Loss: How surprised the model was by the real next token. The loss is small when it gave that token a high chance, and large when it almost ignored it.
Gradient: The slope of the loss. It says which way each stored number should move so the next guess is less surprised.
Training: Showing the model real text, scoring each guess with the loss, and nudging the stored numbers a little. This happens many times. The loss never has to reach zero.
Instruction tuning: A later training pass, on examples of the reply a person wanted. The first pass teaches what usually comes next. This pass teaches the model to answer the request.
Fine-tuning: More training, starting from weights that already exist, on your own examples. The weights move, and you get a new file. Answering does not do this. The weights stay put while the model replies.
LoRA: A way to fine-tune by training a small set of extra numbers, while the original weights stay frozen. It uses far less memory than rewriting every weight.
Weight: One of the stored numbers inside the model. The weights stay put while the model answers. A new sentence is multiplied by them, and that multiplication produces the chances. They are not the list of possible next tokens.
Open model: A file of weights you are allowed to copy and run. The practice text is not the model. The weights are. Most of these are open weights, not fully open source.
Frontier: Among the most capable models available at the moment. The word says nothing about whether you can download the file. A frontier model is often closed, and a few open-weight models sit near that front too.
Open weights: The weight file is published. You can run it on a GPU you rent or own. The training text and the full training recipe usually stay private.
Open source: Weights, training code, and enough of the data to rebuild the model, under a license that allows that. This is rarer than a published weight file.
Closed model: The weights stay at the lab. You send a prompt to their API and get tokens back. You never receive the file.
CPU: The ordinary processor in a computer. It is built for one job at a time: open a file, branch, decide.
Chip: The calculator on a GPU board. One board has one chip. The chip does the multiplications.
VRAM: The memory on one GPU board. It is several small memory chips added together. The weights sit here while the chip works.
GPU: One board: one chip plus that board’s VRAM. Counting GPUs means counting boards. The chip on one board cannot use the memory on another board.
Byte: A small unit of memory. At half precision, one weight takes 2 bytes. A billion weights is about 2 GB.
Bit: A smaller step than a byte. One byte is 8 bits. At 4 bits, one weight takes about half a byte, so the file is about a quarter of the half-precision size.
Half precision: Storing each weight in 16 bits, which is 2 bytes. This is the usual size before quantization. A billion weights is then about 2 GB.
Gigabyte: About a billion bytes, written GB. The memory formulas on these pages are in gigabytes.
Data centre: A room of GPU boards, with power, cooling, and fast cables between the boards. A frontier-size model is split across many boards there.
API: A way to send your text to a company’s computers and get a reply back. Their machines hold the weights. They can store what you sent.
Prompt: The text you give the model before it starts guessing. On an API, the prompt leaves your machine. On a GPU you own, it stays there.
Self-hosting: Running a published weight file on a computer you control. The prompt is multiplied there. You can also keep training that file on your own examples. A lab API is not self-hosting, even when the lab serves an open file.
Runner: The program that loads the weights into VRAM and writes the next token. Your own software sends the prompt to the runner and reads the reply.
Quantization: Storing each weight with fewer bits so the file uses less VRAM. At 4 bits the file is about a quarter of the half-precision size. The answers get a little less exact.
KV cache: Extra memory used while answering, so the model can look back at the prompt and the tokens it has already written. It grows with the length of the conversation, and with how many conversations run at once. The weights do not grow.
License: The rules that come with the weight file. They say who may run it, and for what. A published file is not a promise that every use is allowed.
Rent: Paying to use someone else’s GPU for a while. You run the open file. They own the machine, so they can see it and switch it off.
Practice text: Sentences used to train a model, or later to try a copy. The practice text is not the model. The weights are. A first self-hosted check uses stand-in sentences that are not private.
Zero data retention: A promise that a company does not keep the prompt and the reply after the answer is sent. A request their safety systems flag can still be kept. Every company in the path has to make the promise, or the prompt still sits with the one that did not.
Distillation: Training a new model on another model’s replies, so the new file imitates it. Anthropic’s usage policy requires their permission before Claude’s outputs are used this way.
Independent variable: The thing you change on purpose between runs. If two things change at once, you cannot tell which one moved the score.
Dependent variable: The thing you measure after the run: the score, the seconds, the dollars.
Constant: What you keep the same so the independent variable is the only difference.
Pass at one: The first try is the one that counts. The task passes only if that try meets the test. Written pass@1.

From nothing

How an LLM works

If you have never heard the term: an LLM is a large language model. It is a program that finishes text. You give it a start. It guesses the next piece, sticks that piece on, and guesses again.

It does not look answers up.

A dictionary stores meanings. An LLM does not. It has practiced on a huge pile of text, and what remains is a giant list of numbers. Those numbers are good at guessing what piece of text usually comes next.

The pile is collected first: books, web pages, code, articles, and the rest. Then it is cleaned. Duplicates go. So does broken or low-quality text. What remains is practice text, not the model.

The rest of this page is that idea, slowly. Words become pieces. Pieces become numbers. Numbers get adjusted until the guesses are less wrong.

Text is chopped into tokens.

A token is usually a word, a piece of a word, or a mark like a comma. The model never sees “unbelievable” as letters. It sees a few chunks, and each chunk has an ID number.

untoken 1 believtoken 2 abletoken 3

The ID is just a label, like a locker number. The meaning lives in the list of numbers that comes next, not in the ID itself.

Each token becomes a list of numbers.

That list is called a vector, and for a token it is also called an embedding. A real model uses thousands of numbers per token. Four is enough to see the idea. The list is learned. Tokens that show up in similar places get similar lists. “Cat” sits nearer “dog” than “invoice”.

A flat drawing of a list that is really thousands of numbers long. Near means “used in similar sentences,” not “means the same thing.”

It looks at the other words to decide.

The word “bank” is ambiguous. The model looks across the sentence and leans on the words that matter. This look is called attention. In 2017 attention became the whole design, called a transformer, because looking at every word at once trains well on GPUs. A usual picture is the word “it” in “the programmer fixed the server because it crashed,” leaning back on “server.” That lean is learned. It is not a rule someone wrote.

The thick line is the look that matters. The thin lines are the other words, still visible, but less used.

It does that look many times.

One look is not the model. The list goes through a stack of layers. Each layer looks again and mixes the numbers. A large model has dozens of layers. The last layer does not output a sentence. It outputs a score for every token that could come next.

Same sentence in, a score for every possible next token out. The sentence itself is not stored as a fact.

Scores become chances that add up to 1.

A score can be any number. A chance has to sit between 0 and 1, and the chances have to add up to 1. The formula that does this is called softmax. It boosts the big scores and shrinks the small ones.

chanceᵢ = e^scoreᵢ / (e^score₁ + e^score₂ + …)

A worked toy. e² is about 7.39, e¹ is about 2.72, e⁰·¹ is about 1.11. Divide each by the sum, about 11.21, and you get 66%, 24%, and 10%.

A reply is one token at a time.

The model picks one next token from those chances, writes it onto the end, and runs again. It can only see a limited stretch of text at once. That stretch is the context.

I satstart byguess 1 theguess 2 riverguess 3

Nothing in that loop checks whether “river” is true in the world. It only checks what the chances say.

Learning scores each guess.

So far we watched a finished model answer. Learning is how those numbers got good. Take a real sentence and cover the next token. The model gives that token a chance. The loss is the score for that guess: small when the chance was high, large when the model barely considered the token that was actually there.

loss = −log(chance of the real next token)

Move the chance it gave the real token.

20% chance · loss 1.61

At 100% the loss is 0. The model was not surprised. At 1% the loss is about 4.6. It was very surprised. Language is unsure, so a trained model does not sit at 0.

Left side: the model barely considered the real token, so the loss is high. Right side: it was almost sure, so the loss is almost nothing.

Training is a small step downhill, repeated.

The weights start as random numbers. The loss is one number. The model is billions of numbers. To make the loss smaller, each number has to move a little. Backpropagation walks the loss and computes the slope for every weight. That slope is the gradient. It says which way. One example nudges every number. The next example nudges them again. This long first pass is pre-training. A frontier run uses thousands of GPUs for weeks or months. The count labs publish is tokens, often in the trillions, not a neat pile of separate documents.

new number = old number − step size × slope

Each dot is one pass over an example. The green dot is where training stops. Some surprise is left, because the next word is often unsure.

The trained model is the numbers you keep.

The articles and code were the practice text. They are not the model. The model is the weights: the inner numbers after all those steps. Copy that file and you have copied the model. When the file is published for anyone to run, it is called an open model. Nobody writes a separate rule for Python, physics, or French. Those patterns were in the practice text, and next-token training stored them in the weights.

Pre-training finishes an autocomplete.

A pre-trained model is good at continuing text. It does not yet behave like a helpful assistant. Post-training is the later passes. Instruction tuning shows it questions paired with the reply a person wanted. A preference pass shows two replies and keeps the better one, judged by a person or by an automatic check. When the check can be marked, the math matches or the tests pass, that reward is verifiable. The downhill step is the same. The score it chases is different.

Vaswani et al., 2017, the transformer. Ouyang et al., 2022, the assistant pass. DeepSeek-R1, rewards a checker can mark.

It can sound sure and still be wrong.

The loop only asks, “what token usually comes next?” If a false sentence is a likely sentence, the model will say it. Giving it tools, or fresh notes, is a later fix. The bare model does not go and check.

To answer, those numbers have to sit in memory.

The weights are large. While the model runs, they sit in fast memory, usually on a GPU. A smaller open model can fit on one card. A frontier-size model is split across many cards. Quantization stores each weight in fewer bits so the file takes less room. A busy service batches many requests on those same cards, so one chip works on several replies together. Calling an API means the numbers sit on someone else’s cards.

The next tab is the machine that holds these numbers: a graphics card, its memory, and a room full of them.

The machine

How the hardware runs a model

An LLM is a file of numbers, and a reply is a long run of multiplications. The computer that does this well is a graphics card, a GPU. A normal processor, the CPU, is the wrong shape for that job.

One careful worker, or a crowd doing the same sum.

A CPU is built for one job at a time: open a file, branch, decide. A GPU is built for the same small sum, repeated millions of times. Turning a token into the next token is that kind of sum. The weights are grids of numbers. The card multiplies those grids.

A graphics card was made to colour millions of pixels at once. An LLM uses that same habit on grids of weights.

One GPU is one board.

When people count GPUs, they count boards. One board has one calculator chip, and several smaller memory chips beside it. Those memory chips, added together, are the VRAM. A 4090 is one chip plus twelve memory chips of 2 GB each, which is 24 GB. That whole board is one GPU. The chip on that board uses only the memory on that board.

One chip does the sums. The twelve small chips hold the weights. Together they are one GPU. If the model file is bigger than that 24 GB, this board cannot run it alone.

How much memory the file needs.

Each weight is a number. At the usual half-precision, one weight is 2 bytes. A billion weights is about 2 GB. That is the file size before the conversation itself, which also uses a little more memory as the reply grows.

memory in GB ≈ billions of weights × 2

Move the size of the model.

7 billion weights · 14 GB

A single strong gaming card has about 24 GB. This file fits on one card.

These are the weights alone, at 2 bytes each. A real reply also keeps a growing note of the conversation, so leave some memory free.

One new token re-reads the whole file.

Writing the next token does surprisingly little new arithmetic. The card reads the weights, multiplies once, and writes one token. Then it reads the weights again for the token after that. So the speed of a single reply follows how fast the memory can be read, not the headline maths speed of the chip.

seconds per token ≈ size of the file / memory read speed

A data-centre card and a gaming card can have similar maths speed and very different memory speed. The one with faster memory finishes a token sooner.

A data centre is many cards, plus power and cold air.

When the file is larger than one GPU, the model is split across several boards. Four GPUs means four chips and four separate pools of memory. The chip on one board cannot use the memory on the next board. Those boards need a fast cable between them, a rack, a large power supply, and cooling. That room is a data centre.

One card is a trial. A frontier-size model is a row of cards in a building that can feed them electricity and take the heat away.

The next tab is who owns that machine, and who can see the text you type into it.

Two questions

Open source and frontier

These words answer different questions. Frontier asks how good the model is. Open asks whether you can hold the file. A model can be either, both, or neither.

Frontier means near the front.

A frontier model is one of the most capable models you can use right now. It handles the hardest writing and reasoning. The usual way to reach one is an API: you send text, the lab’s computers answer, and you never get the weights. That is a closed frontier model. The word frontier does not mean secret. It only means the model is at the front of what current models can do.

Open weights means the file is published.

An open-weight model is a weight file you can download and run. A GPU you rent or own does the multiplications. The lab usually keeps the training text and the full recipe, so you can run the model without being able to rebuild it from nothing. People often call this open source. The tighter name is open weights.

open source = weights + training code + the data to rebuild it

If any of those three is missing, you have a published model, not a model you could reproduce.

The two lines cross.

A smaller open file can fit on one GPU and still sit well behind the frontier. A huge open file can sit near the frontier and still need a row of GPUs in a data centre. A closed API can be the frontier, and a closed API can also be a smaller, cheaper model. Quality and ownership are separate.

Left is closed, right is a file you can hold. Top is the most capable, bottom is ordinary. A model’s box depends on both facts, not on one label.

What you give up on each side.

Closed frontier

The strongest answers, and no GPU to run. The prompt goes to the lab. They can store it, change the model, or close the account.

Open weights

You can hold the file. On your own GPU the prompt stays with you. A small file fits one board. A file near the frontier needs many boards.

Open source

Rare. You would get the weights and enough code and data to train that model again. Running a copy does not require that.

What makes one model better.

A better model is one whose weights guess a more useful next token on the job you have. Useful means the reply is right, it does what you asked, and it can keep going without falling apart. Open or closed does not decide that. Three things do.

What it practiced on

The practice text is not stored. The habits are, in the weights. A model that practiced on careful code is better at code. A model that practiced on junk gets good at junk.

A second pass

The first training only teaches what usually comes next. Instruction tuning is a later pass on examples of a reply a person wanted. That is why one model answers you, and another just continues the sentence.

How many weights

More weights can hold more patterns. A huge file that was not trained for long enough can lose to a smaller file that was. Extra size also needs more GPUs.

Better is a job, not a single trophy. The frontier model is the one that wins the hardest jobs today. A smaller open file can still be the one you want when the job is ordinary and the prompt has to stay on your machine.

The next tab is what changes when you run that file yourself.

On your machine

What self-hosting is

Self-hosting means you download an open-weight file and a program on a computer you control does the multiplications. The prompt stays on that computer. You get tokens back from it, not from the lab that trained the model.

Where the prompt goes.

The same open file can sit in three places. Only the last one keeps the prompt on hardware you own, with no account for a lab to close.

Their API

You send the prompt to a company. They hold the weights. They can store the text, change the model, or close the account. This is true even when the model they serve is an open file.

A rented GPU

You load the file and run it. The prompt is on their machine. They can see that machine, and they can switch it off.

A GPU you own

The file and the prompt stay on your computer. No other company has to see the text or keep the model running.

Three things have to be on the machine.

The weight file, a runner, and enough VRAM. The runner is the program that loads the weights and writes the next token. Your own software talks to the runner on that same machine, the way it would talk to an API, except the address is yours.

The lab is not in this picture. Once the file is on disk, the runner can answer with the network unplugged.

The file, the conversation, and a little spare.

The hardware tab sizes the weight file alone: about 2 GB for each billion weights at half precision. A real run needs more than the file. While it answers, the runner keeps a note of the prompt and of the tokens already written, so the model can look back. That note is the KV cache. It grows when the conversation gets longer, and it grows again when several conversations run at once. The weights stay the same size. Leave a little VRAM free for the runner itself.

VRAM ≈ weight file + KV cache + a little spare

A file that just fills the card will fail on a long prompt. The weights fit, and the conversation note does not.

Fewer bits, so a larger file can fit.

Quantization stores each weight with fewer bits. At half precision a weight is 2 bytes. At 4 bits it is about half a byte, so the file shrinks to about a quarter. A model that needed several boards can then fit on fewer of them. The answers get a little less exact. You traded some accuracy for room. You did not make a frontier model out of a smaller one.

4-bit memory in GB ≈ billions of weights × 0.5

Add the KV cache and the spare on top of that. A short chat on one card is the case this number is for.

What you keep, and what you still do not have.

No account to close

The lab can stop publishing new files. The copy already on your disk keeps answering. You choose when to download a newer one.

The prompt stays

On a machine you own, the text is multiplied there. A rented machine still belongs to the company that can see it.

A license, and a quality limit

The file comes with rules about who may run it. You still do not get the training text. A file that fits on one card is often behind the frontier.

One desktop card needs a normal plug and a fan. A file near the frontier needs a row of cards, a large power supply, and a room that can take the heat. That room is the data centre from the hardware tab. Self-hosting changes who holds the numbers. It does not change how much electricity a large file uses, or how good a small file is.

A first run is a check, on practice text.

Pick an open file that fits on one board, including the conversation note. Load it with a runner. Send practice text that is not private, and read the answers. You are checking whether this file is good enough for the work. Private text belongs on a machine you control, after that check. A file that fails the check does not become worth a bigger machine.

You can keep training it on your own examples.

Answering leaves the weights as they are. Training moves them. If you hold the file, you can show it a pile of your own text and run the same downhill step again. That later pass is fine-tuning. You start from a model that already knows language. You are teaching it a habit: the tone, the shape of the answer, the job. The new file is yours.

Write many examples of the reply you want. The loss scores each guess. The gradient nudges the numbers. After enough examples, the model tends to answer in that way on its own.

The habit

Fine-tuning is for how it acts. A long pile of your writing teaches it to sound like that pile, and to follow the kind of reply you showed it.

The page

A particular fact belongs in the prompt. Put the page there, or fetch the relevant pages first. The weights hold the habit. The prompt holds the page in front of it.

The memory

Rewriting every weight needs much more VRAM than answering, because the card must also keep the slope for each number. LoRA freezes the original file and trains a small set of extra numbers. That often fits on the same card that can already run the file.

The examples stay on the machine that does the training. On a GPU you own, that machine is yours. On a rental, the host can see the examples too. The license has to allow this further training. A closed API can sometimes train a copy for you, and the lab keeps that file.

The next tab splits those three places for Skillify, with the prices and the rules that were published.

The decision

The choice for Skillify

Prices below are list prices and shop listings read on 9 October 2026. A figure marked [estimate] is arithmetic on those listings, or a number I could not find a live quote for. Nothing here is a negotiated Skillify contract.

Seen in the Skillify files: lib/llm-client.js sends the live call through OpenRouter, pinned to zero-data-retention endpoints on Amazon Bedrock or Google Vertex only. The default model is anthropic.claude-opus-5, with thinking effort set to high. If that call fails on a set list of errors, the same key is retried on Grok 4.6 through xAI only, also marked zero data retention. Direct Anthropic and OpenAI are not live paths. privacy-minimised-anthropic.js runs two passes, baseline then guided, and caps each reply at 16,384 tokens.

Each score is out of 10. Higher is better for Skillify. The bold line is the reason.

Frontier API

Privacy 3/10

The book still leaves your machine.

The prompt leaves your machine. It goes to OpenRouter, then to Bedrock or Vertex, where Claude Opus 5 holds the weights. The packet is kept short on purpose: a mandate, a few instruments, a short view, a few public prices, and, on the second pass, the titles of the checks. The full private write-ups of those checks are not what the code sends. What does leave is enough to reconstruct the book: the stance, the sizes, and the fact that this PM asked.

OpenRouter’s own docs say a request with zero data retention is routed only to endpoints that do not store the prompt, and that OpenRouter itself does not keep prompts unless logging is turned on. data_collection: deny is how the code also refuses providers that may store data or train on it. Bedrock’s docs say a retention mode of “none” means AWS does not write the request to durable storage and does not share it with the model provider. Anthropic’s Bedrock terms say Anthropic may not train on that customer content, and that the usage data Anthropic receives excludes the content.

That is a stack of promises, not a single lock. OpenRouter still sees the prompt in transit. AWS or Google still runs the machine. If a safety system flags the call, Anthropic’s direct API policy keeps flagged inputs and outputs for up to two years, and even a zero-data-retention deal allows that. Bedrock’s newer “covered” models can require a 30-day review inside AWS. AWS says Claude models released before Claude Fable 5 do not have that new requirement. Opus 5 is the model in the code. Confirm on the AWS account that this model is actually allowed at retention mode “none”, because a model that requires retention will be blocked, or kept, depending on the setting.

Seen in the Skillify files: the OpenRouter flags are zdr: true, data_collection: 'deny', allow_fallbacks: false, and only: ['amazon-bedrock', 'google-vertex']. The Grok retry is only: ['xai']. Sources: OpenRouter ZDR, AWS Bedrock retention, Anthropic on Bedrock, Anthropic commercial retention.

Who can stop it 2/10

Anthropic can suspend the key, and an outage stops the reply.

Anthropic’s usage policy says that if they suspect a violation they may warn, throttle, limit, suspend, or terminate access. Finance is a high-risk use when the product makes a personalized recommendation to buy, sell, hold, or allocate among specific investments. The rule is a qualified person, with the authority to change the output, must review it before it is delivered as advice or used to implement a decision, and the person affected must be told AI was used. A book that a portfolio manager reads and then decides on fits that review. A book that is sent straight through to an order does not. They can cut the key off for that, or for a mistake in how they read the traffic. An outage cuts it off with no policy judgment at all.

The same call can also die because OpenRouter, AWS, or Google is down, or because the account is unpaid. On the listed errors the code does not stop. It retries the prompt on Grok 4.6 at xAI. That keeps a reply coming, and it means xAI can see the book on the days Opus fails. xAI can apply their own terms to that retry. None of these companies has to keep serving Skillify.

Seen in the Skillify files: fallback statuses include 401, 403, 408, 429, and 5xx, then Grok 4.6. Sources: Anthropic Usage Policy PDF, Anthropic’s 2026 policy note.

Quality 8/10

This is the strongest model of the three, and it is untested on your packets.

This is the frontier end of the models tab. The weights stay at the lab. You are renting the guesses. On Artificial Analysis’s Intelligence Index, read on 9 October 2026, Claude Opus 5.5 at maximum effort scores 58, the highest on that board. The same model at high effort, which is the effort Skillify sets, scores 54. The best open-weight models on that same index are MiMo-V2.6-Pro at 46, GLM-5.3 at maximum at 45, and Kimi K3 at maximum at 44. Opus 5.5’s list price is $4 per million input tokens and $20 per million output tokens. Opus 5, the model named in the code, is listed at $5 and $25. I did not find an Intelligence Index row for Opus 5 itself on the page I read. Anthropic’s own write-up says Opus 5.5 leads Opus 5 by 11 points on one coding benchmark, Terminal-Bench 4.0.

Those scores are general tests: agents, code, science, professional writing. They are not Skillify packets. A model can win the index and still miss a mandate, a size, or a flat sleeve. The useful fact is the gap: the open files nearest the front are still several points behind the frontier model Skillify is paying for, and the small file that fits on one GPU is further behind again. DeepSeek V4.1 Flash at maximum scores 39 on the same index.

Fine-tuning does not run on this path. The weights are not yours. You cannot nudge them. Instruction tuning already happened at the lab. What you can change is the packet: the checks you invite, the examples in the prompt, the schema. That changes the habit for one call. It does not change the file.

Sources: Artificial Analysis leaderboard, Opus 5.5 write-up, Anthropic pricing.

Speed 4/10

Two thinking passes, and a public high-effort reply took about 45 seconds.

The wait is two passes, one after the other, with thinking turned on. Artificial Analysis measured Opus 5.5 at high effort at 75 tokens a second, about 38 seconds to the first chunk, and about 45 seconds for the whole reply, on their task. At maximum effort the same model took about 725 seconds before the first chunk. Skillify sets effort to high, on Opus 5, twice. I did not find a measured latency for a Skillify packet. A shorter packet should start sooner than a giant benchmark. Two passes means the PM waits for the first reply, then waits again. The hardware fact still holds: each new token re-reads the weights, and a long think is a long row of tokens.

Seen in the Skillify files: two passes, effort high, 16,384 token cap each. Source: Artificial Analysis speed columns. [No Skillify stopwatch in the files I used.]

Cost 8/10

A full pair of replies caps near $0.82, and idle time is free.

Claude API list price for Opus 5 is $5 per million input tokens and $25 per million output tokens. Opus 5.5 is $4 and $20. Cache reads on Opus 5.5 are $0.20 per million. I could not find a separate Bedrock line item for anthropic.claude-opus-5. Use the Claude API list as the stand-in, and ask AWS for the Bedrock price before you budget.

two full replies = 2 × 16,384 / 1,000,000 × $25 = $0.82

That $0.82 is the output ceiling if both passes write every token the code allows, at the Opus 5 output price. A shorter think costs less, in proportion. Input is extra, at $5 per million, and the packet is the short one described above. I did not count its tokens, so I am not putting an input dollar figure here. A failed Opus call that falls through to Grok is a second bill. [Couldn't get a live Grok 4.6 price. Look up x-ai/grok-4.6 on OpenRouter.]

There is no GPU invoice on this path. The cost grows with the number of decisions and with how long the model thinks, not with a card sitting idle.

Sources: Anthropic pricing. The $0.82 line is arithmetic on that list price and the cap in the Skillify files, not a measured invoice.

Setup, and who else is in the room 9/10

This path is already how the live call works.

This path is already how the live call is built. The companies in the room are OpenRouter, Amazon Web Services or Google for the machine, Anthropic for the weights and the usage policy, and xAI on the days the fallback fires. A portfolio manager, or someone else qualified, has to be in the room too if the output is going to be treated as a decision, because that is the condition in Anthropic’s finance rule.

Setup cost is an account, a key, and the code that already exists. The ongoing work is watching suspensions, outages, and the bill. The thing that does not fit the other headings: Anthropic forbids using Claude’s outputs to train another model unless they have agreed. Copying a year of Skillify replies into an open file, to make a faster local model, needs their permission first. Your own written decisions are a different pile. Those are yours.

Source: the distillation ban is in the Usage Policy PDF, under the universal standards.

Rented

Privacy 3/10

The host can read the disk the book sits on.

You download an open-weight file and a runner on someone else’s GPU does the multiplications. The prompt does not go to Anthropic. It does sit on a disk the rental company can read. A marketplace host, the kind Vast.ai brokers, is some other person’s machine. RunPod’s Secure Cloud is RunPod’s own machines, which is a named company rather than a stranger, and they can still see the box. Zero data retention, in the API sense, is not what this is. The host has the machine for the whole rental.

For Skillify that machine would hold the book, the stance, and any examples you loaded for fine-tuning. The check titles and the customer packet are the easy part to copy. The host does not automatically receive the private write-ups of the checks unless you put those files on the box.

Seen in the Skillify files: the guided pass sends check titles, not the private heuristic bodies. Sources: RunPod pricing, Vast.ai live rental guide.

Who can stop it 4/10

The host can switch the machine off, and you can rent another.

The rental company can switch the machine off. Non-payment, their own rules, a full data centre, or a marketplace host taking the card back. Anthropic’s usage policy does not govern an open file you run yourself. Their finance rule is not the thing that cuts you off here. The rental company’s terms are. A PM waiting on a decision is then waiting on that company’s uptime, not on an API key.

You can start another rental. You cannot make the first company keep the machine on. The weight file, if you also keep a copy somewhere you control, survives the shutdown. The running job does not.

Quality 5/10

The best open files still trail Opus, and one 24 GB card trails further.

Quality follows the file you load, not the fact that you rented. On the same Artificial Analysis index, the open-weight front is MiMo-V2.6-Pro at 46, GLM-5.3 max at 45, Kimi K3 max at 44, against Opus 5.5 high at 54 and Opus 5.5 max at 58. Those open files are the huge ones from the models tab. They need a row of data-centre GPUs. A single 24 GB card, at 4-bit, holds on the order of a few tens of billions of weights once you leave room for the KV cache. That is a smaller model. DeepSeek V4.1 Flash max, at 39 on the index, is the shape of “faster, further from the front.”

I could not find, on the leaderboard page, the VRAM each of those open files needs. Use the hardware formula once the lab publishes the weight count: 4-bit gigabytes are about billions of weights times 0.5, plus the KV cache, plus spare. A short Skillify packet does not need a million-token context. A long one, with a fat book and many sleeves, grows the KV cache and can push a tight card over the edge.

Fine-tuning is available, because you hold the file. A later pass on your own decided books teaches the habit: the JSON, the sleeves, the way a flat book should look. LoRA freezes the original weights and trains a small set of extra numbers, which often fits on the same card that can already run the file. It does not move a 39 to a 58. It makes a smaller model more like your desk. Do that on practice packets first. The private books go on only after the answers are good enough, and on a rented box the host can see those examples.

Sources: Artificial Analysis, Hu et al., LoRA. The VRAM sentence uses the formula already on the hardware tab.

Speed 6/10

A smaller file, in one pass, should beat two frontier thinks.

One pass instead of two is a real cut, if you drop the unguided baseline. The baseline is how Skillify compares a blank book with the guided one. Keeping both means two waits, on your card. Hosted open models on Artificial Analysis, which is their cloud not your rental, did: GLM-5.3 max about 82 tokens a second and 33 seconds for the whole reply; Kimi K3 max about 41 tokens a second and 64 seconds; DeepSeek V4.1 Flash max about 217 tokens a second and 13 seconds. A card you rent will differ with memory bandwidth. I do not have a stopwatch for a Skillify packet on a 4090.

Source: Artificial Analysis. [No rental-GPU measurement for a Skillify packet.]

Cost 4/10

A 4090 left on is about $533 a month, before a larger file.

RunPod’s pricing page, read 9 October 2026, listed an RTX 4090 at $0.74 an hour for 24 GB of VRAM, 41 GB of ordinary memory, and 6 vCPUs. An H100 PCIe was $2.89 an hour. An H200 was $4.59 an hour. An H100 SXM was $3.29 an hour. Vast.ai’s own guide publishes a live floor that moves about hourly. On the copy I read, the floor and the median were: RTX 4090 from $0.14, median $0.49; H100 SXM from $1.73, median $2.24; H200 from $2.76, median $5.00. Treat the Vast numbers as a screen you recheck, not a contract.

always on ≈ hourly price × 720 hours

On the RunPod listings that is $532.80 a month for one 4090, $2,080.80 for one H100 PCIe, and $3,304.80 for one H200. [estimate: arithmetic on those hourly listings, for a card that is never switched off.] A card you start for a few hours of practice text is the hourly price times those hours. Storage on RunPod was listed from $0.05 a GB a month. A multi-GPU box for a GLM-class or Kimi-class file was not given a single hourly total I can stand behind. Ask RunPod, Vast, and Lambda for an 8-GPU quote.

[Couldn't get Lambda’s own price table in this pass.] A secondary comparison dated around August 2026 put Lambda H100 on-demand near $3.29 to $3.99 per GPU-hour. That is a lead, not a quote. Ask Lambda.

Sources: RunPod, Vast.ai, secondary Lambda comparison.

Setup, and who else is in the room 4/10

Skillify has to be rewired, and the license is still unread.

You need a runner, a weight file whose license allows this commercial use, and a change so Skillify talks to your machine instead of OpenRouter. I did not clear the licenses for MiMo, GLM, Kimi, or DeepSeek. Read the file’s license before a PM relies on it. The companies are the GPU host, the lab that published the weights, and whoever operates the runner. There is no Anthropic key in the loop, so their usage policy is not what stops the box. Their ban on distillation still applies if the training examples are Claude’s replies.

A first check is a few hours on one 24 GB card and old packets that are not live books. Wiring it into the product, watching the host, and deciding whether the baseline pass stays on Opus, is the slow part. Days, not a morning, if the JSON has to match what the desk already trusts. Low concurrency is in your favour: one card can serve one decision at a time. Growth is a queue or a second card, still on someone else’s premises.

Owned

Privacy 9/10

The prompt stays on your machine if you do not send it out.

The weight file and the prompt stay on a computer you own. No API company has to see the book. No rental host has the disk. That is the option that matches the privacy you described: the value is the judgment, the judgment is easy to copy, and the copy happens when the prompt leaves. Fine-tuning examples stay on that same machine. The lab that published the weights already had the original file. They do not receive your books unless you send them.

What still leaves, if you let it, is anything the runner itself phones home, or a backup you put in someone else’s cloud. A machine you own does not stay private by magic. It stays private if the network path for the prompt is the machine itself.

Who can stop it 9/10

No model company can suspend this, because there is no key.

Anthropic cannot revoke a file that is already on your disk, and they cannot see the call. An open-model lab can stop publishing new files. The copy you have keeps answering. The license can still forbid a use. A landlord, a power cut, or a dead card stops the machine. Nobody’s usage-policy team stops it because they think you are giving financial advice. That cutoff, the one that matters if PMs are waiting, is gone.

You are then the person who keeps it up. A failed fan or a full disk is your outage. There is no Grok fallback unless you build one.

Quality 5/10

You own the card, not a better file. Training teaches the habit.

Same open-file ladder as the rented tab. The Intelligence Index gap is a property of the weights, not of who owns the board. Opus 5.5 high at 54, best open weights around 44 to 46, a smaller fast open model at 39. Owning the card lets you run that file with the prompt at home. It does not raise the index.

What ownership adds is training without a host reading the examples. Your own past decisions, written as the reply you wanted, are a fine-tuning set. LoRA is the practical pass on one card. Full retraining of every weight needs much more VRAM than answering, because the card must also keep the gradient. A 24 GB board is the trial size. A file near the open-weight front is a row of boards in a room that can feed them and take the heat, which is the data centre from the hardware tab.

Training on Claude’s old replies, to steal the frontier habit, is the distillation ban. Do not do that without Anthropic’s permission. Train on decisions your desk actually made.

Sources: Artificial Analysis, LoRA, Usage Policy, distillation.

Speed 6/10

A smaller file is faster, and a fine-tune does not speed that file up.

The card’s memory bandwidth sets the tokens per second, as on the hardware tab. A smaller file is faster because each token re-reads less. A fine-tune does not make the same file faster. It changes the weights, not the number of multiplications in a way you can budget. Dropping the second pass, and dropping a long think, is what shortens the wait. I have no measurement of a Skillify packet on hardware you would own. The hosted open-model times in the rented tab are the closest published figures, and they are not your box.

Cost 6/10

A listed 4090 is about £1,850 for the card, and an H100 has no shelf price.

Shop listings for a 24 GB RTX 4090, read 9 October 2026. Clove Technology listed an ASUS TUF at £1,851.46 for UK consumers, and £1,542.88 ex VAT on the rest-of-world line, and said fewer than 10 were left. Overclockers listed a Zotac Trinity at £1,829.99 including VAT, on pre-order. Those are the card only. A PC around it, a second-hand card, and VAT treatment for a company are separate. Confirm both pages before paying. Clove. Overclockers.

[Couldn't get a live shelf price for an H100 or an H200.] Ask NVIDIA, Lambda, and a server builder for a one-board and an eight-board quote. Do not use an old headline as the price. The rental rates above are the cost of waiting while that quote comes back: about $533 a month for a RunPod 4090 left on, before you own anything.

Power is extra. A shop listing for a 4090 states a 450 W draw. [estimate] kilowatt-hours are 0.45 times hours running, times your tariff. I did not pull a UK tariff. Ask the supplier, or check the current Ofgem cap, and multiply. A row of data-centre cards is a different quote: power, cooling, and the room.

The 450 W figure is the TDP on a retailer listing, not a measured wall reading. One listing that states 450 W. Confirm on NVIDIA’s own 4090 spec sheet before you size a circuit.

Setup, and who else is in the room 3/10

Buying, power, and a week of practice packets come before a live book.

The companies shrink to the shop that sells the card, the lab behind the weight file, and you. No OpenRouter, no AWS account in the decision path, no Anthropic key. You install a runner, load the file, and point Skillify at that machine. The license is the remaining outside rule. I have not cleared one for commercial portfolio work.

This is the slow setup. Buying, power, cooling, and a week of practice packets before a live book. It is also the setup where a suspended API key cannot take the desk down. Keep one frontier pass only if you still want the blank-book comparison, and accept that those packets leave. If the owned file fails the old packets, a bigger card does not fix the judgment. It only fits a larger file.

Not started

Experiments

The question is which setup Skillify should trust: the frontier API it uses now, an open file on a rented GPU, or that same open file on a GPU you own. No run has been started. The fake Skillify packets are not written yet. The public tests below can be downloaded before those packets exist.

How a run is done.

Freeze the prompt list before any model sees it. Send that same list to each setup. Record the reply, the seconds from send to finished text, and the dollars. Score without knowing which setup wrote the answer. Then write the numbers here. Do not edit the prompts after the first score.

Frontier needs no new machine. The live Skillify path already calls Claude Opus 5. Rented means a card you hire for the hours of the run. Owned means a card you buy later and load with the file the rental already produced. Do not buy a card for round one. A rental can train the weights. It cannot copy the privacy of a machine you own.

Seen in the Skillify files: the live call is OpenRouter to a zero-retention Bedrock or Vertex endpoint, model anthropic.claude-opus-5, thinking effort high, two passes, 16,384 token cap each.

The variables.

Independent variable

The setup: frontier API, rented open file, or owned open file. A second change, only on the open file, is base weights versus a LoRA trained on your examples.

Dependent variables

Rubric score out of 10, pass@1 on a test that checks itself, seconds to finish, and dollars for that run.

Constants

The same prompts, in the same order. The scorer is blind. Nothing is trained on the test prompts. Temperature and effort are written down and kept. The fake packets, once written, stay frozen.

The frontier cell changes two things at once: the weights and the host. Rent versus owned can use the same file, so that pair isolates the machine. A score gap between frontier and rented is a gap between files, not a gap between landlords.

Scoring rubric.

Each item is 0, 1, or 2. The ten points are the sum. A public test that already has a checker keeps that checker’s pass or fail, and we still time it and cost it. This rubric is for the Skillify book, and for any answer a person has to judge.

Schema

2: the reply is the JSON the desk can read. 1: the fields are there and broken. 0: prose, or a refusal to answer in the shape we asked.

Mandate

2: it stays inside the instruments and the rules in the packet. 1: one sleeve wanders. 0: it invents a market the packet did not allow.

Decision

2: a direction and a size, or an explicit flat. 1: a direction with no size. 0: no action a person could check.

Grounding

2: the reasons use numbers that were in the packet. 1: mixed with figures it made up. 0: the prices are invented.

Use

2: a portfolio manager could act, or could correctly do nothing. 1: they would have to rewrite it. 0: they would ignore it.

Two people can score the same blind pile. If they differ by more than 2 points, a third read breaks the tie. This is the small version of a blind ranking. Chatbot Arena does that with a crowd. We do it with the desk. Chatbot Arena.

The tests.

Public rankings do not use one exam. Artificial Analysis builds an index from ten evaluations, weighted agents 30, coding 20, general 30, science 20. About 45 percent of that weight is a private test we cannot rerun. We run the public ones. We do not invent an index number of our own. Where they have already published a score for Opus 5.5, that number stays a citation, not our result.

Skillify book

Our packet, scored on the rubric. Blocked until the fake data is written. This is the test the desk actually cares about.

Terminal-Bench 4.0

66 tasks in a terminal. A task passes only if its own tests pass. Pass@1, three repeats in their method. Public.

SciCode

288 science coding subproblems. The code has to pass the unit tests. Pass@1.

Humanity’s Last Exam

2,158 hard questions. An equality checker marks the open answer. Pass@1.

GDP.pdf

100 tasks over long professional PDFs, 4,592 pages, 1,275 criteria. Credit when the criteria pass.

AA-LCR

100 questions over documents around 100,000 tokens long. A checker marks the answer.

GDPval

220 occupational tasks from a public set. Their score is a pairwise Elo, not a simple percent.

Held out

AA-Briefcase, AutomationBench, the private part of AA-Omniscience, and CritPt’s hidden problems. We do not run these. A public slice is not their index score.

Sources: Artificial Analysis methodology, index v4.3 weights, Terminal-Bench, task repo, GDPval, AA-LCR, GDP.pdf.

Frontier API

What you do.

Buy nothing. Send each frozen prompt through the live Skillify path and save the reply, the seconds, and the token bill. Two passes means two waits and two bills. Use the Opus 5 list price already on the choice tab to turn tokens into dollars, and mark it [estimate] until the real invoice is attached.

You cannot fine-tune this file. The weights stay at the lab. Do not paste these replies into a training set for an open model. That is distillation, and their usage policy asks for permission first.

Seen in the Skillify files: lib/llm-client.js and privacy-minimised-anthropic.js.

Rented

What you do.

Open RunPod and rent one RTX 4090. The page listed $0.74 an hour for 24 GB on 9 October 2026. Recheck it before you start the clock. Install a runner. Download a 4-bit open file that leaves room for the KV cache inside those 24 GB. Write the exact file URL in the lab book before the first prompt.

Do not download DeepSeek-V4.1-Flash onto that card. The smallest GGUF we found for it is about 246 GB. The official checkpoint is hundreds of gigabytes. That file is a later, multi-GPU rental, after the one-card file has a score. Ask RunPod for the bigger box. Do not invent the hourly total.

To test training, stay on the same rental. Freeze a pile of your own example replies that are not the test prompts. Run a LoRA. Download the add-on. Score the base file and the LoRA file on the same tests. The host can see the examples. That is the privacy this condition does not have.

Sources: RunPod, DeepSeek-V4.1-Flash, 246 GB Q2_K note.

Owned

What you do.

Do not buy a GPU for round one. The weights you would own are the file and the LoRA the rental already wrote. Copy them to a disk you control. The owned run is those same weights, the same prompts, and the same rubric, on a card in a machine you own.

If that file is worth keeping off a host, the 24 GB cards listed on 9 October 2026 were an ASUS TUF at £1,851.46 on Clove and a Zotac at £1,829.99 on Overclockers. Confirm stock and VAT. An H100 still has no shelf price. Until a card is in the room, this column stays blank. A rented run is not an owned result.

Results.

Empty. No prompt has been sent.

Product plan

Cheaper crons

A product that sits in front of OpenRouter and makes expensive, repeated jobs cheaper — without a quiet drop in quality. This tab is the build, market, and sell write-up. Nothing here is live software yet.

What it is

People run lots of crons on strong models. Many of those jobs are routine. A cheaper model, or plain code, would do. The product watches real cron traffic, tests cheaper options in the background, and only switches when the answer stays good enough.

OpenRouter already gives one API key for models from many labs. You change the model name, not the key. Anthropic to OpenAI is fine. That is the switch we use.

Build

Ship a thin proxy. The user’s cron points at us. We call OpenRouter with their key (or a key they mint for us). We log the prompt shape, the model, tokens, cost, and a quality score against a gold answer or a judge model.

Classify each cron. Needs a strong model, can try a mid model, or should leave the LLM path (scrape, rules, code).
Shadow test. For a few days, run the live model and one or two cheaper candidates on the same inputs. Do not change production yet.
Gate the switch. Promote a cheaper model only when the score stays inside a set band for enough samples. Fail closed: stay on the expensive model if unsure.
Optional rewrite. For dead-simple jobs, propose a non-LLM path and show the diff before anyone flips it.
Dashboard. Per cron: current model, candidate, savings so far, quality trend, and a one-click revert.

Hard parts: a quality metric that matches the job, not a generic chat score; safe handling of secrets in prompts; and enough samples before a switch so one lucky cheap reply does not fool the system.

Market

Buyers are teams with many scheduled LLM jobs and a rising OpenRouter bill — agent platforms, ops dashboards, scrapers that call models, internal cron fleets. The pitch is simple: same jobs, lower model cost, quality watched.

Lead with a number they already feel: “your cron fleet spent £X last month; we aim to cut the model line without rewriting your jobs.” Show one before/after on a real cron. List on Awesome OpenRouter for discovery. Sell next to this site and Control Tower, where cron cost and quality already show up.

Do not sell “an OpenRouter plugin.” OpenRouter’s plugins are their own request features (search, PDF, routers). Third parties do not list a paid plugin there. “Become a provider” is for selling inference, not apps.

Sell

Billing stays outside OpenRouter. You sell the product yourself.

Default: a low monthly fee — about £2 a month to start — so people try it without arguing about a revenue share. Raise later for teams with bigger fleets.

Harder path: take about 20% of proven savings. Needs trusted cost logs, a clear baseline model, and a dispute path when usage changes. Fine later; messy as v1.

One-off license: possible for self-host, but support and model tables go stale. Prefer monthly.

Integration story for the buyer: keep the OpenRouter key, point the cron base URL at the proxy, leave prompts alone. First week is measure and shadow test. After that, cheaper models turn on where the gate passes.

Open questions

Product name. Whether Skillify / Control Tower is the first dogfood customer. How strict the quality gate is on finance-shaped packets. Whether non-LLM rewrites ship in v1 or wait.

Sources for the OpenRouter facts: OpenRouter plugins, become a provider, Awesome OpenRouter. Written 18 October 2026.