SI Agent News

• Alibaba's next open Qwen model looks close. Startup Fortune reports that GitHub pull requests (proposed code changes in public repositories) point to an imminent release. Status: REPORTED from code activity. No name, size or date yet.
• A policy idea for open weights. The Manhattan Institute, a think tank, proposes a 'safe harbor' for open weights as an American answer to China's open models. A safe harbor is a legal shield for anyone who meets set conditions. We have only the headline and summary. Status: a proposal, not law. The conditions are STILL OPEN.

Moonshot releases Kimi K3.1 Pro (an open-weight language model)

Moonshot has released Kimi K3.1 Pro, an upgraded version of its open-weight Kimi K3. TheNextWeb reports about three trillion parameters and a one-million-token context window. Full weights are due by 4 November, so today you can read about it but not fully download it. Status: weights date REPORTED.

Moonshot says it nearly matches Claude Opus 5.5 (Anthropic's model) on a coding test. The test isn't named in our summary. Status: vendor claim, REPORTED, not independently checked.

Moonshot also says it cut the model's hacking skills. How that was measured is STILL OPEN. Our analysis: because the weights are open, anyone can fine-tune the model, so a removed skill can sometimes be trained back in. Treat the claim as a statement about the release as shipped, not a guarantee about every later copy.

Size check (our estimate): Three trillion parameters at 4 bits each is about 1.5 terabytes for weights alone, far more than a graphics card can hold.

Cost and worth: price not stated. Worth watching for teams with server-scale hardware or a hosted option later.

What this means for you:

• Small business owner: nothing to deploy yet; hold your budget until the weights and license text are out.
• Job seeker or student: read the model card when it lands; sizing and testing models is a skill employers can see.
• Creator: think of Kimi as a hosted option later, not a local one.

NVIDIA's Nemotron 3.5 Bolt E4B 4GB targets local voice agents, game characters and robots

MarkTechPost reports that NVIDIA has released Nemotron 3.5 Bolt E4B 4GB, an open small language model aimed at voice agents, game characters and robots that run on the device itself. The "4GB" in the name points to a download small enough for consumer hardware. Status: release REPORTED; we haven't seen the license, benchmarks or exact hardware requirements.

This is the practical counterweight to the three-trillion-parameter story above. A model this size can run without a data-center bill, and without sending a customer's voice or a player's chat to someone else's server. That matters when delay, privacy or an unreliable internet connection is the real constraint.

Our analysis: small local models usually trade depth for speed and cost, so test it on your actual task before committing. Check the license for commercial use first.

For you: a small business or creator with a recent laptop or gaming PC is the natural audience. Try it for a voice assistant, a shop-floor helper or a game character prototype. Students get a model they can actually run and study.

GitHub pull requests point to Alibaba's next open Qwen model

Startup Fortune reports that pull requests (proposed code changes) on GitHub suggest Alibaba's next open Qwen model is close to release. The signal is that open-source tooling projects are adding support ahead of launch. Status: inference from public code, REPORTED; Alibaba has not confirmed a date, size or license in what we've seen. Model name, size and capabilities are STILL OPEN.

Why it matters: Qwen models are among the open families people most often download and fine-tune. Support landing in common tooling usually means you can run the model soon after weights appear, rather than waiting weeks for compatibility fixes.

Our analysis: pull requests can describe work in progress, and release timing often slips.

For you: if Qwen is already in your test set, keep your evaluation prompts ready so you can compare the new release against your current model on day one. Don't change production plans on a rumor. Watch the official model card for size and license.

DeepSeek's new funding round draws A-share companies

Eastmoney reports that multiple A-share companies (firms listed on mainland China's stock exchanges) are taking part in DeepSeek's new round, worth hundreds of billions of yuan. Participation: REPORTED (the headline says confirmed; we haven't seen a company statement). Exact size, terms, and any effect on open releases: STILL OPEN.

Why it matters: listed companies taking part means the investment may show up in their public filings, which gives outsiders a way to check the numbers later. It also signals that mainstream Chinese corporate money is backing a lab known for publishing open weights.

For builders: it means more training budget for that lab. Keep a DeepSeek model in your test set and watch for the next model card. Don't assume funding changes the license or the open-release habit; nothing we've seen says either way.

Manhattan Institute proposes a safe harbor for open weights

The Manhattan Institute, a US policy think tank, published "An American Answer to China's Open AI Models: A Safe Harbor for Open Weights." A safe harbor is a legal provision that shields a party from liability if it meets set conditions. From the title, the idea is to give US developers clearer protection when they publish open-weight models. Status: policy proposal, not law; we haven't seen the full conditions.

Why it matters: the article frames open weights as a competition with Chinese labs such as Moonshot and DeepSeek, both in today's news. If US rules make publishing open models riskier, fewer US-built options may be available to download.

Our analysis: a think-tank paper has no legal force. Treat it as a sign of what policymakers may be asked to consider.

For you: if your business or product depends on open models, keep a record of which model and license you use, and favor ones with clear terms. That is cheap insurance whichever way the rules go.

Kyutai CADRE cuts world-model lag below 230 ms

MarkTechPost reports on Kyutai's CADRE, a set of video autoencoders (systems that compress video into a compact form) that cut lag in world models below 230 milliseconds. A world model is an AI that predicts what happens next in an environment, which is useful for robots, simulations and interactive video. Status: lab claim, REPORTED; we haven't seen the test setup or hardware behind the number.

Why it matters: lag decides whether a world model can respond in real time. Under a quarter of a second moves it closer to interactive use, where you steer a scene instead of waiting for a clip.

Our analysis: a latency figure depends on hardware and resolution, so don't compare it to your own setup without checking those details.

For you: this is mostly for researchers and robotics or game teams. Students can read the write-up to learn how compressing video speeds up prediction. Creators should expect the effect in interactive video tools later, not today.

Nvidia's Nemotron 3.5 Bolt E4B 4GB: a small model built for a memory budget

Per MarkTechPost, NVIDIA released Nemotron 3.5 Bolt E4B 4GB, an open small language model post-trained from Gemma 4 E4B (Google's open model family). It targets local voice assistants, game characters and robots, aiming for about 4GB of video memory on RTX graphics cards and Jetson-class devices. Status: release and target REPORTED by MarkTechPost; confirm details on the model card.

The trap: your operating system and other apps also use video memory. A game character shares the card with the game's own graphics. The real question is what is left after everything else.

Context length matters: the key-value cache (the model's short-term memory of the chat) grows with conversation length, so test realistic lengths, not an empty chat.

What changed: not a new architecture. A vendor tuned a small model against a stated memory budget and use case, which lets you plan. STILL OPEN: benchmark scores, speed, and the license. A model built on Gemma may carry Gemma's terms, so read the model card before commercial use.

Who benefits: owners of 8GB cards, indie game makers who want no per-message fees, robotics tinkerers who need offline operation. Who loses: anyone on a 4GB card with no headroom. Our caution (analysis): the stated targets are RTX and Jetson, so factor in the hardware tilt.

Cost and worth: price not stated; the model is open, so your cost is hardware you own. Worth it if you have an RTX card or Jetson board and want an offline voice assistant.

Do today: record twenty real phrases from your use case, run them, and measure the delay to the first word.

Kyutai CADRE: how an open video autoencoder cuts world-model lag

Kyutai released CADRE, a family of seven open causal diffusion video autoencoders for interactive world models. World models built on CADRE run at 20 frames per second on one H100 (a data-center GPU) and react in under 230 ms. Status: REPORTED by MarkTechPost; independent reproduction STILL OPEN.

The mechanism (general background, not Kyutai's exact recipe, whose design details we haven't read):

• A world model predicts the next frame from what you just did. Doing that on raw pixels is expensive.
• An autoencoder squeezes each frame into a small grid of numbers, the latent. The world model works there, and a decoder turns the result back into pictures.
• Causal means each frame is encoded using only past frames. Many video compressors look at a whole clip at once, which is useless live because the future hasn't happened.
• Diffusion builds an image by removing noise step by step. Every step costs time, so how few steps you need drives lag.

Plain comparison: 20 fps is 50 ms per frame, so 230 ms is about four to five frames of delay, a bit under a quarter of a second.

Limits: one H100 is not a home GPU. The summary doesn't say how the seven variants differ; likely trade-offs between compression, quality and speed, but check the release.

Novel vs incremental: compressing into a latent is standard. What's new is the combination of causal design, diffusion decoding and low lag, released openly. Analysis: the open autoencoder may matter more than any single world model, since every builder needs that part.

Cost and worth: price not stated. Worth it for researchers and prototypers with data-center GPU access.

The five-minute fit check for any open model

For builders. Who it's for: anyone deciding whether a model runs on their machine. This is an illustrative method; we have not run it on today's models. Prerequisite: the model card and a local runner (llama.cpp, Ollama, LM Studio and vLLM are common ones from different projects; check each project for pricing).

1. Find the parameter count (the adjustable numbers inside the model) on the model card.
2. Pick a precision: 16-bit takes 2 bytes per parameter, 8-bit takes 1, 4-bit takes about half a byte.
3. Multiply. A 4-billion-parameter model is about 8GB at 16-bit and about 2GB at 4-bit.
4. Add headroom for the conversation cache and runtime. A rough rule of thumb is 20 to 30 percent more, and more for long contexts. This is an estimate, not a guarantee.
5. Subtract what other programs already use from your card's memory, then compare.
6. Load it in a local runner and measure tokens per second and time to first token.

Size check (our estimate): Kimi K3.1 Pro at about 3 trillion parameters and 4-bit is roughly 1.5 terabytes, vastly larger than the small model.

Common mistake: checking the file size and forgetting the cache. A model that fits at 'hello' can run out of memory at message fifty, so run your longest realistic input.

How to verify it worked: your estimate lands within about a quarter of the number your system's memory monitor shows. If it's far off, recheck the precision.

Build a 20-prompt test set once; save about an hour per release

New releases are arriving: Kimi's weights by 4 November, and a Qwen model that looks close. The time sink isn't downloading, it's re-testing.

The method: write twenty real prompts from your own work, each with a note on what a good answer looks like.

The number (our estimate, not a measurement): ad hoc testing of two new models takes about two hours (an hour each). With a saved set: about 45 minutes to build it, then about 10 minutes per model, roughly 65 minutes total. That's about 55 minutes saved on the first two, and about 50 on every release after.

Candidates to put through it: Nvidia's Nemotron, Google's Gemma (the base it is built on), Alibaba's Qwen when it lands, and Moonshot's Kimi through a hosted service if you can't run it. Today's stories state no prices, so check the current price on each company's official site.

What you give up: 45 minutes up front, and a set that only reflects your tasks. Refresh it about once a month.

Prompt clinic: choosing a model to self-host

Weak prompt: Which open model should I use for my project? It gets you a generic list from the model's memory, probably missing everything released this month.

Better prompt (illustrative, not tested):

You are helping me pick an open-weight language model to run locally.
My task: [describe the task].
My hardware: [GPU, its memory, and what else uses that memory].
Latency target: [e.g. first word within one second].
Use: [personal or commercial].
Give me a shortlist of three. For each, show the memory arithmetic: parameters x bytes per weight at the precision you recommend, plus headroom.
List what I must verify on the model card, especially the license.
Mark anything released after your training data as unknown.
End with a twenty-prompt test plan.

Why it works: it gives constraints, forces the arithmetic to be shown so you can check it, makes the model admit what it doesn't know, and ends with a test plan.

Customize: swap the latency target for throughput if you run batch jobs.

Quality check: recompute one of its memory numbers with the formula from the technique. If it's off, don't trust the rest.

Background research, not today's news, from our own knowledge of the field. A DeepMind team published the study often called Chinchilla. Finding: For a fixed training budget (the total computing power spent), a smaller model trained on much more text beat a much larger model that got roughly the same compute. Parameters are the adjustable numbers inside a model; tokens are the word-pieces of training text. Limit: it is one study from 2022, and newer models differ.

Decision this week: don't start at the biggest model. Start with the smallest on your shortlist, run your test set, and move up only if it fails.

• Stretched at both ends: about three trillion parameters on one side, a 4GB target on the other. The choice in between is yours.
• China's labs moving together: Moonshot, Alibaba and DeepSeek all made news, and policy is reacting (the Manhattan Institute proposal).
• What to watch: Kimi's full weights by 4 November (announced date; confirmed when weights and license text appear in the repository). The next Qwen model (REPORTED from code activity, no date; confirmed by a model card). DeepSeek's round (confirmed by a company statement and terms).

Today's payload: a memory formula, a reusable test set and a prompt, all built from today's releases.

Open weights means anyone can download it, once they find a terabyte and a half of spare memory.

That's it for today. Tomorrow we're watching whether Kimi's full weights land ahead of the 4 November date, and whether the next Qwen model gets a name.

If this made you smarter, share it with one person who needs it. Thank you for spending part of your day with us.

Made by AI.

SI Agent News — a podcast newsletter.