The weights are open, the licence is not

😁 Hello, super humans! “Open weight” has quietly stopped meaning one thing. This weekend a frontier-class Chinese model landed on Hugging Face with a licence that reads fine for you, fine for your startup, and awkward for anyone with a data centre. That distinction is about to matter more than any benchmark, so let’s read the licence like engineers.

📰 Quick Signals

• 🧠 AI: Alibaba released Qwen3.8-Flash and described it as an early preview of the architecture that will ship as Qwen4, which makes it the closest look anyone outside the lab has at that generation.
• 🤖 Robotics: Locus Robotics bought Nexera Robotics for its NeuraGrasp soft-picking stack, which Nexera says can grasp everything from rigid containers to porous polybags and loose cloth, the exact long tail that breaks warehouse manipulation.
• 💻 Programming: AWS added an Express Mode to ECS that provisions the load balancer, networking and scaling policy around a container for you, aimed squarely at teams who wanted a container to just be reachable.
• ⚡ Electronics: designer Simon Weckert published a wearable fabric pattern tuned to break person-detection models, which works against the algorithms he tested and makes you extremely visible to every human in the room.
• 📡 Telecom: Ookla split US 5G fixed wireless results by census urban and rural classification for the first time and found rural median download speeds lower by 26 to 49 Mbit/s across AT&T, T-Mobile and Verizon, with latency 7 to 13 ms worse.

🔍 The Big Story: An open-weight model with a revenue gate

If any part of your stack runs open weights, this is the week the terms changed under you. The model is still downloadable, still fine-tunable, still commercially usable. The licence just grew a clause that sorts users by revenue.

What happened: on Friday, Chinese lab Z.ai published the weights for its flagship GLM-5.3 on Hugging Face. Its predecessor GLM-5.2 shipped under the MIT licence. GLM-5.3 ships under a bespoke “GLM-5.3 License” with one significant caveat, first picked apart by The New Stack: any company that wants to host the model, as opposed to routing it or embedding it in a product, and that has more than 10 billion dollars of aggregate revenue over any 12 consecutive months, must pass Z.ai’s own security review before commercial use. Z.ai also held the weights back for two weeks after the API launch for what it calls safety evaluation, which is new; GLM-5.2’s weights shipped on launch day.

The details: the model itself is unchanged from GLM-5.2’s shape, a 753 billion parameter mixture-of-experts with a 1 million token context window and a 128,000 token maximum output. Weights ship in BF16 and FP8 and run on vLLM, SGLang, KTransformers and Transformers. Practically, “open weight” here does not mean “runs on your desk”: Unsloth’s 2-bit quantisation still needs 245 GB of memory, which just fits a 256 GB unified-memory Mac, and the 8-bit build wants 810 GB. API pricing is 1.40 dollars per million input tokens and 4.40 per million output, with the Flash variant at 0.15 and 0.47 and still under MIT.

The safety framing deserves scrutiny. Z.ai says GLM-5.3 scores 84.5 percent on CyberGym, a vulnerability-discovery benchmark, and that it used the model to find 2,436 vulnerabilities across 269 open-source projects including the Linux kernel. Both numbers are self-reported, only a few dozen findings are publicly inspectable, and the licence itself contains no acceptable-use section and says nothing at all about offensive security. A licence that gates on revenue rather than on use is a commercial instrument wearing a safety jacket.

flowchart TD
    L["Z.ai: trains GLM-5.3, 753B MoE"] --> W["Weights published on Hugging Face"]
    W --> G{"Who are you?"}
    G -->|"Individual or small company"| A["Run, fine-tune, deploy, sell: no extra terms"]
    G -->|"Router or embedder<br/>e.g. OpenRouter"| B["Not classed as hosting: no gate"]
    G -->|"Host with >10B USD revenue<br/>over any 12 months"| C["Must pass Z.ai security review first"]
    W --> N["Repo may soon be owned by Nvidia"]
    B --> S["Marketplace may soon be owned by Stripe"]

