Following the release of Kimi K3, Axios reported that the administration is reviving a push to restrict Chinese models on cybersecurity grounds, with Entity List designations under discussion and House committees probing the American companies that run them.[1] The explainer wave arrived within the news cycle: what open weights are, why enterprises quietly run them, which Chinese models to worry about, and the same comparison table in a hundred fonts. Much of it reads as if the subject were discovered at roughly the moment it hit 46.4% of routed traffic on OpenRouter.[2] Benchmarks, market share, comparison: the wave runs on one axis, and it is the wrong one.
Being late is forgivable; I would rather people learn about open models now than never. The problem is that it is not just late; it is describing an object from an era that ended eighteen months ago. So let me set the record straight, from the beginning, because I was there for it.
In March 2021, I published a post on the AWS machine learning blog announcing a partnership between Amazon and a startup most enterprise readers had never heard of. Hugging Face, founded in 2016 and with offices in New York and Paris, made it easy to add Transformer models to your applications. The catalog held about 7,000 pre-trained models in 164 languages. The examples I reached for were BERT (340 million parameters) and GPT (175 billion).[3]
Read that post today, and the striking thing is what it does not contain. There is no comparison. No table weighing an open model against a proprietary API, no paragraph on cost per token, nothing on privacy or lock-in. There was nothing to compare against. The problem the partnership existed to solve was more basic: most organizations could not deploy these models at all. Getting the file onto managed infrastructure with a few lines of code was the entire value proposition.
Three eras
Open models have changed what they are three times, and each era is defined by the question practitioners were asking.
In the distribution era, roughly 2021 to 2022, the question was:how do I run this at all?The achievement was deployment. The infrastructure that mattered was hubs, containers, and managed endpoints, and the partnership I announced was that infrastructure being built.
ChatGPT ended the first era in a weekend. Deployment stopped being the hard part because the incumbent had arrived, and in the comparison era, 2023 to 2024, the question became:Why would I use this instead of the API?Open models had a proprietary incumbent to displace, so every argument became a table: transparency versus opacity, cost versus convenience, control versus capability. I spent two years making that argument, and I will show you my own exhibit below.
The third era had been building quietly since 2023, in preference-tuning papers and merge experiments, while the comparison arguments still held the stage. It blew into public view in January 2025, when DeepSeek shipped R1, trained with a reinforcement learning algorithm the lab published, alongside a family of smaller models distilled from it. In the post-training era, the question changed again, and most people have not noticed, because the era’s arrival, like the first era’s ending, was a visibility event: the work predated the moment.The question is no longer which model to pick. It is what to make from the models you hold.Open models stopped being products that compete with closed ones and became checkpoints: fine-tuned, aligned, distilled, merged, transplanted, and quantized, both inside the labs that release them and on hardware that fits on a desk. Training no longer ends where the download begins.
Open models are not a substitute for closed ones. They are a different kind of object, and every era of their history has been a discovery of what that object permits.
For the record: I was at AWS during distribution, at Hugging Face during comparison, and at Arcee AI, the company behind the MergeKit toolkit, during post-training. My career is how I noticed the eras. It is not the evidence, which is other people’s published work throughout.
This piece is for teams with the engineering capacity to act on that. If your organization has no machine learning function, the hosted service is the right purchase, and nothing below changes it. But if you are arriving at open models now, through the current wave of explainers and best-of lists, you are being taught the second era’s answer to the third era’s question. You should know what this era looks like, from someone who watched all three arrive.
The comparison era, from inside
In September 2023, as Chief Evangelist at Hugging Face, I published a comparison of SafeCoder, our enterprise code assistant, against the closed-source alternatives.[4] It made five arguments. The model was state-of-the-art. It was transparent: you could read the paper, inspect the training dataset, and check whether your code was in it, since the dataset shipped with an opt-out tool for repository owners.[5] You could fine-tune it yourself in your code. You could run it anywhere, including in an air-gapped environment. And it phoned nothing home.
I stand by every line, and the post has aged into a period piece anyway. Not because the claims failed, but because theformdates it. Five properties, each argued against a closed-source counterpart. The piece is a table wearing prose, and the table was the era. Open models were the challenger, the incumbent set the terms, and everything we wrote had to justify the open choice against the closed default.
The comparison era did real work. It established that open models were viable for serious deployment, it forced pricing discipline on the incumbents, and its arguments about privacy and control were correct and remain correct. What it could not do was describe properties with no counterpart on the other side of the table. A comparison can only hold what both columns share. The operations that define this era were invisible to the format: not suppressed, just unrepresentable.
Which is why, if you learned open models from the comparison literature, the current era will sound like it happened somewhere else. It did not. It happened inside the models you are being recommended.
The post-training era: where the models come from
Here is what the era’s best-of lists do not say about the models on them: nearly everything that makes them good happened after pre-training. Supervised fine-tuning, preference training, reinforcement learning, distillation from a larger teacher, and increasingly merging. The base run buys the raw capability; the post-training stack turns it into the model you download.
The stack starts earlier than most descriptions admit. Continued pre-training, sometimes called mid-training, takes a released checkpoint and keeps feeding it raw text: Code Llama is Llama 2 with its pre-training continued on a code-heavy corpus, and SEA-LION’s pipeline begins by continuing pre-training on Southeast Asian text before any of the stages below.[6] A checkpoint is not a finished artefact with a tuning knob. It is a training run; somebody paused, and anyone holding the file can press resume.
The alignment layer opened first, and the progression is worth spelling out because it is the era in miniature. In 2022, preference training meant RLHF as the closed labs ran it: proximal policy optimization, a learned reward model, a critic network, and infrastructure that almost nobody else could operate. In 2023, direct preference optimization collapsed all of that into a single loss function that runs wherever fine-tuning runs, and Zephyr showed a 7-billion-parameter open model beating much larger chat models on supervised fine-tuning plus DPO alone.[7] In late 2024, AI2’s Tülu 3 published a complete open post-training recipe, including data, code, and weights, and introduced reinforcement learning from verifiable rewards: checkers instead of learned reward models.[8]
Then, DeepSeek’s GRPO (group relative policy optimization), the algorithm behind R1, deleted the critic network that made the RL loop expensive, and within weeks of R1’s release, the open community was replicating the pipeline publicly.[9] Each step removed a piece of infrastructure only a frontier lab could afford, until the whole alignment stack ran in open frameworks, with the small-model end reaching consumer GPUs.[10]
Merging is the newest layer of that stack, and it is already inside the models the guides recommend. Meta’s Llama 3.1 report describes averaging models at every post-training stage across reward modeling, supervised fine-tuning, and DPO, and using the flagship to improve its smaller siblings.[11] Cohere’s Command: A technical report calls expert merging a core feature of its training pipeline: domain experts trained separately, then folded into a single set of parameters.[12]
Much of that is averaging variants of a single pipeline. Merging separately trained models into a single set of weights was adopted from papers and released systems in 2025.[13] In March, a team from Qiyuan Tech and Peking University distilled DeepSeek-R1 into three domain experts for mathematics, coding, and science, then merged them with Arcee Fusion, from Arcee AI's MergeKit toolkit, landing within two points of the 671-billion-parameter teacher on AIME mathematics. The merge took 4 GPU-hours, compared with 740 for retraining on mixed data, which the authors call a free lunch, published from the far side of the boundary the ban debate is trying to draw. SEA-LION, AI Singapore's national language family, runs multiple DELLA Linear merge stages in the pipeline behind its shipped models.[16] And the field is not fringe: merging has a survey in ACM Computing Surveys, and the toolkit's paper sits in the EMNLP industry track.[17][18]
So the technical reports describe merging as routine, the lists recommend the models that those reports document, and the word appears in neither. A newcomer can read guide after guide and never learn that the operation exists, let alone that it built the thing they just downloaded.
The post-training era: on your desk
The same operations run downstream, and the hardware to run them arrived recently enough that most of the literature predates it.
One calibration first, because the era has a gradient, and you should know where you stand on it. Quantization and distillation are the mass operations: anyone running a model through Ollama is running quantized weights, today, probably without thinking of it as a weight-space operation at all. Fine-tuning is common. Merging and surgery are where the frontier is, not where the median is. The era is defined not by everyone doing everything, but by the possibility of it all with a single object.
The practitioner’s toolkit is six operations, and the everyday ones come first.
Fine-tune a model on your own data: low-rank adaptation runs on a single consumer GPU, and the output is an adapter file measured in megabytes that you keep, copy, and load anywhere.
Distil a large open model into a small one whose weights you own; an open teacher is a teacher you are allowed to keep, where a closed vendor’s terms typically forbid training a competitor on its outputs. NVIDIA went further and released the Nemotron-4 340B family under a licence that explicitly permits generating synthetic training data, because data generation is now a post-training stage in its own right.[19]
Align it: DPO runs wherever fine-tuning runs, and GRPO-style reinforcement learning, critic deleted and rewards drawn from verifiable checkers, now runs in open frameworks on consumer GPUs; I examined the compute shape of that workload inThe Verification Tax.
Merge models into a new one.That operation needs no training run, no rented cluster, and no data; for small models, it runs on a CPU or eight gigabytes of video memory, and lazy tensor loading keeps even large merges on modest hardware.[20]
Transplant components between models: MergeKit ships a tool that moves one model’s tokenizer into another, and in its published cross-family test, the underlying technique retained roughly 96% of language-understanding performance with no training at all.[21]
Quantize: reduce numerical precision to trade quality for footprint at a point you choose.
Quantization is the bridge between owning weights and using them, and its arithmetic is blunt. Qwen3.5-397B, a 397-billion-parameter mixture-of-experts model from one of the Chinese families reportedly under discussion in Washington, is roughly 807 gigabytes on disk at full precision: a rack, full stop. At dynamic four-bit, it is about 214 gigabytes and loads on a single Mac Studio. At three bits, it fits a 192-gigabyte machine, and the quantizer’s own guidance now recommends two-bit dynamic variants as a legitimate operating point rather than a last resort.[22] The same weights span a data center and a desk, and where on that curve you sit is your decision, not a vendor’s. The community quant tables even publish the far end with honest labels: the one-bit files are marked “for the desperate”.[23] That is what a continuous curve looks like: it goes all the way down, and it tells you the quality price at every stop. And the desk changed too.
Consumer graphics cards stop at 24 or 32 gigabytes of memory, and a model that does not fit does not run.[24] Unified memory architectures remove that ceiling by pooling system and graphics memory. Apple established the pattern. AMD’s Strix Halo platform puts 128 gigabytes of unified memory in mini-PCs selling for roughly $2,000, with AMD’s own developer machine at $3,999, and Nvidia sells its own 128-gigabyte unified-memory developer box, the DGX Spark, at the same price. The company unveiled the platform at CES in January 2026, claiming it could run models with up to 200 billion parameters locally.[25] The trade is bandwidth: a discrete card moves memory several times faster, which is what generation speed depends on, so small models run faster on the card while large ones only run on the pool. Mixture-of-experts models bend the curve further by activating only a fraction of their parameters per token, letting a far sparser model outrun a dense one on the same machine.[26]
And weight surgery is quietly becoming a production dependency, not an enthusiast’s hobby. Speculative decoding, the serving optimization in which a small draft model runs ahead of a large one, is recommended in current deployment guides and implemented in vLLM, which, by default, requires that the draft and the target share a vocabulary.[27] For a model with its own vocabulary, no compatible draft exists, and building one traditionally means returning to the training stage.[28] The cheap route is the transplant operation above; the heavier one is training a small drafting head, EAGLE-style, directly onto the frozen checkpoint, which is likewise an operation on weights you must hold.[29] Microsoft Foundry’s import screen now has a dedicated slot for draft models.[30] The platform assumes you arrive holding one. None of the guides I read mentions that the slot exists or that weight surgery is how it's filled.
Where the checkpoint beats the frontier
The frontier labs post-train for everyone on average. A checkpoint post-trained for one domain beats them on that domain, and the clearest demonstrations now come from companies you know.
Cursor, one of the companies the House is reportedly asking about, built Composer, the model behind its agent, by training a mixture-of-experts model via reinforcement learning across hundreds of thousands of sandboxed coding environments. According to the company’s benchmarks, it achieves frontier coding results at 4x the generation speed of comparably intelligent models.[32] The base is widely reported to be an open checkpoint, a question Cursor’s researchers pointedly decline to answer, which tells you what a checkpoint’s provenance is now worth.[33]
Salesforce fine-tuned its xLAM family on synthesized tool-use data and took first place on the Berkeley Function-Calling Leaderboard, ahead of GPT-4 and Claude 3, with models a fraction of their size.[34]
And Baichuan post-trained a 32-billion-parameter medical model using a staged GRPO recipe against a clinical verifier. On HealthBench, OpenAI’s own medical benchmark, M2 beat every open model and most closed ones, including o3 and Gemini 2.5 Pro, and at release, it was the only model other than GPT-5 to clear 32 on the Hard subset. Quantized, it deploys on a single RTX 4090.[35]
Three domains, three of the six operations, three names your board recognizes. None of these teams out-trained the frontier in general, and none needed to. They picked an axis, fine-tuned a checkpoint on it, and kept the axis.
Why the literature lags
If the post-training era is real, why is the “Open Models 101” wave still writing comparison-era explainers? Mostly because that is what explanation is. The genre exists to introduce open models to people arriving from closed APIs, and introducing the unfamiliar means comparing it to the familiar. A comparison can only hold properties both sides share: price, privacy, control, and latency each take a value on both sides, so each gets a row. Continued pre-training, merging, and weight surgery have no closed-form counterparts, so no rows exist for them, and they go unwritten. The blog posts, the press explainers, and the analyst notes all inherit the format, whoever writes them.
The commercial guides could break the frame, because their authors run these operations for a living. They do not, and the pattern is instructive. I read four guides closely: an inference platform, a GPU renter, a desktop-app maker, and an independent author. Each goes deep on exactly one production capability, the one it sells. Preference optimization and RL fine-tuning appear in none of them, and neither does merging, which nobody sells.[36] Merging needs no rented compute, no serving contract, no application. The comparison frame explains the wave. The billing pattern explains why even its deep end never corrects its shallow end.
The obvious objection is that if these operations mattered, the closed vendors would sell them. They did. OpenAI shipped a complete distillation workflow in its API in October 2024, and Google, Anthropic, and AWS offer their own distillation paths.[37] What they sell is the operation, never the artifact. OpenAI now even releases open-weight models of its own; what it does not release is the adapted weights from your fine-tuning of its hosted models. The fine-tune lives behind the API, and Microsoft’s documentation for the equivalent Azure workflow states plainly that the stored training data cannot be exported or downloaded.[38]
The operations arrived. Nothing came out. And the hosted route delivers real results: published distillation numbers report 14-24 times lower cost per successful task than frontier calls.[39] What the buyer owns afterward is a result, not a model; it cannot be merged, quantized, or moved, and it lives only as long as the vendor’s base.
The platforms noticed the same thing, and what they built is the clearest statement of what this era is worth. Amazon Bedrock ships Custom Model Import, generally available since October 2024, which accepts weights in the Hugging Face format: Llama, Mistral, Qwen, and, since last November, OpenAI’s own open-weight models.[40] Google Vertex accepts custom weights. Microsoft Foundry accepts full models, adapters, and draft models.
Study those import screens for a moment. Every major platform built a door for the model file to come in. None of them built one facing out. You can bring a merged model to all three hyperscalers; you cannot take a fine-tune of their own models away from any of them. The companies that run the largest AI infrastructure in existence have priced what a file in hand is worth, and their answer is a one-way door.
So the question to take away from this piece is not the question of the era being compared. Not which model is best, and not even open versus closed. The question is what you will make from the thing you hold. And it is the right question because the models are now made that way, the tools run on a desk, and the explainers who cannot tell you so are still writing inside a frame built for the era before.
Washington, incidentally, is learning the same lesson from the opposite direction. The reported ban keeps colliding with the property this piece is about: the weights are files, already on disks in their millions, and legal analysts note that restricting publicly available model weights raises constitutional questions a service ban never would.[41] Whatever the security merits of the case, and the security findings are not trivial,[42] the policy difficulty is the object lesson. You can sanction a company and geo-block a service. A file that has shipped is neither, which is presumably why the instruments reportedly under discussion are Entity List designations, procurement rules, and liability: tools that reach companies and contracts, because nothing reaches the file.
And I should say plainly that the capability this piece describes cuts both ways: the same weight access that lets a practitioner transplant a tokenizer lets anyone strip a model’s safety training, an operation I examined inOpen From Both Sides. Weight access is not a virtue. It is a property, and properties do not pick sides.
So here’s my one-line “open models 101”: An open model shouldn’t be a finished product that you pick. It should be a training run you resume.
Notes
[1] Axios,“The secret Trump administration battle to fight Chinese AI”, 20 July 2026; see also Tom’s Hardware,“Trump administration reportedly reviving push to ban Chinese AI models following Kimi K3 launch”, 22 July 2026. No executive order signed as of this writing; the Commerce Department reportedly evaluated Entity List designations; House committee probes of US firms using Chinese models reported July 2026. All characterisations “reportedly” per the sourcing.
[2] Chinese models at 46.4% of routed token traffic onOpenRouterversus 35.7% for US models, DeepSeek at 17.6% alone, as of July 2026, per theAxiosreporting and contemporaneous coverage. OpenRouter routes a developer-heavy slice of traffic; treat the shares as indicative of that population, not of the whole market.
[3] Simon,“AWS and Hugging Face collaborate to simplify and accelerate adoption of Natural Language Processing models”, AWS Machine Learning Blog, 23 March 2021. Figures as published: ~7,000 pre-trained models, 164 languages, BERT at 340M parameters, GPT at 175B.
[4] Simon,“SafeCoder vs. Closed-source Code Assistants”, Hugging Face blog, 11 September 2023.
[5] The StarCoder base models were trained on The Stack (2.7 TB, permissively licensed code), published with an opt-out mechanism for repository owners. Li et al.,“StarCoder: may the source be with you!”, arXiv:2305.06161.
[6] Rozière et al.,“Code Llama: Open Foundation Models for Code”: Llama 2 with continued pre-training on a code-heavy corpus. SEA-LION’s continued pre-training stage per its technical report (see the SEA-LION note above). Continued pre-training at useful scale consumes billions of tokens of compute; it is the heaviest operation in this piece and the one with the highest floor.
[7] Rafailov et al.,“Direct Preference Optimization: Your Language Model is Secretly a Reward Model”, NeurIPS 2023; Tunstall et al.,“Zephyr: Direct Distillation of LM Alignment”, the Hugging Face H4 recipe pairing SFT with DPO.
[8] Lambert et al.,“Tülu 3: Pushing Frontiers in Open Language Model Post-Training”, Allen Institute for AI, November 2024. Full recipe, data and weights released; introduces reinforcement learning with verifiable rewards (RLVR).
[9] GRPO: Shao et al.,“DeepSeekMath”, which introduced group relative policy optimisation; DeepSeek-AI,“DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning”, January 2025. GRPO computes advantages within a sampled group, removing the separate critic network. Community replication: Hugging Face’sOpen R1.
[10] Open post-training frameworks include Hugging FaceTRL(SFT, DPO and GRPO trainers), ByteDance’sverl, andOpenRLHF; consumer-hardware GRPO recipes ship inUnsloth.
[11] Grattafiori et al.,“The Llama 3 Herd of Models”: models from experiments with different data and hyperparameters are averaged at each reward-modelling, SFT and DPO stage; checkpoint averaging is also applied during pre-training annealing, and the flagship model is used to improve the smaller models in post-training.
[12] Cohere,“Command A: An Enterprise-Ready Large Language Model”: “Expert merging is a core feature of the Command A training pipeline”, alongside Polyak and seed averaging and interpolation for capability recovery.
[13] Three grades of the operation, in ascending difficulty. Averaging variants produced by one pipeline under different data or hyperparameters: Llama 3.1 and Command A above. Merging separately post-trained branches that share an ancestor: TinyR1’s three domain experts and SEA-LION’s DELLA stages, below. Cross-family merging between unrelated bases: requires tokenizer transplantation when vocabularies differ (note 21) and remains largely research territory (note 14). The 2025 exhibits in this piece are the second grade.
[14]“A Systematic Study of In-the-Wild Model Merging for Large Language Models”, arXiv:2511.21437. Six methods, four base models, twelve checkpoints each, sixteen benchmarks.
[15] Sun et al.,“TinyR1-32B-Preview: Boosting Accuracy with Branch-Merge Distillation”. Qiyuan Tech and Peking University. Branch phase: domain-specific SFT of DeepSeek-R1-Distill-Qwen-32B on math, coding, and science data. Merge phase: Arcee Fusion (Goddard et al., 2024). AIME 2024: 78.1 versus DeepSeek-R1’s 79.8. Merge cost: 4 H800 GPU-hours versus 740 for data-mixture retraining; the paper reports using 0.5% of the data-mixture merging compute and describes model merging as “a ‘free-lunch’ approach”.
[16] AI Singapore,SEA-LION technical report, arXiv:2504.05747. Post-training pipeline for Gemma-SEA-LION-v3-9B-IT: two instruction-tuning stages, alignment, and multiple merge stages using DELLA Linear.
[17] Yang et al.,“Model Merging in LLMs, MLLMs, and Beyond: Methods, Theories, Applications and Opportunities”, ACM Computing Surveys, 2026.
[18] Goddard et al.,“Arcee’s MergeKit: A Toolkit for Merging Large Language Models”, EMNLP 2024 Industry Track, pp. 477–485. The author served as Chief Evangelist at Arcee AI until November 2025 and holds no current commercial relationship with the company.
[19] NVIDIA,“Nemotron-4 340B”, released under the NVIDIA Open Model License permitting synthetic data generation for training other models.
[20]MergeKit repository, hardware requirements per repository documentation (accessed 23 July 2026).
[21]“Breaking Down Model Vocabulary Barriers with Tokenizer Transplantation”, arXiv:2506.06607. Orthogonal matching pursuit reconstruction of embedding matrices; ~96% retention across model families, training-free.
[22]Unsloth documentation, Qwen3.5-397B-A17B: ~807 GB full checkpoint; ~214 GB at Unsloth dynamic 4-bit (UD-Q4_K_XL), loadable on a 256 GB M3 Ultra; 3-bit fits 192 GB systems; 2-bit dynamic (UD-Q2_K_XL) recommended by Unsloth as a size/accuracy balance. Via MoE offloading, runs on a single 24 GB GPU plus 256 GB system RAM at 25+ tokens per second. Unsloth documentation, July 2026. Performance-tier comparison to closed frontier models is Unsloth’s claim; vendor-adjacent, label accordingly. File sizes are directional and vary by quant build.
[23] Community GGUF quantization tables (mradermacherand similar) publish the full precision ladder with quality annotations; the 1-bit IQ1 entries carry the label “for the desperate”.
[24] 24 GB: RTX 3090/4090, RX 7900 XTX. 32 GB: RTX 5090. Manufacturer specifications.
[25] AMD Ryzen AI Max+ 395 (”Strix Halo”): 128 GB unified LPDDR5X. Platform unveiled in Lisa Su’s CES keynote, 5 January 2026; AMD’sCES press releasedescribes the Ryzen AI Halo developer platform as “capable of running up to 200 billion parameter models locally”, with the developer machine at $3,999. Third-party 128 GB mini-PCs sell for roughly $2,000 street as of July 2026; the widely quoted ~$1,499 entry units carry 64 GB and cannot load the largest models. Street prices vary by configuration.
[26] Sparse mixture-of-experts models activate a fraction of parameters per token, so decode cost tracks active rather than total parameters; for a concrete instance of a very large MoE running on modest hardware via offloading, see the Qwen3.5 figures in note 10.
[27]vLLM speculative decoding documentation: draft and target models must share a vocabulary by default. A heterogeneous-vocabulary path (token-level intersection) exists with ~60% reported acceptance for overlapping vocabularies.
[28] TokenTiming,arXiv:2510.15545, on the shared-vocabulary constraint and the training-stage cost of aligned draft models.
[29] Li et al.,“EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty”. EAGLE-class draft heads train against the frozen target model’s features; the vLLM documentation in note 27 lists EAGLE and MTP among supported speculative methods.
[30]Microsoft Foundry custom model import, running on the Fireworks inference runtime within Foundry: full weight models, LoRA adapters (preview), draft models for speculative decoding (preview). Documentation, June 2026.
[32] Cursor,“Composer: Building a fast frontier model with RL”, October 2025. Cursor’s own comparison places Composer at frontier coding results with roughly four times the generation speed of comparably intelligent models, while noting GPT-5 and Sonnet 4.5 outperform it on raw score.
[33] Simon Willison,notes on Composer: Cursor researchers declined to say whether Composer starts from an open-weights base such as Qwen or GLM; reporting has widely inferred an open checkpoint. Cursor is also among the US companies House committees have reportedly queried over Chinese-model use; seeTechTimes.
[34] Zhang et al.,“xLAM: A Family of Large Action Models to Empower AI Agent Systems”, Salesforce AI Research: first position on the Berkeley Function-Calling Leaderboard at the time, outperforming GPT-4 and Claude 3 on tool use;repository. Leaderboard positions have since shifted with newer versions of the benchmark.
[35] Baichuan,“Baichuan-M2: Scaling Medical Capability with Large Verifier System”: 32B model trained with multi-stage GRPO against a patient-simulator verifier; above 32 on HealthBench Hard, previously exceeded only by GPT-5; surpasses o3, Grok 3, Gemini 2.5 Pro and GPT-4.1 on HealthBench; near-lossless quantisation deploys on a single RTX 4090.
[36] Sample of four current guides read in full, selected for variance in author business model:BentoML(inference infrastructure; June 2026),Thunder Compute(GPU rental; July 2026),LocalChat(local desktop application; June 2026), andan independent authoron the Hugging Face community blog (November 2025). Coverage pattern as described; merging absent from all four. Sample and selection logic stated in the interest of checkability.
[37] OpenAI,“Model Distillation in the API”, 1 October 2024: Stored Completions capture frontier-model outputs as training data for fine-tuning smaller models, inside the platform. On rival offerings:InfoWorldnotes Google, Anthropic and AWS provide distillation capabilities.
[38] Microsoft Learn,Azure OpenAI stored completions and distillation: “Stored completion distillation training files cannot be accessed directly and cannot be exported externally/downloaded.” The page documents the classic workflow, which Microsoft schedules for migration to the Responses API in October 2026; the export restriction is as stated as of July 2026.
[39] TensorZero,“Distillation with Programmatic Data Curation”: fine-tuned small models at 13.7x (GPT-4o mini) to 24.1x (Gemini 2.0 Flash Lite) lower cost per successful task than GPT-4o across their evaluation environments. Vendor-published benchmark, B-tier.
[40] Amazon Bedrock Custom Model Import,generally available 21 October 2024;Qwen architectures added 11 June 2025;OpenAI gpt-oss added 19 November 2025. GA 21 October 2024, Hugging Face safetensors format; Qwen support added 11 June 2025; OpenAI gpt-oss support added 19 November 2025. Google Vertex AI custom weights import. Microsoft Foundry custom model import (note 21).
[41] Representative commentary:Fast Companyon the unresolved form and reach of any restriction, andTom’s Hardwareon enforceability of restrictions on downloadable weights. B-tier commentary on a live policy question.
[42] Booz Allen Hamilton,“What’s in America’s Code?”(May 2026): in 2,800+ trials across roughly 460,000 lines of generated code, three of four Chinese code-generation models produced significantly more vulnerable code when the prompt identified the user as working for the US government; Qwen3-Coder added roughly 130% more vulnerabilities under the government persona. Booz Allen states its evidence stops short of showing backdoors or deliberate insertion. The security concern is empirically grounded; this piece takes no position on the policy response.