The catalog, JSON out
A tour of the abliteration.org API through the tasks people actually run. Fifteen reads of the catalog, each in the language that best fits the job, including the new change-stream feeds that surface what shifted on the Hub since your last check.
Much of what abliteration.org displays on its pages is also served as JSON at /api/v1. Ten native clients cover Python, Ruby, Rust, TypeScript, .NET, PHP, Elixir, Dart, Java and a Node CLI, plus plain curl. This page walks through the API by way of concrete tasks, one task per section, each solved in the language most people would pick for it, so a researcher, a journalist or an engineer can find the read that matches what they came here to do. The last five cases cover the change stream: what HF pulled, how a model's README drifted over time, which downloads spiked or fell, and how to fold any of it into a compliance report, a CI check or a dashboard sparkline.
- What each of the eighteen endpoints returns, shown by real request-response pairs
- How to phrase the fifteen most common questions researchers, journalists and engineers ask the catalog
- Which language fits which task, and why. Honest reasoning, not language wars
- How the shared envelope (cost, credits_remaining, rate limits) behaves across every response
- What the four flagship indices (DAI, Freedom Velocity, Weaponization, F2W Latency) mean when read as JSON
- How to reach data no other catalog surfaces: dead models, description drifts, download anomalies, our own datasets
- How to watch the Hub from a cron job, a GitHub Action or a Cloudflare Worker without polling the whole catalog
How to read this guide
The API mirrors much of the site. The catalog lists, the model, author, method and dataset profiles, the four indices, the timeline and the change-stream feeds also arrive as JSON if you ask for it that way. This guide walks through that surface as a sequence of tasks rather than as a reference: what a working researcher, a journalist writing a piece, or an engineer building a tool might actually want to know, and the shortest way to get it.
Each section shows one task. The terminal on the left runs a real request and prints a representative response (numbers drift as the catalog updates, and a few change-stream examples use placeholder ids) - copy the request into your shell and it works. The prose on the right is for the reader who is not going to run anything: it explains what the response contains and what you can do with it, in plain English. Language choice on the left is a matter of fit, not favouritism - every task in this guide is also reachable through plain curl, and every one of the ten native clients speaks the same envelope with the same key.
You will need a Bearer key. Get one at /shop/account, export it as ABLITERATION_API_KEY, and every example below runs unmodified.
1. Monday briefing on the field
Every Monday, a research team, a policy desk or a security analyst wants three things in one sitting. What appeared last week. Which method is behind it. Which authors are shipping. Python fits the whole workflow because it is where reports live once they are written: one Client, one weekend of data, three cells that print what someone will paste into a doc on Monday morning.
$ pip install abliteration
$ export ABLITERATION_API_KEY=abl_live_...
$ python
>>> from abliteration import Client
>>> with Client() as c:
... fresh = c.models(
... created_after="2026-09-10",
... sort="created", limit=3,
... )
... for m in fresh:
... print(f"{m.method} {m.id[:52]:<52} {m.downloads:>8,}")
...
M8 DavidAU/Qwen3.8-27B-TWIN-TURBO-Fable-Cold-Fusion-709 114,335
M8 taurusduan/qwen3.8-27b-abliterated-3.69bpw-12GB-MTP 19,991
M4 mlabonne/Qwen3-30B-A3B-abliterated 218,909 Reports start with what's freshest because that is what people notice first. created_after takes any ISO date and filters on the row's own created_at, not on when we first indexed the model, so a checkpoint uploaded on Sunday but crawled on Monday still counts as Sunday's release. In this example, two of the three rows are M8 repackages and one is an M4 release.
>>> m8 = c.method("M8")
>>> print(f"{m8.label}: {m8.model_count} models, "
... f"{m8.total_downloads:,} downloads")
Repackaged (GGUF): 5298 models, 15,511,375 downloads
>>> for a in m8.top_authors[:3]:
... print(f" {a['author']}: {a['count']} models")
mradermacher: 2738 models
RichardErkhov: 131 models
tensorblock: 96 models If the fresh list surprises you, the next question is always the same. Which method is driving the surge? A method detail call returns not just the count of models but the top authors publishing under that method (in the Python client top_authors arrives as a list of plain dicts, hence the key lookups). M8 is our label for repackaging into GGUF format. Not a new architecture, not a new ablation, just conversion for local inference. The top three names here are exactly who you would expect if you follow the field: converters, not surgeons.
>>> top = c.authors(sort="downloads", limit=5)
>>> for a in top:
... print(f"{a.author:<18} {a.total_models:>5} models "
... f"{a.total_downloads:>12,} dl")
HauhauCS 26 models 9,369,705 dl
mradermacher 3,221 models 5,945,791 dl
DavidAU 207 models 5,017,040 dl
huihui-ai 166 models 4,935,314 dl
JonathanColetti 2 models 2,706,177 dl The third piece of the briefing is who is currently on top by downloads. The downloads figure on every model is Hugging Face's rolling 30-day count, so an author's total is the sum of their models' last-30-day downloads, not an all-time figure. The ordering matters when you compare against the fresh models above. If a name in the fresh list already sits high in the total ranking, that's a returning author extending a lead. If it's a new handle, that's someone worth watching. HauhauCS at the top with only 26 models means a very small catalog with very heavy downloads. A different pattern than mradermacher's three thousand.
2. Vet a candidate author
Before you take a dependency on someone's checkpoint, you want to know who they are as a shipper. How much they release, how much of it people actually pull, which methods they favour, whether one hit carries the whole account. Ruby fits because a small analyst script that turns a handle into a paragraph of profile is exactly the shape Ruby was made for: read some rows, do a little arithmetic, print a summary.
$ gem install abliteration
$ export ABLITERATION_API_KEY=abl_live_...
$ ruby -r abliteration -e '
Abliteration.configure { |c| c.access_token = ENV["ABLITERATION_API_KEY"] }
a = Abliteration::AuthorsApi.new.get_author("mlabonne").data
puts "#{a.author}: #{a.total_models} models, " \
"#{a.total_downloads} dl, #{a.total_likes} likes"
puts "First seen in catalog: #{a.first_seen_at}"
'
mlabonne: 40 models, 316838 dl, 1958 likes
First seen in catalog: 2026-08-22 13:56:58 UTC Before you build on someone else's checkpoint, you want a one-line answer to who they are as a shipper. The author detail endpoint returns the four numbers that matter: how many models they have, how many downloads that adds up to (summed from each model's 30-day count), how many likes, and when we first saw them. The gem is generated from the OpenAPI spec, so the key goes in once through Abliteration.configure and every call goes through a per-resource API class. First-seen timestamp also tells you if the account is old and steady or fresh and unproven.
$ ruby -r abliteration -e '
Abliteration.configure { |c| c.access_token = ENV["ABLITERATION_API_KEY"] }
rows = Abliteration::ModelsApi.new
.list_models(author: "mlabonne", limit: 1000).data
by_method = rows.group_by(&:method)
.transform_values(&:count)
.sort_by { |_, n| -n }
puts "Method mix:"
by_method.each { |m, n| puts " #{m}: #{n} models" }
'
Method mix:
M4: 22 models
M3: 11 models
M1: 5 models
M5: 2 models The author payload embeds only a sample of up to 25 models, so for the full mix ask the models list for everything under that author (one call, filtered by author), then group by method, count, sort. Twenty two M4 models against eleven M3 and a handful of others tells you this author has a preferred technique and applies it consistently. A random spread across every method would be a different signal: someone experimenting, not committing.
$ ruby -r abliteration -e '
Abliteration.configure { |c| c.access_token = ENV["ABLITERATION_API_KEY"] }
a = Abliteration::AuthorsApi.new.get_author("mlabonne").data
top = Abliteration::ModelsApi.new
.list_models(author: "mlabonne", sort: "downloads", limit: 1)
.data.first
share = 100.0 * top.downloads / a.total_downloads
puts "Top model: #{top.id}"
puts " #{top.downloads} downloads = " \
"#{share.round(1)}% of the account"
'
Top model: mlabonne/Qwen3-30B-A3B-abliterated
218909 downloads = 69.1% of the account One more question every reviewer asks: is this a one-hit author or a steady producer? Divide the top model's downloads by the total, and you get a concentration ratio. Sixty nine percent from a single model means almost the whole reputation rests on one checkpoint. That is not automatically bad, but it changes what a dependency on this author looks like. If that one model breaks or gets pulled, the account effectively disappears.
3. Read a model's passport in full
The list endpoint gives you a summary. The detail endpoint gives you a passport: classification with evidence, file manifest, base-model chain, the classifier version that made the call. curl and jq fit because this is the endpoint every SDK below wraps, and reading it once as raw JSON makes every wrapper legible without another detour.
$ export ABLITERATION_API_KEY=abl_live_...
$ curl -s -H "Authorization: Bearer $ABLITERATION_API_KEY" \
"https://abliteration.org/api/v1/models/mlabonne%2FQwen3-30B-A3B-abliterated" \
| jq '.data | {id, family, params_b, is_moe, yaml_license,
downloads, hub_downloads_all_time}'
{
"id": "mlabonne/Qwen3-30B-A3B-abliterated",
"family": "qwen",
"params_b": 30,
"is_moe": 1,
"yaml_license": "apache-2.0",
"downloads": 218909,
"hub_downloads_all_time": 1739443
} The list endpoint gives a card. The detail endpoint gives a full passport. jq lets you slice it into whichever shape you need without pulling a client library. This first slice is the identity: id, family, parameter count, mixture-of-experts flag, license (the detail record carries it as yaml_license, straight from the model card; only the list rows rename it to license), and two download figures. downloads is Hugging Face's rolling 30-day count; hub_downloads_all_time is the lifetime total. The ratio between them tells you whether a model is still being pulled or living on its past.
$ curl -s -H "Authorization: Bearer $ABLITERATION_API_KEY" \
"https://abliteration.org/api/v1/models/mlabonne%2FQwen3-30B-A3B-abliterated" \
| jq '.data | {primary_method, secondary_methods, confidence,
classification_evidence, classifier_version,
classified_at, yaml_base_model}'
{
"primary_method": "M4",
"secondary_methods": "[\"M1\"]",
"confidence": "medium",
"classification_evidence": "[\"author=mlabonne (NeuralDaredevil M4 heal pipeline signature)\", \"abliterated marker present\"]",
"classifier_version": "v1.0.0",
"classified_at": "2026-08-30T11:07:15+00:00",
"yaml_base_model": "Qwen/Qwen3-30B-A3B"
} The classification block is why our detail endpoint exists at all. Anyone can look up a model on Hugging Face. What Hugging Face won't tell you is which ablation technique was actually used. Here you see the primary method, any secondary ones, our confidence in the call, the specific evidence that produced the label, the classifier version that ran it, and the timestamp of the last classification. secondary_methods and classification_evidence arrive as JSON-encoded strings, so pipe them through jq's fromjson when you want real arrays. This is a full audit trail. If the label ever changes, the version and timestamp explain when and why.
$ curl -s -H "Authorization: Bearer $ABLITERATION_API_KEY" \
"https://abliteration.org/api/v1/models/mlabonne%2FQwen3-30B-A3B-abliterated" \
| jq '.data | {files_count,
total_gb: (.total_size_bytes / 1e9),
first_shard: .files[0]}'
{
"files_count": 38,
"total_gb": 183.2,
"first_shard": {
"filename": "model-00004-of-00013.safetensors",
"size_bytes": 4997743184,
"sha256": "dd954b96736ddf3fc4187b1d8982a9dae19144714..."
}
} The last slice answers a practical question. How much disk space will this cost me? files_count and total_size_bytes together tell you what's about to land in your cache. Dividing bytes by ten to the ninth gives gigabytes in a form your storage team will recognise. The first listed file's sha256 (files come back model files first, largest first) is also shown here because it's the smallest useful fingerprint: if two shards on two mirrors have the same hash, they are the same file, no need to re-download.
$ curl -s -H "Authorization: Bearer $ABLITERATION_API_KEY" \
"https://abliteration.org/api/v1/models/somebody%2Fmid-tier-model-that-vanished" \
| jq '.data | {id, is_delisted, last_seen_at, downloads,
hub_downloads_all_time}'
{
"id": "somebody/mid-tier-model-that-vanished",
"is_delisted": 1,
"last_seen_at": "2026-06-12T04:17:03Z",
"downloads": 18542,
"hub_downloads_all_time": 91307
} Every passport now carries two tombstone fields. is_delisted is a plain 0 or 1 flag, and last_seen_at is the timestamp of the final observation we made before the model disappeared from Hugging Face. When both come back non-null with the flag set to 1, the record you are reading is a preserved copy of a model that no longer exists at its source. Every other field is still there: method classification, download counts as last recorded, family and base links; the README history stays available from the drifts endpoint. The Hub is where a model gets erased. This is where it stays reachable.
4. Guard a marketplace listing
A marketplace, a moderation queue, or a CI pipeline needs one function: given a candidate id, decide whether it is safe to list. That decision is more than "does the id exist". It combines existence, classifier confidence, and the Weaponization index, each of them a separate call, all of them combined into a single verdict. Rust fits because a guard function that runs on every submission needs a compiled binary with typed errors and no runtime warm-up.
// Cargo.toml
[dependencies]
abliteration = "0.1"
use abliteration::apis::{configuration::Configuration, models_api, Error};
let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("ABLITERATION_API_KEY").ok();
let id = "mlabonne/Qwen3-30B-A3B-abliterated";
match models_api::get_model(&cfg, id) {
Ok(r) => println!("OK {} = {}", id,
r.data.primary_method.flatten().unwrap_or_default()),
Err(Error::ResponseError(e)) if e.status == 404 =>
eprintln!("MISS {} not in catalog", id),
Err(e) => eprintln!("ERR {}", e),
} A moderation guard has three possible outcomes and it needs to name each of them explicitly. The model exists in the catalog, in which case return the id and its classified method. The model does not exist, in which case say so with a distinct code so the caller can route it into a review queue instead of failing silently. Something else went wrong, network, auth, rate limit, in which case surface the underlying error. The crate is generated from the OpenAPI spec and uses blocking reqwest, so there is no async runtime to set up; a 404 arrives as Error::ResponseError with the HTTP status attached, and the match guard on that status makes each branch explicit.
let m = models_api::get_model(&cfg, id)?.data;
let conf = m.confidence.clone().flatten().unwrap_or_default();
let verdict = match conf.as_str() {
"high" => "auto-approve",
"medium" => "auto-approve, log for spot-check",
"low" => "queue for human review",
_ => "queue for human review",
};
println!("{} confidence={} => {}",
id, conf, verdict);
// mlabonne/Qwen3-30B-A3B-abliterated confidence=medium
// => auto-approve, log for spot-check Existence alone is not a safety verdict. Our classifier reports a confidence level for every call, and the guard should route on that. High confidence auto-approves. Medium confidence approves but writes a log line for a periodic spot check. Low confidence goes to a human. Sub-second decision, no manual review of the boring majority, human attention reserved for the ambiguous minority. This is the exact split that keeps moderation queues tolerable at scale.
use abliteration::apis::indices_api;
let w = indices_api::get_index(&cfg, "weaponization")?.data;
let pct = w.value.unwrap_or(0.0);
if pct > 5.0 {
eprintln!("BLOCK field weaponization at {}% (threshold 5%). \
Freeze all new listings.", pct);
return Ok(());
}
println!("PASS weaponization {}% (as of {}, threshold 5%)",
pct, w.as_of.as_deref().unwrap_or("?"));
// PASS weaponization 0% (as of 2026-11, threshold 5%) One more check, and this one is field-wide. The Weaponization index is our public measure of documented misuse across the whole abliteration space. Today it reads zero because we have no confirmed incidents on record: the value is a placeholder constant, and the payload says so with measured: false. The guard should still check it every time. If the index ever rises above your chosen threshold, freeze new listings entirely until the situation is understood. Five percent is a placeholder you should tune to your own risk appetite.
// This branch belongs at the very top of the guard, before
// confidence and before the weaponization gate. A model that
// was pulled from the Hub cannot be listed no matter how
// confident our classifier was when we still had it.
if m.is_delisted.flatten() == Some(1) {
eprintln!(
"BLOCK {} was pulled from the Hub on {}. \
Do not list.",
id,
m.last_seen_at.clone().flatten().as_deref().unwrap_or("?"),
);
return Ok(());
} A guard that only checks classification and confidence will happily approve a listing for a model that no longer exists. The catalog remembers it, the passport still returns, but the download link is dead. Shipping a dead dependency to your marketplace is worse than blocking a live one you were unsure about. One flag, one branch, placed above every other check. When is_delisted comes back as 1, refuse the listing and log the last-seen date so an operator can decide whether the removal was recent enough to fight or old enough to write off.
5. All four flagship indices at once
The catalog exposes four indices that together map the state of the abliteration field. DAI measures how much of a base model's audience flows into modified descendants. Freedom Velocity measures how many days pass from an original base model's release on Hugging Face until the first abliterated or uncensored model built on it appears. Weaponization measures documented misuse. F2W Latency measures the gap between the first two. TypeScript fits because these four numbers usually land on a dashboard, and the SDK (generated from the OpenAPI spec, one API class per resource) returns them typed.
$ npm install @abliteration/sdk
import { Configuration, IndicesApi } from "@abliteration/sdk";
const api = new IndicesApi(new Configuration({
accessToken: process.env.ABLITERATION_API_KEY!,
}));
const { data: idx } = await api.listIndices();
for (const i of idx) {
const v = i.value == null ? "-" : `${i.value} ${i.unit}`;
const meas = i.measured ? "measured" : "reported";
console.log(`${i.id!.padEnd(18)} ${v.padEnd(14)} ${meas}`);
}
// illustrative output; the values are examples, not current readings
// dai 15.12 percent measured
// freedom-velocity 65.8 days measured
// weaponization 0 percent reported
// f2w-latency - reported Four indices in one payload is the honest way to see the field. DAI is a measured percentage. Freedom Velocity is a measured average in days; its object also carries median and bases_count (read them from the raw JSON if your SDK version predates them). Weaponization is currently reported as zero not because we have measured absence of misuse but because no incidents have been confirmed yet. F2W Latency is null for the same reason: you cannot measure the time between two events when the second one has not happened. Both are constants in the server code, not query results, and each index also carries a source string that says where its number comes from. The measured flag (printed here as measured versus reported) exists so a dashboard cannot accidentally treat a placeholder as a finding.
const { data: dai } = await api.getIndex({ id: "dai" });
console.log(dai.value, dai.unit, "as of", dai.as_of);
// 15.12 percent as of 2026-11
for (const p of dai.history!.slice(-6)) {
console.log(p.month, p.weighted_dai_pct!.toFixed(2) + "%");
}
// 2026-06 3.45%
// 2026-07 2.89%
// 2026-08 6.43%
// 2026-09 7.22%
// 2026-10 12.44%
// 2026-11 15.12% DAI is the one index with real history: it is read from the monthly dai_market_history series, the same one the market page charts, and each point carries the weighted share of downloads that go to abliterated descendants plus the number of bases included that month. In this example the last six months are not a smooth line: a dip in July, then a steep climb from under seven percent in August to over fifteen in November. Read bases_included alongside the percentage, because a share moving on a changing base count can be partly an artefact of which bases made the cut that month.
import { LineChart, Line, XAxis, YAxis, Tooltip } from "recharts";
export function DaiChart({ history }) {
return (
<LineChart width={640} height={240} data={history}>
<XAxis dataKey="month" />
<YAxis unit="%" />
<Tooltip />
<Line type="monotone"
dataKey="weighted_dai_pct"
stroke="#4E9B87"
dot={false} />
</LineChart>
);
} The history array plugs into recharts with no reshaping. Feed it as data, name the field for the x axis and the field for the y axis, pick a stroke colour from the site palette, drop the dots for a cleaner line. Two hundred lines of TypeScript become one component you can embed on a status page or an investor deck. Everything else, tooltips, axis formatting, legends, is stock recharts and stays with the library.
6. Read the M-method taxonomy
M1 through M-uncensored is our classification of how a model was actually modified. Ranking them by adoption tells you which technique dominates. Following one method to its top authors tells you who is behind the wave. PHP fits because this shape of read-and-render task lives on a sidebar widget or a CMS route, cached for the hour, served by the same server that runs the marketing site.
$ composer require abliteration/abliteration
require __DIR__ . "/vendor/autoload.php";
use Abliteration\Client\Configuration;
use Abliteration\Client\Api\MethodsApi;
$cfg = Configuration::getDefaultConfiguration()
->setAccessToken(getenv("ABLITERATION_API_KEY"));
$api = new MethodsApi(new GuzzleHttp\Client(), $cfg);
foreach ($api->listMethods()->getData() as $m) {
printf("%-16s %-12s %5d models %10s dl\n",
$m->getId(), $m->getCategory(),
$m->getModelCount(), number_format($m->getTotalDownloads()));
}
// M1 original 3799 models 5,140,723 dl
// M2 original 0 models 0 dl
// M3 original 2030 models 11,060,073 dl
// M4 original 102 models 322,711 dl
// M5 merged 620 models 142,740 dl
// M5-frankenstein merged 57 models 119,228 dl
// ... M6, M7 rows ...
// M8 repackage 5298 models 15,511,375 dl
// M-uncensored original 3083 models 14,352,610 dl
// ... unknown (unclassified) row ... The methods endpoint returns our full taxonomy in one shot. Each row carries the M code, the category we assigned it to (original, merged, repackage, unclassified), the current model count and the total downloads across every live model classified as that method. Every code in the taxonomy is returned, including codes with zero models (M2 here) and an unknown bucket for models not yet classified, so a client can build a complete filter list from this one call. One large method dominating downloads, a long tail of smaller ones. Nothing hidden.
$methods = $api->listMethods()->getData();
usort($methods, fn($a, $b) =>
$b->getTotalDownloads() <=> $a->getTotalDownloads());
foreach (array_slice($methods, 0, 5) as $i => $m) {
printf("%d. %-16s %10s dl\n",
$i + 1, $m->getId(), number_format($m->getTotalDownloads()));
}
// 1. M8 15,511,375 dl
// 2. M-uncensored 14,352,610 dl
// 3. M3 11,060,073 dl
// 4. M1 5,140,723 dl
// 5. M4 322,711 dl To rank by adoption, sort the array on the client. PHP's usort takes a spaceship-style comparator and orders the list in place. The top five reveals what actually moves in the field: M8 (GGUF repackaging) leads, with M-uncensored close behind, then the real ablation techniques M3 and M1. Repackaging beating original ablation is a truth about how the ecosystem consumes models: most downloads are quantized versions, not the surgeries themselves.
$m8 = $api->getMethod("M8")->getData();
printf("%s (%s): %d models, %s downloads\n",
$m8->getLabel(), $m8->getCategory(),
$m8->getModelCount(), number_format($m8->getTotalDownloads()));
foreach (array_slice($m8->getTopAuthors(), 0, 5) as $a) {
printf(" %-16s %5d models\n", $a->getAuthor(), $a->getCount());
}
// Repackaged (GGUF) (repackage): 5298 models, 15,511,375 downloads
// mradermacher 2738 models
// RichardErkhov 131 models
// tensorblock 96 models
// bartowski 64 models
// DevQuasar 53 models Following the winner one step deeper answers who is behind it. The method detail endpoint carries a top_authors array with a per-author count. For M8, the top slot belongs to mradermacher with almost three thousand repackaged models. One author accounts for more than half of the entire method. That single fact reframes the ranking: the M8 lead is not a broad movement, it's largely one person's factory operating at scale.
7. Nightly export for the analytics team
For research reports, spreadsheets and dashboards, the whole catalog under a given method needs to arrive as a flat file every night. The models endpoint returns 50 rows by default and up to 1,000 per call; the export asks for 100 at a time, loops through the pages, and writes a well formed CSV. .NET fits because this is exactly what a nightly scheduled job on Windows or Linux looks like: a compiled console app, typed models, one file on disk when it finishes.
$ dotnet new console -n AbliterationExport
$ cd AbliterationExport
$ dotnet add package abliteration
$ dotnet add package Microsoft.Extensions.Hosting
$ export ABLITERATION_API_KEY=abl_live_...
$ dotnet run
using System.Globalization;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using abliteration.Api;
using abliteration.Client;
using abliteration.Extensions;
var host = Host.CreateDefaultBuilder(args)
.ConfigureApi((context, options) =>
options.AddTokens(new BearerToken(
Environment.GetEnvironmentVariable("ABLITERATION_API_KEY")!)))
.Build();
var models = host.Services.GetRequiredService<IModelsApi>(); A nightly export is one of the few tasks where compiled languages still pull ahead. No interpreter warm-up, typed models, one binary that ships to a build server and runs under the platform scheduler of your choice. The setup is a standard dotnet console project plus the package reference; the NuGet client is generated in the .NET generic-host style, so the key is registered once as a bearer token and the API classes come out of dependency injection. The key comes from the environment, so nothing sensitive lands in the code or the artifact. Everything below runs the same on Windows Task Scheduler or a Linux systemd timer.
await using var csv = new StreamWriter("m1-models.csv");
await csv.WriteLineAsync(
"id,author,family,params_b,downloads,created_at");
int offset = 0, total = 0;
while (true) {
var page = (await models.ListModelsAsync(
method: "M1", sort: "downloads",
limit: 100, offset: offset)).Ok();
foreach (var m in page.Data) {
await csv.WriteLineAsync(string.Join(",",
m.Id, m.Author, m.Family ?? "",
m.ParamsB?.ToString(CultureInfo.InvariantCulture) ?? "",
m.Downloads, m.CreatedAt));
total++;
}
if (page.Data.Count < 100) break;
offset += 100;
}
Console.WriteLine($"Wrote {total} rows to m1-models.csv");
// Wrote 3799 rows to m1-models.csv This loop asks the models endpoint for a hundred rows per call. To export a full method, loop with offset and stop when a page comes back short. Deep offsets cost more on the models list (the price is multiplied by 1 + (offset/2500)²), and every response reports its actual cost. Write each row to disk as it arrives so memory stays flat regardless of how many rows the method contains. Two small details worth naming: InvariantCulture on the parameter count keeps the CSV portable across European locales that would otherwise write 27,5, and the null-coalesce on family covers the rare rows where our classifier could not assign a family.
$ head -6 m1-models.csv id,author,family,params_b,downloads,created_at PocketAiHub/Qwen3.8-27B-Abliterated-MLX,PocketAiHub,qwen,27,0,2026-08-15T14:18:33Z PocketAiHub/Qwen3.8-9B-Abliterated-MLX,PocketAiHub,qwen,9,0,2026-08-17T08:37:11Z nqd145/Gemma-4-E2B-it-abliterated-litertlm,nqd145,gemma,,0,2026-08-16T09:12:44Z mlabonne/NeuralDaredevil-8B-abliterated,mlabonne,llama,8,14863,2024-05-27T18:03:12Z mlabonne/Meta-Llama-3.1-8B-abliterated,mlabonne,llama,8,9421,2024-07-29T10:44:20Z $ wc -l m1-models.csv 3800 m1-models.csv # 3799 rows + header
The result is a plain CSV that any tool can read: Excel, pandas, DuckDB, Google Sheets. The five sample rows (an illustrative selection) show a mix: two brand-new MLX quantizations with zero downloads because they are too fresh to have been indexed by the hub's counter, one Gemma conversion, two mlabonne classics with real historic download numbers. The row count on the last line, 3799 plus header, matches the M1 model count from case 6. That's your consistency check: the export and the taxonomy agree.
8. Follow the field as it moves
Beyond individual models, the catalog tracks the events that move the field. A major open-weights release. A piece of press coverage. A regulatory notice. An academic paper. A newsroom desk or a policy team wants a polled feed of these with dedup and typed events. Elixir fits because a supervised GenServer that polls, deduplicates and emits fresh events is exactly the shape the BEAM was built for.
# mix.exs
def deps do
[
{:abliteration, "~> 0.1"}
]
end
# config/runtime.exs
config :field, :abliteration_key,
System.get_env("ABLITERATION_API_KEY") Elixir setup is two blocks. mix.exs pulls the client, a Tesla-based package generated from the OpenAPI spec that decodes JSON with Elixir's built-in JSON module. runtime.exs reads the API key from the environment when the release starts, not at compile time, so the same binary works across staging and production. The client does not read the key on its own: you pass it as bearer_token when you build a connection, which the GenServer below does once at start.
defmodule Field.Timeline do
use GenServer
@interval :timer.minutes(5)
def start_link(_),
do: GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
def init(_) do
conn = Abliteration.Connection.new(
bearer_token: Application.fetch_env!(:field, :abliteration_key))
Process.send_after(self(), :poll, 0)
{:ok, %{conn: conn, seen: MapSet.new()}}
end
def handle_info(:poll, %{conn: conn, seen: seen} = state) do
{:ok, %{data: events}} =
Abliteration.Api.Timeline.list_timeline(conn, limit: 20)
events
|> Enum.reject(&MapSet.member?(seen, &1.id))
|> Enum.each(&Phoenix.PubSub.broadcast(
Field.PubSub, "timeline", {:field_event, &1}))
Process.send_after(self(), :poll, @interval)
{:noreply, %{state | seen: MapSet.union(seen,
MapSet.new(events, & &1.id))}}
end
end One supervised GenServer is enough for a polled feed. On start it schedules the first poll immediately. Each poll fetches the last twenty timeline events, diffs them against a MapSet of ids seen so far, broadcasts each fresh event on a Phoenix.PubSub topic, and schedules the next poll five minutes out. State is one MapSet. On restart the set starts empty and you get one duplicate broadcast round, which is the honest trade for zero external storage. Any LiveView or channel can subscribe to the topic and re-render on each event.
iex> {:ok, %{data: events}} =
...> Abliteration.Api.Timeline.list_timeline(conn,
...> to: "2026-07-31", limit: 2)
iex> events
[
%Abliteration.Model.Event{
id: "evt_2026_07_27_kimi_k3_weights",
date: "2026-07-27",
date_precision: "day",
type: "model_release",
title: "Moonshot AI publishes Kimi K3 weights",
description: "Open weights published 27 July 2026 " <>
"following UK AISI / US CAISI evaluation.",
primary_source_url: "https://ctc.westpoint.edu/..."
},
%Abliteration.Model.Event{
id: "evt_2026_07_21_threatdown",
date: "2026-07-21",
date_precision: "day",
type: "press_coverage",
title: "ThreatDown 2026 Cybercrime in the age of AI report",
description: "6,644 distinct guardrail-free HF models " <>
"downloaded 22M+ times in 30 days.",
primary_source_url: "https://www.businesswire.com/..."
}
] The timeline returns typed structs, not raw maps, newest first. Each event carries a stable id, a date as an ISO string with a date_precision (day, month or quarter), a type that groups events into families (model releases, press coverage, regulatory actions, papers and more), a title, a short description, and a link to the primary source. The to filter here pins the window to late July so the example stays reproducible. The two events shown are rows from our timeline table: an open-weights release and a piece of press coverage that landed within a week of each other. That closeness in time is itself information about how the field moves.
9. Ship an author profile in a mobile app
On a phone, an author profile is one scrollable screen: a header with totals, then a list of that author's models. The author-detail endpoint returns exactly that shape, so one call fills the whole screen. Dart and Flutter fit because the abliteration package returns typed model classes that plug straight into a FutureBuilder without a manual JSON pass, and the same code runs on Android, iOS and web builds.
# pubspec.yaml
dependencies:
flutter:
sdk: flutter
abliteration: ^0.1.8
$ flutter run --dart-define=ABL_KEY=abl_live_...
// App entry:
import 'package:abliteration/api.dart';
final client = ApiClient(
authentication: HttpBearerAuth()
..accessToken = const String.fromEnvironment('ABL_KEY'),
); Flutter setup is pubspec.yaml plus one client object. The package is generated from the OpenAPI spec on top of package:http, with plain Dart model classes, so there is no code-generation step on your side. The API key is compiled in via --dart-define rather than a dotenv file. This is the mobile pattern: the key ships inside the release binary and is rotated by re-signing, not by shipping a config file to every device.
Future<AuthorDetail> loadAuthor(String handle) async {
final res = await AuthorsApi(client).getAuthor(handle);
return res!.data;
}
final profile = await loadAuthor("mlabonne");
print(profile.author); // mlabonne
print(profile.totalModels); // 40
print(profile.totalDownloads); // 316838
print(profile.totalLikes); // 1958
print(profile.models.length); // 25 summaries embedded (the cap) One call is the whole screen. loadAuthor returns a typed AuthorDetail with the four scalar totals and an embedded sample of the author's models, capped at 25. The numbers here are for mlabonne: forty models, three hundred and sixteen thousand downloads, nearly two thousand likes. The totals are computed the same way as on the authors list endpoint, summed from the models table at request time, so the two agree. For an author with more than 25 models, page the rest from /api/v1/models?author=....
class AuthorScreen extends StatelessWidget {
final String handle;
const AuthorScreen({required this.handle});
@override
Widget build(BuildContext context) {
return FutureBuilder<AuthorDetail>(
future: loadAuthor(handle),
builder: (ctx, snap) {
if (!snap.hasData)
return const CircularProgressIndicator();
final a = snap.data!;
return CustomScrollView(slivers: [
SliverAppBar(
title: Text(a.author ?? handle),
expandedHeight: 140,
flexibleSpace: AuthorStats(
models: a.totalModels,
downloads: a.totalDownloads,
likes: a.totalLikes,
),
),
SliverList.builder(
itemCount: a.models.length,
itemBuilder: (_, i) => ModelTile(model: a.models[i]),
),
]);
},
);
}
} The widget is a single FutureBuilder wrapping a CustomScrollView. A SliverAppBar holds the header with the totals. A SliverList.builder below it renders each model as a tile. AuthorStats and ModelTile are left as widget references because every team will style them to their own design language. What matters here is the shape: one fetch, one scroll view, header and list from the same payload.
10. Line up three dataset categories
The catalog sorts datasets into six categories; three of them map to three stages of the abliteration pipeline. Extract is the harmful and harmless prompt pairs used to find the refusal direction. Evaluate is the benchmarks it is judged by. Heal is the material used to restore capability after ablation. A compliance report or a research review needs all three lined up so the reader can see what dominates each stage. Java fits because this shape of task is what enterprise reporting looks like: a compiled JAR, typed responses, one run a week feeding a corporate dashboard.
// build.gradle.kts
dependencies {
implementation("org.abliteration:abliteration:0.1.9")
}
// Or Maven pom.xml:
// <dependency>
// <groupId>org.abliteration</groupId>
// <artifactId>abliteration</artifactId>
// <version>0.1.9</version>
// </dependency>
$ export ABLITERATION_API_KEY=abl_live_...
$ ./gradlew run Java's build system takes one line for a dependency. The Gradle syntax is shown first because most new JVM projects start there, with the Maven equivalent in a comment for teams that still use pom.xml. Both point at the same coordinates on Maven Central. After the key export and a gradlew run, the reader is ready to make API calls with the same typed client that a production Spring Boot service would use.
import org.abliteration.client.ApiClient;
import org.abliteration.client.Configuration;
import org.abliteration.client.api.DatasetsApi;
import org.abliteration.client.auth.HttpBearerAuth;
ApiClient client = Configuration.getDefaultApiClient();
HttpBearerAuth bearer =
(HttpBearerAuth) client.getAuthentication("bearerAuth");
bearer.setBearerToken(
System.getenv("ABLITERATION_API_KEY"));
DatasetsApi api = new DatasetsApi(client);
// listDatasets(category, author, license, sort, limit, offset)
var extract = api.listDatasets("extract",
null, null, "downloads", 3, null);
var evaluate = api.listDatasets("evaluate",
null, null, "downloads", 3, null);
var heal = api.listDatasets("heal",
null, null, "downloads", 3, null); The dataset categories are how we split the pipeline. extract is the harmful and harmless prompt pairs used to identify the refusal direction. evaluate is the benchmarks it gets scored against. heal is the restoration data used to recover capabilities after ablation. Three parallel listDatasets calls give three typed lists, one per category. Sorting on downloads (which on datasets ranks by downloads_all, the lifetime figure) and clamping to three per column keeps the output narrow enough to print on a terminal or paste into a memo.
System.out.printf("%-3s %-38s %-38s %-38s%n",
"#", "EXTRACT", "EVALUATE", "HEAL");
for (int i = 0; i < 3; i++) {
var e = extract.getData().get(i);
var v = evaluate.getData().get(i);
var h = heal.getData().get(i);
System.out.printf("%-3d %-30s %8d %-30s %8d %-30s %8d%n",
i + 1,
shortId(e.getId()), e.getDownloadsAll(),
shortId(v.getId()), v.getDownloadsAll(),
shortId(h.getId()), h.getDownloadsAll());
}
// # EXTRACT EVALUATE HEAL
// 1 Anthropic/hh-rlhf 2030508 google/IFEval 1433165 argilla/distilabel-intel-orca... 163091
// 2 mosaicml/dolly_hhrlhf 309087 JailbreakBench/JBB-Behaviors 383318 Intel/orca_dpo_pairs 121771
// 3 Dahoas/full-hh-rlhf 265720 Beijing-AISI/panda-bench 193296 arcee-ai/distilabel-intel-orca... 118049 Printed side by side, the three categories tell one story. extract is led by Anthropic's hh-rlhf human-preference dataset. evaluate is led by Google's IFEval, an instruction-following benchmark. heal is led by an argilla variant of Intel's orca_dpo_pairs. Three columns, three eras of the pipeline, one glance to see who supplies each stage.
Change stream: what shifted since your last check
The first ten cases treat the catalog as a snapshot. Everything after this point treats it as a river. Seven endpoints report what changed on the Hub since the last time you looked: which models disappeared, when their README shifted and how, which downloads spiked or fell out of nowhere. The same envelope, the same key, the same clients you already have installed. What follows is five tasks that use them, each in the language that makes the task honest.
11. Weekly compliance snapshot from a cron job
A compliance officer needs one email every Monday. How many models did Hugging Face pull last week, which ones were the biggest losses, and what disappeared most recently. Nothing about this task needs an interpreter, a dependency lockfile or a container. Bash with curl and jq handles it in under twenty lines, sits in /etc/cron.weekly, and never breaks over a Python version bump on the server. Every language on this page could do the same, but this is where shell earns its keep.
$ export ABLITERATION_API_KEY=abl_live_...
$ curl -s -H "Authorization: Bearer $ABLITERATION_API_KEY" \
"https://abliteration.org/api/v1/models/historical-deletions/summary" \
| jq '.data | {
all_time: .total_deleted,
of_everything: (.deletion_rate_pct | . * 100 | round / 100),
avg_life_mo: (.avg_months_alive | . * 10 | round / 10),
last_six: (.timeline | .[-6:])
}'
{
"all_time": 2983,
"of_everything": 15.3,
"avg_life_mo": 7.7,
"last_six": [
{ "month": "2026-04", "count": 58 },
{ "month": "2026-05", "count": 72 },
{ "month": "2026-06", "count": 91 },
{ "month": "2026-07", "count": 67 },
{ "month": "2026-08", "count": 53 },
{ "month": "2026-09", "count": 41 }
]
} The summary endpoint returns the numbers a compliance memo opens with. How many models the 24-month Hub snapshot analysis has seen disappear from Hugging Face, what share that is of everything seen (deleted plus the current catalog, an approximation the server computes and already rounds to one decimal, as a percentage), how many months the average one survived, and how many were last seen in each month. jq trims the timeline to the last six entries, which is usually the window someone in the meeting actually wants to see. One call, one shape, no math on the shell side beyond a rounding for readability.
$ curl -s -H "Authorization: Bearer $ABLITERATION_API_KEY" \
"https://abliteration.org/api/v1/models/historical-deletions/list?since_month=2026-09&sort=downloads&limit=5" \
| jq -r '.data[] |
"\(.peak_downloads)\t\(.total_months_alive)mo\t\(.id)"' \
| column -t -s "$(printf '\t')"
1358421 14 someauthor/big-vanished-model
491203 9 otherauth/mid-tier-model-that-was-once-notable
188044 22 veteran/very-old-checkpoint-quietly-pulled
72019 4 freshface/four-months-then-gone
34220 6 quantcorp/gguf-sibling-taken-down-with-parent The list endpoint pages the same 24-month backlog and takes a since_month cutoff, so a script asking "who died in September" gets exactly that. Sorting on downloads puts the biggest losses at the top of the memo, which matters, because the reader wants to know what really left, not which forgotten GGUF sibling was the most recent to go. column -t straightens the tab-separated output into legible fixed-width for the inbox this ends up in.
$ curl -s -H "Authorization: Bearer $ABLITERATION_API_KEY" \
"https://abliteration.org/api/v1/models/delisted?sort=recent&limit=5" \
| jq -r '.data[] |
"\(.last_seen_at[0:10]) \(.days_since_gone)d \(.downloads) \(.id)"'
2026-09-17 2d 8342 author-x/model-name-here
2026-09-15 4d 1123 author-y/another-checkpoint
2026-09-13 6d 19204 bigauthor/older-but-still-notable
2026-09-11 8d 402 smallfry/almost-nobody-noticed
2026-09-08 11d 6011 moderate/mid-week-casualty The delisted feed is the "who died this week" answer in a shape a shell can format with a single jq string interpolation. last_seen_at[0:10] slices the ISO timestamp to the date. days_since_gone is a convenience field the server computes so a compliance officer sees "2d" rather than has to subtract dates in her head. The three slices together, aggregate, biggest losses of the month, freshest graves, are the full memo shape.
#!/usr/bin/env bash
# /etc/cron.weekly/abl-compliance
set -euo pipefail
: "${ABLITERATION_API_KEY:?set in /etc/default/abl}"
BASE="https://abliteration.org/api/v1"
AUTH=(-H "Authorization: Bearer $ABLITERATION_API_KEY")
MONTH=$(date -u +%Y-%m)
OUT=$(mktemp)
{
echo "Deletion snapshot as of $(date -u +%Y-%m-%d)"
echo
curl -s "${AUTH[@]}" "$BASE/models/historical-deletions/summary" \
| jq '.data | { total_deleted, avg_months_alive, timeline: .timeline[-6:] }'
echo
echo "Biggest losses this month ($MONTH):"
curl -s "${AUTH[@]}" \
"$BASE/models/historical-deletions/list?since_month=$MONTH&sort=downloads&limit=5" \
| jq -r '.data[] | " \(.peak_downloads)\t\(.id)"' \
| column -t -s "$(printf '\t')"
echo
echo "Fresh graves (last week):"
curl -s "${AUTH[@]}" "$BASE/models/delisted?sort=recent&limit=5" \
| jq -r '.data[] | " \(.last_seen_at[0:10]) \(.id)"'
} > "$OUT"
mail -s "abliteration weekly deletion report" [email protected] < "$OUT"
rm -f "$OUT" Three calls, one temp file, one mail invocation. The script reads the key from the environment and stops with a pointer to /etc/default/abl if it is missing, so nothing sensitive appears in the script itself. set -euo pipefail stops the script when a command fails; note that curl exits with an error on an HTTP error status only when it is given --fail. Weekly cadence is a convention: the file lives in /etc/cron.weekly, which the system's cron runs on its own weekly schedule. On Monday morning the compliance inbox has a fresh snapshot without a single Python interpreter ever having to start.
12. Fleet monitoring in CI
A repository depends on a handful of specific model checkpoints. When one of them disappears from Hugging Face, the team wants to hear about it before the next pip install or docker build discovers it the hard way. A daily GitHub Actions run does the job. No Node package in the repo, no compiled binary, nothing to maintain past a workflow file and a small shell script. The abl CLI covers everything the check needs, which is exactly why the bonus at the end of this guide grows into a full case here.
# .github/workflows/fleet-check.yml
name: fleet-check
on:
schedule:
- cron: "17 6 * * *" # 06:17 UTC daily
workflow_dispatch:
jobs:
check:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: "20"
- run: npm install -g @abliteration/cli
- run: bash scripts/fleet-check.sh
env:
ABLITERATION_API_KEY: ${{ secrets.ABLITERATION_API_KEY }} Standard GitHub Actions boilerplate with two departures worth naming. The cron minute is 17, not 0, because the top of the hour is when everyone else's cron jobs fire and the queue makes you wait. workflow_dispatch is included so an engineer can trigger the same check from the Actions tab in seconds, without waiting for the next scheduled run. The key comes in from repository secrets so nothing sensitive sits in the repo, and the CLI installs globally so the shell script that follows can just call abl.
#!/usr/bin/env bash
# scripts/fleet-check.sh
set -euo pipefail
# Pinned models this repository depends on:
MODELS=(
"mlabonne/Qwen3-30B-A3B-abliterated"
"huihui-ai/Llama-3.3-70B-Instruct-abliterated"
"DavidAU/L3.1-Dark-Planet-8B-abliterated"
)
fails=0
for m in "${MODELS[@]}"; do
row=$(abl models "$m" --json)
dead=$(echo "$row" | jq '.data.is_delisted // 0')
if [ "$dead" = "1" ]; then
lost=$(echo "$row" | jq -r '.data.last_seen_at // "unknown"')
echo "::error title=Delisted::$m was pulled from HF on $lost"
fails=$((fails + 1))
else
echo " ok $m"
fi
done
if [ "$fails" -gt 0 ]; then
echo "::error::$fails model(s) in the fleet are no longer on Hugging Face."
exit 1
fi The script stays small on purpose. A bash array holds the fleet, one line per pinned model. For each entry, abl models <id> --json fetches the passport wrapped in the same envelope curl would return, and jq reads .data.is_delisted with a null-safe default. When the flag is 1, the script prints a GitHub Actions error annotation (the ::error:: prefix is what turns a log line into a red banner in the run summary) and increments a counter. A non-zero counter at the end is a non-zero exit code, which is what fails the workflow.
$ gh run view --log-failed ok huihui-ai/Llama-3.3-70B-Instruct-abliterated ok DavidAU/L3.1-Dark-Planet-8B-abliterated ::error title=Delisted::mlabonne/Qwen3-30B-A3B-abliterated was pulled from HF on 2026-09-14T11:22:07Z ::error::1 model(s) in the fleet are no longer on Hugging Face. Process completed with exit code 1. Run failed. $ gh api repos/:owner/:repo/check-runs/CHECK_RUN_ID/annotations \ | jq '.[0].message' "mlabonne/Qwen3-30B-A3B-abliterated was pulled from HF on 2026-09-14T11:22:07Z"
The point is not just to notice but to fail loud enough that no one misses it. GitHub notifies the user who last changed the workflow's cron schedule, the Actions tab shows the failed run, and Slack (if you route Actions notifications there) posts the annotation verbatim. A dependency that quietly disappeared six weeks ago no longer waits in the manifest for someone's next fresh clone to break the build.
13. README drift audit for a headline model
When a model gets press coverage, its README often gets edited in response. Marketing language softens, disclaimers appear, method descriptions get simplified for a wider audience. A journalist writing a follow-up piece, or a researcher building a citation record, wants to know what changed and when. Python is a natural fit here: text handling, diff libraries in the standard library, quick REPL for exploration. difflib.unified_diff does all the heavy lifting and comes in the box.
$ pip install abliteration
$ export ABLITERATION_API_KEY=abl_live_...
$ python
>>> from abliteration import Client
>>> from urllib.parse import quote
>>> mid = "mlabonne/Qwen3-30B-A3B-abliterated"
>>> enc = quote(mid, safe="")
>>> with Client() as c:
... env = c.get_envelope(
... f"/api/v1/models/{enc}/drifts",
... params={"limit": 6},
... )
... drifts = env.data
... for d in drifts:
... sign = "+" if d["size_delta"] > 0 else ""
... msg = ((d.get("commit_message") or "").splitlines() or [""])[0][:44]
... print(f"{d['commit_sha'][:8]} {sign}{d['size_delta']:>5}b {msg}")
...
ff53d83f -1322b Update README.md
50d872d0 -2653b Update README.md
e8c6fbd9 0b Upload Qwen3MoeForCausalLM The drifts endpoint returns every commit that changed a model's README on the Hub, newest first, with the byte delta since the previous commit. The oldest commit always reports a delta of 0, because there is nothing before it to compare against. The Python client keeps a general-purpose get_envelope escape hatch that hands you a raw dict for any path, which is what we use here because the client has no typed convenience methods for the change-stream routes. Reading down the list tells a small story on its own: a README that arrived with the weights upload at about 5 KB, then two edits that cut it to about 2.5 KB and then 1.2 KB. No README bytes fetched yet, only the diff-shaped metadata.
>>> import difflib
>>> def readme_at(client, model_id, commit):
... env = client.get_envelope(
... f"/api/v1/models/{quote(model_id, safe='')}"
... f"/readme-at/{commit}"
... )
... return env.data["content"]
>>> with Client() as c:
... first = readme_at(c, mid, drifts[-1]["commit_sha"])
... latest = readme_at(c, mid, drifts[0]["commit_sha"])
>>> diff = difflib.unified_diff(
... first.splitlines(),
... latest.splitlines(),
... fromfile=f"{mid}@first",
... tofile=f"{mid}@latest",
... lineterm="",
... n=1,
... )
>>> print("\n".join(list(diff)[:10]))
--- mlabonne/Qwen3-30B-A3B-abliterated@first
+++ mlabonne/Qwen3-30B-A3B-abliterated@latest
@@ -2,198 +2,21 @@
library_name: transformers
-tags: []
+license: apache-2.0
+license_link: https://huggingface.co/Qwen/Qwen3-30B-A3B/blob/main/LICENSE
+pipeline_tag: text-generation
+base_model:
+- Qwen/Qwen3-30B-A3B Two calls to the readme-at endpoint, one for the earliest commit in the list and one for the most recent, then Python's own difflib.unified_diff prints the changes. The tiny readme_at helper wraps the escape hatch so the diff line reads naturally. The first hunk already shows what happened: the first version was Hugging Face's blank model-card template, and the latest one adds license and base-model metadata, then (further down the diff) a short card that warns the model is still a work in progress and not recommended for use yet. That kind of warning is exactly what a research follow-up needs to see dated. The Hub model page shows the current README. Here you have both endpoints of the timeline, and every version in between, without leaving the standard library.
>>> from datetime import datetime, timezone
>>> biggest = max(drifts, key=lambda d: abs(d["size_delta"]))
>>> when = datetime.fromtimestamp(biggest["commit_ts"], timezone.utc)
>>> print(f"Biggest single change: {biggest['commit_sha'][:8]} on {when:%Y-%m-%d}")
>>> print(f"Message: {biggest['commit_message']}")
>>> print(f"Byte delta: {biggest['size_delta']:+d}")
Biggest single change: 50d872d0 on 2025-05-18
Message: Update README.md
Byte delta: -2653 One line finds the commit that moved the most bytes. The initial upload can never win that contest, because its delta is reported as 0, so the winner is always a later edit. When that edit is large, something substantial happened: a rewrite, a new evaluation table, a retraction of a claim. Here it is the edit that replaced the blank template with a real card. That is the commit worth pulling and reading in full, and it is one readme_at call away.
14. Watch the field from a Cloudflare Worker
A Discord channel, a Slack workspace or a team wiki wants a weekly note about the biggest download movers in the field. No backend, no server to keep alive, no cron machine to patch. A Cloudflare Worker with a scheduled trigger runs once a week on Cloudflare's free tier, calls /market/anomalies, formats three lines and posts them to a webhook. TypeScript fits because the Worker runtime speaks it natively and the @abliteration/sdk package is built on the platform fetch, with no Node-specific bindings.
# wrangler.toml
name = "abl-surge-watcher"
main = "src/worker.ts"
compatibility_date = "2026-09-01"
[triggers]
crons = ["7 6 * * 1"] # 06:07 UTC, every Monday
# npm install @abliteration/sdk
# wrangler secret put ABLITERATION_API_KEY
# wrangler secret put SLACK_WEBHOOK
# wrangler deploy
// src/worker.ts
import { Configuration, ModelsApi, type DownloadAnomaly } from "@abliteration/sdk";
interface Env {
ABLITERATION_API_KEY: string;
SLACK_WEBHOOK: string;
}
export default {
async scheduled(_ctrl: ScheduledController, env: Env) {
const cfg = new Configuration({
accessToken: env.ABLITERATION_API_KEY,
});
const api = new ModelsApi(cfg); // /market/anomalies lives on ModelsApi
const { data } = await api.listAnomalies({
kind: "spike",
windowDays: 7,
minBaseline: 1000,
limit: 3,
});
if (data.length === 0) return; // quiet week, no post
await postToSlack(env.SLACK_WEBHOOK, data);
},
}; A Cloudflare Worker with one scheduled trigger runs every Monday at 06:07 UTC. Free tier covers this weekly cadence with room to spare. ModelsApi.listAnomalies (the SDK files the anomalies route under the models tag) returns spikes and drops as typed objects, no manual JSON parsing on the worker side. A spike is a current reading at least 2x the reading closest to windowDays ago, and minBaseline drops models whose baseline was too small to mean anything. Three movers is the right dose: enough to see a pattern, few enough to fit on a phone screen. When nothing crossed the threshold, the array is empty and the worker skips the post entirely. Silence is a valid answer.
async function postToSlack(webhook: string, rows: DownloadAnomaly[]) {
const lines = rows.map((row, i) => {
const pct = ((row.ratio! - 1) * 100).toFixed(0);
const base = row.baseline_downloads!.toLocaleString();
const now = row.current_downloads!.toLocaleString();
return `${i + 1}. *${row.model_id}* ` +
`\`${base}\` → \`${now}\` ` +
`(+${pct}%)`;
});
const message = {
text: `Weekly abliteration spikes, 7-day window:\n${lines.join("\n")}`,
};
await fetch(webhook, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(message),
});
} The Slack message stays close to mrkdwn. Bold the model id so the eye lands on it, backticks around the two numbers so the download counts render as inline code, a plus-signed percentage at the end. The ratio comes straight from the anomalies endpoint, so the client-side math is only for cosmetics. Three lines of Slack text, one channel that watches abliteration for you.
#hf-watch Monday 09:07 abl-surge-watcher APP Weekly abliteration spikes, 7-day window: 1. mlabonne/Qwen3-30B-A3B-abliterated 14,321 → 218,909 (+1429%) 2. huihui-ai/Llama-3.3-70B-abliterated 3,102 → 38,004 (+1125%) 3. DavidAU/Qwen3.8-27B-Frankenstein 842 → 9,401 (+1017%)
The Monday message arrives before anyone is at their desk, so the first thing the channel sees is the week's three biggest movers already ranked. Anyone watching a specific author or family can eyeball the list and know within seconds whether one of their names is on it. A quiet week produces no message at all, which is often the honest report: no post, no false urgency, no fabricated news.
15. Sparklines for a fleet, in the CMS a newsroom already runs
A newsroom keeps a fleet of ten or fifteen models it follows for stories. The editor wants a tile on the internal WordPress dashboard, or on the intranet built out of PHP templates, that shows a sparkline for each. No new dashboard tool. No Grafana. Just a page in the admin area of the CMS the team already logs into. PHP fits because this shape of read-and-render task is what PHP was made for: pull a small number of rows, echo them into an HTML template, hand the numbers to a tiny Chart.js block. The result is a page the editorial staff can bookmark, not a service that needs a runbook.
$ composer require guzzlehttp/guzzle
<?php // wp-content/plugins/abl-fleet-tile/tile.php
require_once __DIR__ . "/vendor/autoload.php";
$http = new GuzzleHttp\Client([
"base_uri" => "https://abliteration.org/api/v1/",
"headers" => ["Authorization" =>
"Bearer " . getenv("ABLITERATION_API_KEY")],
]);
// The ten models this newsroom tracks:
$fleet = [
"mlabonne/Qwen3-30B-A3B-abliterated",
"huihui-ai/Llama-3.3-70B-Instruct-abliterated",
"DavidAU/L3.1-Dark-Planet-8B-abliterated",
// ... seven more in a real deployment
];
$series = [];
foreach ($fleet as $id) {
$res = $http->get("models/" . rawurlencode($id) . "/download-history",
["query" => ["days" => 90]]);
$hist = json_decode((string) $res->getBody(), true);
$series[$id] = array_column($hist["data"], "downloads");
} The published PHP SDK (abliteration/abliteration 0.1.0 on Packagist) predates the change-stream routes, so this tile calls the endpoint with plain Guzzle: one GET per model with days=90, the id percent-encoded so its slash travels as %2F, and each response reduced to a flat array of download readings, one per snapshot. The whole page holds ten short arrays of integers, a few kilobytes of state at most. Every request is a flat 5 credits regardless of how many rows come back, so a ten-model refresh costs 50 credits, the price of five passport reads.
?>
<div class="fleet-grid">
<?php foreach ($series as $id => $points): ?>
<div class="fleet-card">
<div class="fleet-id"><?= htmlspecialchars($id) ?></div>
<canvas class="spark"
data-points="<?= implode(",", $points) ?>"></canvas>
<div class="fleet-latest">
<?= number_format(end($points)) ?> dl
</div>
</div>
<?php endforeach; ?>
</div>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script>
document.querySelectorAll(".spark").forEach(el => {
const points = el.dataset.points.split(",").map(Number);
new Chart(el, {
type: "line",
data: {
labels: points.map((_, i) => i),
datasets: [{
data: points,
borderColor: "#4E9B87",
pointRadius: 0,
borderWidth: 1.5,
tension: 0.3,
}],
},
options: {
plugins: { legend: { display: false } },
scales: { x: { display: false }, y: { display: false } },
animation: false,
},
});
});
</script> The template loop hydrates one card per model. The download timeline is dumped into a data-points attribute as a comma-separated string; Chart.js picks it up on load, hides both axes and the legend, and renders a bare line. That is the sparkline. Ten of them in a grid tells you at a glance which models are climbing and which are flat, without a database on the middle tier, without a dashboard tool, and without much CSS.
Fleet download trend, last 90 days [ Refresh ] +-------------------------------------------------------------------+ | mlabonne/Qwen3-30B-A3B-abliterated | | ▁▂▂▃▄▅▆▇█████▇▇▇▇▆▆▆▆▅▅▄▄▄▃▃▃▂▂▁▁ 218,909 dl | | | | huihui-ai/Llama-3.3-70B-Instruct-abliterated | | ▁▁▁▂▂▃▄▄▄▅▅▆▇▇███▇▆▆▅▄▄▃▃▂▂▁▁ 38,004 dl | | | | DavidAU/L3.1-Dark-Planet-8B-abliterated | | ▁▁▁▁▁▁▁▁▁▁▂▃▄▄▅▆▇█▇▇▆▅▄▃▂▁▁▁▁▁ 9,401 dl | | | | ... seven more | +-------------------------------------------------------------------+
The rendered admin page shows real Chart.js curves in a browser. The ASCII sketch above stands in for the shape because a screenshot cannot type itself out. The pattern is what matters. One steady climb into a plateau. One late-summer surge that softens. One single-week burst that returned to nothing. A weekly editorial meeting looks at this tile for ten seconds and knows which model to write about first, and which one is not the story any more.
Bonus: check anything without installing a client
All fifteen cases above use a native client because that is what production code looks like. Sometimes what you want is one line in a shell: a quick look, a debug pass, a sanity check before writing anything. The abl CLI covers that. Same envelope, same key, no dependency on your project's language.
$ npm install -g @abliteration/cli $ export ABLITERATION_API_KEY=abl_live_... # Case 1 - Monday briefing $ abl models --sort created --limit 3 --json | jq -r '.data[].id' DavidAU/Qwen3.8-27B-TWIN-TURBO-Fable-Cold-Fusion-709-L-Unce... taurusduan/qwen3.8-27b-abliterated-3.69bpw-12GB-MTP.gguf mlabonne/Qwen3-30B-A3B-abliterated # Case 2 - Top authors $ abl authors --sort downloads --limit 3 --json \ | jq -r '.data[] | "\(.author) \(.total_models) \(.total_downloads)"' HauhauCS 26 9369705 mradermacher 3221 5945791 DavidAU 207 5017040 # Case 5 - Four indices (illustrative output; the values are examples, not current readings) $ abl indices --json \ | jq -r '.data[] | "\(.id) \(.value) \(.measured)"' dai 15.12 true freedom-velocity 65.8 true weaponization 0 false f2w-latency null false # Case 3 - Model passport $ abl models mlabonne/Qwen3-30B-A3B-abliterated --json \ | jq '.data.primary_method, .data.confidence' "M4" "medium"
The four one-liners each map to a case above. Same key from the environment, same rate limit. Without --json the CLI prints a human-readable table plus a footer with the call's cost; with --json it prints the full envelope (data, cost, credits_remaining, rate-limit fields), so your jq paths start at .data, exactly as they would on a raw curl call. The CLI wraps the API without adding surface area, which makes it the right tool when you want to look before you decide which language to write in. Nothing to install beyond one npm package.