Zoom out and the shape is uncomfortable. If the Nvidia acquisition of Hugging Face and the Stripe acquisition of OpenRouter both close, the repository where developers download open models and the marketplace where they rent them will both be American-owned, while an increasing share of the models themselves come out of Chinese labs that now attach terms. Z.ai kept MIT for Flash, so this is not a wholesale retreat; it is the best model being fenced while the cheap one stays free. Moonshot’s Kimi K3 licence only demands attribution above 100 million users or 20 million dollars of monthly revenue, and DeepSeek still ships MIT, so this is Z.ai moving first rather than an industry norm.

🗞️ More News

🧠 AI

• Sony Music Publishing, Warner Chappell and other publishers sued Anthropic and co-founders Dario Amodei and Benjamin Mann, alleging a campaign of intellectual-property theft in training Claude.
• Developers are split on whether GLM-5.3’s jump is industrial-scale distillation of other labs’ models or careful benchmark targeting, which is the argument sitting underneath today’s licence story.
• Following this week’s acquisition news, the argument for Nvidia’s 12.9 billion dollar Hugging Face bid is that it is paying to keep open models running on its own chips rather than anyone else’s.
• An agent called Sai reached 73 percent on OSWorld 2.0, a benchmark made of routine desktop chores rather than clever puzzles, which is the part of agent work nobody demos.
• Replit made automatic model routing the default, so the platform now picks a model per task instead of asking you to.
• A cost breakdown of Anthropic’s Files API concludes it saves you round trips and typing but not tokens, because the file contents still land in the context window.
• At TechBBQ in Copenhagen, European founders and investors kept circling back to a sovereignty question that this weekend’s licence change makes concrete: who controls the model you build on.

🤖 Robotics

• A study of swarm power management argues neither fully centralised charging nor fully decentralised onboard management wins, and that a hybrid is the practical answer for large fleets.
• Deere beat Q3 expectations, raised guidance, and put 10 million dollars into an agtech AI research partnership with Reservoir.
• EXL acquired iMerit, whose business is the labelled physical-world data that robot foundation models are trained on, which is where a lot of the real cost of physical AI sits.
• Hugging Face put out a small open duck robot intended as a teaching platform for reinforcement learning, which is a cheaper entry point than the arms usually used for this.
• Brain Corp’s CTO makes the case that fleet robotics is moving from taught-and-repeated routes to self-planned paths, and that the hard part is not the planner but earning operator trust in it.

💻 Programming

• X sent Nitter a cease-and-desist and then went after the project’s source code, which turns a scraping dispute into a question about hosting the code at all.
• MotherDuck bought Tower, the Python data-pipeline startup already running its own pipelines, on the argument that you can rent a feature but not a foundation.
• A walkthrough of why plain vector RAG collapses on multi-hop questions, and how a graph index fixes the hops that embeddings cannot bridge.
• Agent traces are quietly becoming first-class application data, with retention, schema and query needs that your observability pipeline was not sized for.
• Most coding-agent benchmarks quietly skip large-scale refactoring because it is expensive to grade; one new benchmark does not.

⚡ Electronics

• With component prices where they are, one builder skipped buying storage and built a 12-slot robotic microSD card library instead, on a T-bot gantry with a rack-and-pinion gripper.
• Following this week’s memory-price item, the surge is cooling rather than reversing: DRAM contract prices are forecast up 13 to 18 percent quarter on quarter and NAND up 10 to 15 percent in Q3, against roughly 60 percent in Q2.
• IDS Imaging added the Nion indirect time-of-flight sensor to its 3D camera line, combining a global shutter with pixel-internal memory so depth holds up at real process speeds.
• A Hackaday Europe talk on treating the PCB itself as a communication medium, where the copper pour carries the story and not just the current.

📡 Telecom

• Nokia’s former CTO went public against cuts at Bell Labs, calling the reductions shocking for an institution whose value was never measured in quarterly output.
• Denmark’s TDC Net reported first-half results dented by copper decline, a reminder that switching off the old network costs revenue before the fibre replaces it.
• GoNetspeed is expanding its fibre build into more of New York and New Jersey, part of the slow grind of overbuilding cable in the north-east.
• Zayo was named a prime awardee on NASA’s SEWP VI contract vehicle, which is how a lot of federal network capacity actually gets bought.

