OpenAI reports 948 Linux flaws as Mistral releases Large 4 weights

OpenAI published results from an automated Linux kernel vulnerability research system on November 4, 2026.¹ In a mid-October run, the company used its unreleased GPT-6 Cyber model to find potential flaws, test attacks, and draft patches.¹² OpenAI says the system produced working exploits for 948 distinct vulnerabilities that allow local privilege escalation. Its proposed patches were intended for human review.¹

The experiment covered selected, commonly used kernel code, and attacks were tested in isolated environments.³ OpenAI reported disclosing 304 critical findings with proposed patches but did not provide a complete remediation status for all 948 vulnerabilities.²⁴ The results demonstrate a potential use for automated security research; they do not mean every reported flaw has been fixed.

Mistral AI released the weights for Mistral Large 4 on October 29. The multimodal mixture-of-experts model has about one trillion parameters and is available to download through Hugging Face for self-hosting.¹² Mistral highlights applications in agentic coding and defensive cybersecurity.¹

The release gives companies another way to run a large model on their own infrastructure rather than rely solely on an API. The weights carry a modified MIT license; reports say providers offering the model as a hosted service need a separate commercial license.¹³ Mistral reports strong results on coding-agent evaluations. Those figures are the company’s performance claims, however, and do not replace testing against an organization’s own tasks and security requirements.¹

MIT researchers described on November 2 how they had GPT-6 Astra inspect and change the weights of the open-weight Qwen3.5-0.8B model. Astra used a coding environment and up to 50 forward-pass iterations, but no gradient descent or conventional training run. In the reported evaluation, MATH-500 accuracy rose from 7.9% to 48.1%. The results appeared in a research post, not a peer-reviewed publication.¹²

According to the researchers, the edit primarily addressed repetitive reasoning loops that made answers run long. The result therefore points to a way to repair a specific model failure, rather than evidence that Astra added broad mathematical knowledge. Whether the approach works reliably across other models and tasks remains unclear. This experiment alone does not establish weight editing as a general replacement for retraining.¹²

Moonshot AI released the weights for Kimi K3.1 Pro on November 4. The model was already available through Kimi apps and its API; the new release lets users download and host it themselves.¹² Kimi K3.1 Pro has 2.8 trillion total parameters and a 1,048,576-token context window.³¹

The release gives companies more control over deployment, but the infrastructure requirements are substantial: the model files total about 1.56 TB.¹ The weights carry a Moonshot license rather than an OSI-approved open-source license, and additional terms apply to large commercial providers.¹ Moonshot says it removed cyber-related data and environments before releasing the weights. It has not disclosed the training data or complete training recipe.⁴¹

On October 29, 2026, Cursor identified tampered versions of a Claude Code extension in its VS Code extension marketplace.¹ The packages used the identifier Anthropic.claude-code but were not developed by Anthropic.¹² Up to 5,000 users may have downloaded them; that is not a confirmed count of compromised computers.³ Cursor removed the versions, temporarily suspended its marketplace, and said it would contact affected users.¹³

The injected code ran when the extension loaded and collected host information.¹² It attempted to add an attacker-controlled SSH key, enable the SSH service, establish a reverse tunnel, and install persistence outside the extension directory.¹² Whether remote access succeeded depended in part on system privileges and SSH configuration.² Uninstalling the extension alone may not remove components placed elsewhere. Cursor advises checking affected systems and rotating credentials accessible from them.¹⁴

ISTA-DASLab released a compressed GGUF coding variant of DeepSeek-V4.1-Flash-1017 on November 2. It is available under an MIT license in five files and is listed as compatible with llama.cpp.¹ The underlying mixture-of-experts model has 763.2 billion parameters. For this variant, the lab removed 192 of 384 routed experts per layer and quantized the remaining weights with GSQ and RCO. Its transformer files occupy 72.12 GB, down from 138.2 GB for the version without expert pruning.¹²

“One bit per parameter” is an effective rate: the calculation counts removed weights even though they consume no storage.¹ The 72.12 GB also excludes the Engram file; together, those files occupy 182.72 GB. A vision projector adds more.¹ The model card reports 77.00 on SWE-bench Verified, compared with 81.20 for the base model. The smaller size therefore does not establish unchanged performance.³

Prefrontal AI introduced Latent Sparse Attention (LSA) on November 2 and released its code.¹² The method groups keys in a learned latent space and searches those groups before reading selected keys, rather than checking every key individually.³ At a 10-million-token context on an NVIDIA H200, the team reports a 72.4× prefill speedup for one attention layer compared with full attention on Qwen3.8-27B.⁴⁵

That figure does not describe whole-model speed.⁵ The reported speedup over GLM-5.3-Flash’s existing sparse-attention implementation is 22.7×, but that comparison uses a different model and baseline.⁴⁵ The paper reports similar accuracy across several tasks while also showing degradation in some tests at 10 million tokens.³ Whether the results hold across other systems and production workloads remains unclear.

Ricursive Intelligence released the weights for Ripple-65B Preview on Hugging Face on November 4, 2026.¹² The 65-billion-parameter dense Transformer is intended for general tasks and coding agents, with weights available under Apache 2.0.¹ Ricursive reports an 80.52% score on Terminal-Bench 2.1 and claims the lead among U.S. open-weight models on that test.¹

The model card explicitly labels the score self-reported, and it has not been independently verified.¹ Comparisons with results from other labs warrant caution because evaluation setups may differ. Ripple does not lead every coding test, either: Ricursive lists a 76.5% SWE-bench Verified result for Ripple, versus 81.6% for Reflection AI’s Beam.¹ Companies can test the released weights themselves, but should not treat the reported ranking as settled.

The open-source nv-uefi-unlocker project aims to increase AI throughput on certain Nvidia GeForce GPUs. It runs from a FAT32 USB drive and changes GPU registers before the driver loads; it does not flash the VBIOS. The change must be reapplied after the machine powers off. The project targets Windows and Linux.¹ In one developer test, FP16 matrix throughput on an RTX 4060 Laptop GPU rose from 29.89 to 49.33 TFLOPS, an increase of about 65%.²

That figure reflects a specific test, not the speedup every AI application can expect. The project reports gains of 14% to 75% in image and video generation tests, but only about 5% for LLM decoding. Results vary with the GPU, precision, power limit, and workload.¹ The figures come from developer and community measurements; the supplied sources do not establish independent validation across a broad range of deployments. Using the tool also means accepting the risks of changing GPU behavior before the driver starts.

A Carnegie Mellon University–led team has proposed an approach that handles pretraining, later training stages, supervised fine-tuning, and certain reinforcement learning objectives with a shared algorithm. The study appeared as a preprint on October 29, 2026.¹² Rather than treating each stage as a fundamentally separate procedure, the researchers mix training examples with selected model outputs. The weights and composition of that mix change over the course of training.¹

In the reported experiments, unified training schedules often produced better results than staged training at comparable compute budgets, including on tasks outside the training distribution.¹ The advantage was not consistent: staged training did better at some intermediate budgets.¹ The experiments used models with fewer than one billion parameters, and one applied unification mainly in its final reinforcement learning phase. Whether the approach helps at much larger scales remains untested.¹