What Token Factory Actually Is, and the Honest State of Its Catalog
Prerequisite: none. This is the course's opening lesson. After this lesson, you can: explain what Nebius Token Factory actually trades against a self-hostable product like NVIDIA NIM, and check whether a model name you've been handed (by this course or anyone else) is still current before you build on it.
Nebius are friends of this site. Nobody paid for this course. Rod teaches a module for Nebius Academy (AI Performance Engineering), and three lessons already live on this site were built straight out of that relationship, running real demos against Token Factory months before this course existed. That relationship is disclosed here, dated, in the site's own frontmatter. Not because it has to be, but because an unstated one would read as concealment once discovered. This course holds itself to the same bar as every other course here: same honesty about limits, same lint floor, same obligation to say where the product breaks.
Not NIM with a different logo
Two products on this site's shelf both let you call an open model without training it yourself, and the difference between them matters. NVIDIA NIM ships a container you run on your own GPU: you provision the hardware, NIM handles the inference backend. Nebius Token Factory is the opposite trade. Nebius runs the GPU, you call an API, and in exchange for giving up hardware control you get zero-ops managed serving plus something NIM doesn't offer at all: a managed fine-tuning pipeline (Post-Training). This course doesn't have a fine-tuning lesson of its own: no first-party Rod receipt for actually running that pipeline exists yet, and a lesson without one doesn't get written here, per this program's own refusal rule (RULING-213).
Neither is the "better" one in general. The question that actually decides it: do you need the model's weights on your own hardware (compliance, air-gapped deployment, a self-hosting mandate), or do you just need tokens back from an API and would rather not run GPUs at all? NIM answers the first. Token Factory answers the second, and adds fine-tuning access frontier APIs cannot offer at all, because Claude and GPT don't hand you their weights to adjust.
The catalog moves fast enough that this course caught itself
Before you trust a single model name in this course, know this: three lessons already live on this
site (tools-memory-and-multi-agent-systems, lessons 01, 03, and 08) run real, working code against
Token Factory. A lost-in-the-middle demo on google/gemma-2-2b-it. A Planner-Executor lab on
Qwen/Qwen3-235B-A22B-Thinking-2507. A multi-tool agent on Qwen/Qwen3-235B-A22B-Instruct-2507. A
CLI-wrapper lab on meta-llama/Llama-3.3-70B-Instruct. Useful teaching, real demos, all of it.
None of those five model names appear on Nebius's own live service page or its own cookbook
repository, both fetched fresh while writing this lesson. What's there instead: DeepSeek-V4-Pro,
Kimi-K3, GLM-5.1 on one Nebius page and GLM-5.2 on another, fetched minutes apart in the same
session. This isn't this course being sloppy about checking. It's the catalog moving between two
pages the vendor itself controls, inside one sitting. If you came here with a model string copied
from a tutorial (this one included), there's a real chance it's already one generation behind by
the time you paste it.
Checking a model yourself, in under a minute
The habit that would have caught this course's own drift before publishing:
Call the models endpoint directly rather than trusting any course's snapshot, including this one.
from openai import OpenAI
client = OpenAI(
base_url="https://api.tokenfactory.nebius.com/v1/",
api_key="YOUR_API_KEY",
)
live_models = {m.id for m in client.models.list().data}
print("MODEL_ID" in live_models)If a model string this course used isn't in live_models, that is the catalog telling you the
truth. The fix is picking a current replacement from the same call's output, not assuming the old
string still half-works.
A model check done once at authoring time (what this lesson's own receipts field records) is a snapshot. A model check wired into a deploy script is a habit that survives the next catalog generation, whatever it turns out to be named.
python check_model_status.py MODEL_ID
What doesn't move, even while the roster does
Every model behind Token Factory (chat, embeddings, fine-tuning jobs) sits behind the same
OpenAI-compatible base URL, https://api.tokenfactory.nebius.com/v1/. That's the exact base URL
this site's own three existing lessons already use in working code, and it's the one thing about
this product that has NOT changed while the model roster around it has. Learn that shape once, and
a catalog swap costs you a string change, not a rewrite. NIM's own course teaches the same property
about NIM's client, because it's true of hosted-inference APIs generally, not specific to either
vendor.
What "friend," not "sponsored," actually means for this course
One honest number, attributed rather than repeated as fact: Nebius's own launch materials cite a named customer, Prosus, reporting "up to 26x cost reductions compared to proprietary models" at 200 billion tokens per day. That's Nebius's claim about one customer's result, not this course's own finding. Lesson 02 works through when a claim like that is plausible for a much smaller, ordinary workload, rather than repeating the headline number as if it applied generically. A friend relationship doesn't buy a softer read on numbers like this one. It buys nothing at all, except a disclosed reason to be extra careful about them.
The cost/latency decision framework: when an open model on Token Factory actually beats a frontier API, worked through on an ordinary workload rather than a headline case study.
Reply here and it goes straight to Rod. Same as replying to one of his emails.