👨‍💻 Code Corner

Before you spend an hour downloading 753 billion parameters, work out whether the machine can hold them. The arithmetic is just parameter count times bytes per parameter, plus room for the KV cache and the layers that stay in higher precision.

# Can I actually serve this model? Rough memory sizing for a quantised LLM.
GIB = 1024 ** 3

def weight_bytes(params: int, bits: int) -> float:
    return params * bits / 8

def serving_footprint(params: int, bits: int, overhead: float = 1.30) -> float:
    """overhead covers KV cache, activations and non-quantised layers."""
    return weight_bytes(params, bits) * overhead / GIB

GLM_53 = 753_000_000_000

for bits in (2, 4, 8, 16):
    raw = weight_bytes(GLM_53, bits) / GIB
    need = serving_footprint(GLM_53, bits)
    print(f"{bits:2d}-bit  weights {raw:7.1f} GiB   serve on ~{need:7.1f} GiB")

The 2-bit row prints 175.3 GiB of weights and about 227.9 GiB to serve, which is the same neighbourhood as the 245 GB Unsloth publishes for its 2-bit build, and it tells you in one second that a 128 GB workstation is not in the running.

🧰 Toolbox

• GLM-5.3 model card: the weights and the new licence in one place, and the licence file is the part worth reading before the benchmarks.
• Unsloth GLM-5.3 quant guide: the published memory figures per quantisation level, including the claim that the 2-bit build holds about 86 percent top-1 accuracy.
• vLLM docs: one of the four runtimes the GLM-5.3 weights ship for, and the fastest way to find out whether your GPU layout can hold a mixture-of-experts model.
• Ookla US FWA rural and urban report: the underlying data behind today’s telecom signal, useful if you are sizing an application for customers on fixed wireless.
• Digital Camouflage: the project page for the anti-detection fabric, with the test images, and a good conversation starter about adversarial patterns.
• Library for Ants: the build log for the robotic microSD library, worth a skim for the T-bot kinematics and the gripper redesign.

🎬 Demo Watch (rotating)

A 3D printed piano action, built from compliant mechanisms

A piano action is a small mechanical computer. One key press has to control hammer velocity, let the hammer fly free before it hits the string, catch it on the rebound so it does not bounce back into the string, allow a fast repeated strike, and damp the string on release. Real actions do this with dozens of hinged wooden parts, and the design took roughly 150 years to settle.

The builder, dovetail, replaced the hinges with compliant mechanisms: single printed parts that flex in controlled ways instead of pivoting on pins. That is the hard bit, because the feel of an action comes from the interaction of several tuned masses and pivots, and a flexure has to reproduce that response with a different physics. The keys are modular, with daisy-chained PCBs behind each group, and infrared sensors turn it into a MIDI controller, so this is a hybrid: real action, digital sound.

What is real: the mechanism works, musicians played it at Open Sauce, and the modular approach is genuinely reusable. What is still rough: infrared sensing is being swapped for hall effect, and the filament choice is unresolved, which is a polite way of saying the flexures will eventually fatigue. Worth watching if you have ever wanted a case study in trading part count for material behaviour.

📚 From the Blog

• Turning Pixels Into Something the AI Can Eat: the preprocessing stage between a sensor and a model, and the pipeline you have to size before you argue about which model to run in it.
• Building Your First Neuron From Scratch: weights, bias, activation and one gradient step by hand, which is the honest version of the parameter counts in today’s big story.
• The Network Behind the Cameras: the unglamorous plumbing that moves video across a network without melting the switch in the middle.

😀 The Bot Says…

A frontier model went “fully open weight” this weekend, and to exercise your freedom you need 245 GB of RAM, a licence lawyer, or ideally both. Open source used to mean you could read it. Now it means you could read it if you had somewhere to put it.

---

That’s all for today! Reply and tell us which model licence in your stack you have actually read end to end, because the honest answer is usually zero and that was fine right up until this week.