← Back to search
Episode 127: OpenAI Patches 948 Linux Kernel Vulnerabilities
AgentStack Daily · 2026-11-06 · 33 min
Show full episode description
OpenAI’s discovery and patching of 948 Linux kernel vulnerabilities anchors today’s developer news, alongside Astra’s direct neural-network weight editing... Show notes: https://tobyonfitnesstech.com/podcasts/episode-127/
✨ Episode Outline — click any point to jump to it in the episode
Problem solved
Daily roundup of agent-ecosystem news:
Hermes Agent 0.226/0.227 collaboration features, Astra's direct weight editing,
OpenAI's kernel-patching pipeline, Ripple 65B, and infrastructure shifts.
Benefits
- Hermes 0.226 web app served via gateway; group chats get renaming, mentions, attachments
- Hermes 0.227 cron jobs post into group chats; per-skill locks and pre-inference hooks
- Ripple 65B offers 1M-token context and native tool calling via OpenRouter
- OpenAI pipeline hands kernel maintainers validated vulnerabilities plus candidate patches
- Images 2.6 adds GIF generation and precise editing in ChatGPT, Codex, API
Use cases
- Astra edited 0.016% of Qwen 3.5 0.8B weights, lifting MATH-500 from 7.9% to 48.1% without retraining
- OpenAI autonomous pipeline found, validated, and patched 948 Linux kernel local privilege escalation flaws
- Hermes desktop group chats add lead routing, shared notes, pinned Kanban boards as tabs
- Together Compiler re-optimizes serving plans as traffic shifts, up to 2.6x tokens/sec
- Voters in 30+ localities across 9 US states restricted or banned data centers
KPIs / results
- 948 Linux kernel vulnerabilities patched by OpenAI pipeline
- MATH-500 7.9% → 48.1% from editing 0.016% of weights
- Ripple 65B: 80.52 Terminal Bench 2.1; $0.20/M input, $0.60/M output
- Hermes 0.226 shipped Nov 2, 0.227 Nov 3
I'm Alloy, and this is AgentStack Daily. Automated systems can contribute to defensive software work. And software itself is becoming editable in stranger ways. Aster reportedly inspected a smaller neural network's raw weights and changed just 0.016% of them, lifting its reported math 500 accuracy from 7.9 to 48.1%. Ripple 65B brings native tool use, open weights, and a million token context window to agentic coding. People are also building texture and dubbing pipelines in ComfyUI, generating GIFs inside OpenAI's image system, and adapting inference plans while live traffic changes. Today, Hermes Agent .227 and .226, direct neural network weight editing, OpenAI's Linux fixes and faster image model, Ripple's local coding ambitions, voter resistance to AI data centers, mixed-chip inference, and new infrastructure for codec-scale development. Nouse Research shipped Hermes Agent .226 on November 2 and .227 one day later. The pair broadens shared agent work across its terminal interface, web app, desktop, Docker, and Hermes Cloud. .226 adds a web app served directly through the gateway, so the terminal interface can open it and desktop users can reach it through a web access pane on their network or behind a now sign-in. Desktop plugins can also load inside a browser tab. Group chats gain renaming, disbanding, mentions, and pasted attachments, while every profile can appear as a section in the desktop sidebar. That turns Hermes from a mostly individual agent surface into something closer to a shared workspace with visible participants and shared material. It also reduces the separation between a task running through a terminal and the people following that task through a graphical interface. A person monitoring several agents can see those profiles as distinct participants instead of treating the whole group as one opaque automation process. .227 pushes that collaboration into scheduled work. Cron jobs, tasks that run at preset times, can now post into group chats. Desktop group chats also gain optional lead routing, a lead badge, room purposes, shared notes, a single column layout showing each member's live state, and pinned Kanban boards as quick switch tabs. I like the pairing because it answers two separate questions, where does automated work go, and who appears responsible for moving it forward? Scheduling becomes easier to control too. People can cancel jobs, choose what happens after a missed run, and stop a job from the desktop editor. Per-skill locks can prevent autonomous rights to a selected skill, while a pre-inference hook can block a turn before the model is called. Those controls operate at different moments, one protects a particular capability, while the other can stop an entire turn before inference spends resources or initiates action. A session's chosen model can also be cleared without deleting its history. Collaboration gets richer, but so do the breaks, which is exactly what shared automation needs. The planned .23 release is supposed to collect curated notes across these feature areas and the changes introduced since .22, giving the collaboration push a more unified account. A 65 billion parameter model with a million-token context window sounds enormous in both senses. What does Ripple 65B's OpenRouter listing actually make available? OpenRouter lists Recursive AI's Ripple 65B preview as a text-to-text model served in 16-bit precision, with native tool calling and a context capacity of 1,048,576 tokens. Tool calling means the model can ask connected software to invoke a named function instead of trying to express every action as pros. The listing prices prompt input at 20 cents per million tokens, generated output at 60 cents per million, and cache read input at 5 cents per million. That cache rate matters when a long-running agent repeatedly revisits the same large body of code or documentation. Access is through OpenRouter's API, so a team can route an existing agent workload to Ripple without first hosting the weights itself. The model accepts text and returns text, so its agent value comes from connecting that language surface to tools rather than from built-in image or audio processing. A coding application, for example, could place repository context in the model's working window while letting tool calls handle file inspection, searches, or other external actions. The million token capacity grabs attention, but tool use is what turns that capacity into an agent product. A model can hold a very large repository or document collection in view and then request an external action when reasoning alone isn't enough. Capacity, though, doesn't prove that every useful detail remains equally available across the entire window. Ripple's listing provides an immediate access route and predictable token prices, its separate open-weight release creates a path towards self-managed deployment. Those are distinct advantages. One reduces the friction of putting the model behind an existing application, while the other gives organizations more control over where it runs. The cache read price also favors workloads that reuse a large shared prefix instead of paying the full input rate on every turn. The listing makes Ripple easy to reach now. Sustained coding sessions will reveal how well its long context and native tool calls cooperate when the work involves many files, repeated actions, and changing state. Ustra's reported experiment is genuinely unusual. The team says GPT-6 Ustra inspected the raw numerical weights inside QUEN 3.5, 0.8 billion, inferred that part of the network contributed to reasoning loops, and edited selected values through natural language reasoning. It didn't use a custom training loop or gradient descent, the usual process of improving a model by repeatedly measuring errors and nudging huge numbers of parameters. Ustra changed 0.016% of the weights. And the reported jump isn't subtle. Under the same sampling settings, MATH 500 accuracy rose from 7.9% to 48.1%, while instruction following performance on IFEVAL tripled. Those results come from the team presenting the method, so they need reproduction beyond the reported example. But okay, that's actually wild, a larger model appears to have examined a smaller model as a numerical object, found behavior associated with particular weights, and performed a targeted repair without retraining the whole network. They call it weight space programming. Instead of treating weights as an opaque byproduct of training, the approach treats them as editable numerical artifacts whose computations can be reasoned about. That could matter when a model has a narrow behavioral defect and full retraining would be slow or expensive. A targeted edit might alter one failure while leaving most of the network untouched. The difficult question is whether the change really stays narrow. Improving two evaluations doesn't establish what happened to unrelated skills, calibration, safety behavior, or robustness under different prompts. Right, and I don't buy the broadest interpretation yet. One intervention in a 0.8 billion parameter model doesn't mean frontier networks have become cleanly programmable from natural language. But it does challenge the assumption that model improvement must always mean another training run. If later work can connect an observed failure to a small, interpretable set of weight edits, and show that the repair generalizes without hidden damage, model maintenance could begin to resemble repairing a particular circuit instead of rebuilding the entire machine. OpenAI says it built an autonomous pipeline that found, validated, and generated patches for 948 Linux kernel vulnerabilities. These were local privilege escalation flaws. An attacker would already need some access to the machine, but exploiting one could elevate that access and expose much more of the system. The Linux kernel sits at the heart of servers, desktops, embedded devices, and cloud infrastructure, so defects at that layer can have an enormous reach. 948 is the number that makes me stop. Security teams normally have to move through discovery, reproduction, severity assessment, patch design, and review. OpenAI's pipeline compressed discovery, validation, and candidate patch generation into one automated flow. It doesn't remove maintainers from the process. It hands them a large body of validated cases and proposed fixes to inspect. That distinction matters because a patch can close one flaw while causing a regression somewhere else in a system as interconnected as the kernel. Exactly. Generated a patch and safely landed in Linux aren't interchangeable. Kernel maintainers still have to judge whether a fix addresses the actual cause, preserves expected behavior, applies across relevant branches, and avoids creating another security problem. But the discovery scale changes what becomes possible upstream. An automated system can search for classes of flaws that human teams might encounter slowly, then produce reproducible cases instead of a pile of speculative warnings. It can also connect discovery to a candidate repair, shortening the distance between something is wrong and here is a concrete change for expert review. The consequential evidence comes through expert review, acceptance, and deployment. Even if only a portion of the generated fixes ultimately lands, the pipeline demonstrates a different shape for defensive security work. Humans can spend more attention judging repairs and understanding systemic causes while machines search and reproduce flaws at volume. That's exciting, but it raises the bar for review capacity too. Finding hundreds of real vulnerabilities faster only helps if maintainers can safely turn that cue into shipped fixes without drowning in the output. OpenAI released Images 2.6 on November 4 across ChatGPT, Codex, and the API. It generates images faster, can create GIFs, and offers more precise editing. New API controls give developers more influence over how those capabilities behave inside products. The visible change is that image work can move beyond making a static first draft. A person can generate an asset, refine a selected detail, or turn the idea into motion without leaving the same model family. In Codex, that also puts visual creation nearer the software work surrounding an interface, demonstration, or digital product. An application team could generate interface artwork and produce a short-moving demonstration through the same underlying service instead of handing each stage to a disconnected tool. The same capabilities can also support rapid variations of an existing visual while preserving the parts that already work. GIF creation sounds playful, but it closes a real production gap. Short-motion assets appear in product demos, social posts, support material, and interface prototypes, and they've often required a separate tool after image generation. More precise editing may prove even more important because useful creative work depends on preserving what's already right while changing one specific region. Faster output shortens the conversational loop, ask, inspect, revise, and keep moving before the idea goes cold. The API expands that loop beyond OpenAI's own applications, letting other products combine generation, motion, and selective editing inside their existing creative surfaces. A support platform could produce a short animated explanation, while a design product could let someone revise one object without recreating the entire composition. Speed matters most when it supports several careful revisions, not merely when it produces the first image sooner. We've covered Ripple's hosted route. The open-weight release makes a bigger claim, Recursive Intelligence says a 65 billion parameter model can lead American open-weight models in agentic coding while remaining practical enough for local NVIDIA systems. What supports that? Recursive reports an 80.52 score on Terminal Bench 2.1, an evaluation built around agents completing tasks in a terminal environment. The company places Ripple ahead of Reflection Beam at 501 billion parameters, MetaMuse Spark Open at 816 billion, Thinking Machines Inkling at 975 billion, and NVIDIA Nemetron 3 Ultra at 550 billion. Those comparisons and the score are Recursive's reported results. Ripple is much smaller than those named Rivals, which makes the number notable if broader use reflects the same efficiency. The model was pre-trained on 12 trillion tokens, and Recursive says its dense architecture was designed for efficient training and serving on NVIDIA hardware. The company says it tested architectural changes on smaller models before scaling them, built its own synthetic data pipelines, and spent $32 million across data, evaluation, debugging, and post-training. That's a meaningful engineering claim, but local needs translation here. Recursive points toward hardware such as NVIDIA DGX Spark, not a thin laptop running beside a web browser. Open weights give organizations the option to operate the model on infrastructure they manage, while 65 billion parameters still demand serious memory and compute. Ripple supports up to 1 million tokens of context and native tool calling, aiming it at agents that inspect large repositories and act through connected software. The weights are available through HuggingFace, while Together AI, GMI Cloud, and OpenRouter provide hosted access, with fireworks also scheduled. That combination lets teams choose between managed inference and more direct control over deployment. Recursive's terminal bench score gives the release a sharp headline, unfamiliar repositories, long jobs, and messy tool failures will determine how much of that reported advantage survives ordinary development. ComfyUI's stable point 44 release adds partner nodes for patina texture work and VED dubbing, both contributed by BigCat88. Patina brings texture creation into the node graph, while VED adds a dubbing step. ComfyUI also updated its workflow templates to .1198, giving creators refreshed starting structures for assembling those pieces with image, video, and audio operations. The fun part is the connection between them. Texture and dubbing sound unrelated until a single graph is producing a visual scene, giving its surfaces a particular material character, and localizing its spoken track. ComfyUI's node approach makes those operations composable instead of hiding them behind separate application workflows. A creator can place a specialized operation at the point where it belongs and keep the surrounding pipeline visible. There's an internal maintenance change to the Python target used by PyLint, but the creator-facing news is firmly the two partner nodes. Their value becomes clearer through complete workflows rather than isolated node descriptions. A texture node earns its place when it fits naturally between generation and final rendering. Dubbing becomes useful when timing, voice, and the surrounding media pipeline remain coherent. That's why ComfyUI keeps getting more interesting. It isn't merely adding another model picker. It's accumulating specialized production steps that can be rewired around a creator's actual process. Patina and VED extend that graph into two more parts of media production without forcing generation, surface work, sound, and localization into one monolithic editor. Voters rejected or restricted data centers in more than 30 localities across nine American states. Measures included moratoria, outright bans, and financial or operational constraints on hyperscalers seeking tax breaks. Some votes responded to projects already underway, so this wasn't theoretical resistance to an imagined future build-out. Edgewater, Florida, overwhelmingly put a data center ban into its city charter. Perry, Ohio, imposed financial and operational conditions on hyperscalers seeking incentives. Anti-tech or anti-data center advertising also appeared in more than 130 federal and gubernatorial races. Texas Governor Greg Abbott had promoted AI and data center expansion, then promised tougher regulation, but still lost his election. Local concerns have become potent enough to shape campaigns far beyond planning board meetings. Financing is responding too. Banks and asset managers have begun treating community opposition as a credit risk, while hyperscalers are hiring community liaisons. Some operators are calling their facilities compute campuses, but changing the label hasn't reliably changed public reaction. Residents still see power demand, water use, land, noise, tax treatment, and the durability of promised jobs. A polished name doesn't answer who pays for new infrastructure or who bears the disruption. Once lenders put a price on political resistance, a community vote can alter project economics before construction starts. This can change the map of AI infrastructure. A technically suitable site may become financially unattractive if approval is uncertain, incentives face voter conditions, or lenders price opposition into the deal. Communities are asserting leverage before construction, not merely negotiating after the servers arrive. Companies that keep building will need agreements people can evaluate in concrete terms, costs, protections, and local benefits. The compute boom increasingly depends on public consent, and voters have shown they're willing to withhold it. Sambanova and Supermicro announced a collaboration to build and sell inference systems combining Sambanova RDUs with GPUs. An RDU is Sambanova's processor designed around dataflow, moving model computations through hardware differently from a conventional graphics processor. Supermicro's initial planning covers 10,000 SN50 RDU chips, giving the partnership a real volume target rather than a vague agreement to explore mixed hardware. Supermicro contributes system building and distribution experience. Sambanova brings a processor designed around a different way of moving model computations. The combination also acknowledges that AI serving may benefit from several processor types rather than demanding that one chip handle every stage equally well. The mixed chip design is the interesting bet. Agentic workloads don't necessarily behave like one uniform stream of matrix operations. They can alternate between generating tokens, processing long contexts, calling tools, and waiting on external systems. Sambanova argues that the next wave of inference has to run everywhere, and the partnership pairs its specialized processors with the enormous installed momentum of GPUs. But 10,000 planned chips aren't 10,000 deployed chips. The meaningful next step is an available system showing which work runs on the RDU, which remains on GPUs, and whether the combination improves throughput, latency, or cost enough to justify another hardware layer. If the split works, operators gain another way to match particular computations with the hardware that handles them efficiently. After voters imposed restrictions on data centers, OpenAI introduced the Grid Protectors program. Is that a direct response to the same pressure? It addresses the same collision between compute growth and local infrastructure. OpenAI says the program will work with utilities so future compute campuses support electrical grid reliability and protect consumer power costs. Large facilities create concentrated demand, while grids still need enough generation, transmission, and flexibility to handle peaks and disruptions. A campus that coordinates its demand or supports new infrastructure may integrate more cleanly than one that simply requests an enormous continuous load. The announcement puts household costs and reliability inside the compute project's public obligations That's the right framing, but communities will judge specific arrangements. Each region has different generation, weather, regulation, rate structures, and transmission constraints. Named utilities, named campuses, and enforceable protections will show whether the program changes outcomes. Still, OpenAI's timing makes one point clear, power access and public consent are becoming the same business problem. Future AI capacity depends on chips and buildings, but also on utility agreements that existing customers consider fair. Calling a site a compute campus won't rescue a weak deal, transparent commitments around reliability and consumer costs might. The data center votes we just discussed make those commitments commercially important, not merely good public relations. A laboratory model can understand that a sample needs to move and still fail at the physical question, what can it safely grasp, and how can the machine reach it? That gap is what the Beaker benchmark measures. Researchers curated image and video questions covering equipment recognition, experimental state, experimental state, safety, apparatus setup, operation, procedure order, and physical reasoning. Current models handled broad procedural steps better than tasks requiring them to identify operable parts and feasible trajectories, the paths a robot or machine can actually follow. That matters enormously for self-driving laboratories. Recognizing an experiment sequence isn't enough when an action can spill a chemical, collide with equipment, grip the wrong component, or disturb an apparatus whose state matters to the result. Exactly. Describing the right action isn't the same as performing it. Lab automation needs perception, safety constraints, and physically workable movement to agree at the same moment. Beaker exposes that gap before systems receive control over real machinery. OpenAI built Pando, a GIT-compatible backend designed for the amount of development codecs can produce across its desktop app coding environment. GIT is the system developers use to record code history, branch work, compare changes, and combine contributions. Compatibility lets established GIT concepts remain relevant while Pando changes the infrastructure serving them. That matters when codecs creates more concurrent development activity than a conventional human-only workflow, more repository reads, proposed changes, branches, comparisons, reviews, and merges moving at machine speed. So the notable codecs change isn't another terminal tag. OpenAI is rebuilding the repository layer beneath the desktop product. Why not simply add more servers behind ordinary GIT hosting? Because scale changes the shape of the workload. Many parallel coding tasks can repeatedly inspect the same histories, create overlapping changes, and ask for comparisons or merges at a pace repository infrastructure wasn't originally designed around. OpenAI describes Pando as GIT-compatible and built for codecs-driven scale, which suggests the company wants higher capacity without forcing developers to abandon familiar code history semantics. The visible coding experience still depends on durable history, coordination, and review underneath it. If agents multiply the number of simultaneous contributors, repository performance becomes part of whether the product feels coherent. And GIT compatibility is the clever constraint. A new backend is easier to absorb when software teams don't have to discard the mental model and surrounding ecosystem they already use. Real repositories will supply the harder evidence, large histories, many concurrent agents, human contributors, conflicting edits, and complicated merges. Still, Pando shows where AI-assisted development is heading. Writing code is only one layer. The surrounding systems must absorb far more software activity without allowing collaboration, provenance, and history to become the new choke point. OpenAI announced on November 4 that it will acquire Pierre Computer Company. OpenAI says the deal will expand Codex's tools for building, understanding, and reviewing code. That places the acquisition across the software development cycle rather than attaching it to one narrow feature. Building covers creating or changing software. Understanding means navigating what an existing code base does. Review asks whether a proposed change is correct, safe, and appropriate. Those later stages become more important as coding agents generate a larger volume of changes because producing code quickly doesn't automatically make that code easy to comprehend or approve. Better review and code understanding can determine whether additional generated work becomes useful output or simply a larger cue for people to untangle. It pairs neatly with Pando. One investment strengthens the repository infrastructure beneath agent-heavy development, while the other adds people and technology aimed at how developers create, comprehend, and assess code. OpenAI isn't positioning Codex as a clever completion box. It's assembling a broader environment where generation, repository understanding, and review increasingly sit together, and where the human needs a clear view of what changed, why it changed, and whether it belongs. The acquisition's impact will become tangible as Pierre's work appears in those building, understanding, and review surfaces. Fast code generation is easy to celebrate, making that growing stream legible and reviewable is what turns speed into dependable engineering. Most model optimization sounds finished once deployment begins. Together compiler assumes the opposite, traffic changes, so the optimized computation should keep changing too. How does that differ from one carefully tuned serving configuration? Together AI describes it as an agent-driven system that repeatedly re-optimizes a model's forward pass, the computation that turns input into output, as serving traffic shifts. Together reports throughput of up to 2.6 times the tokens per second of the best inference-ex configurations, with optimization completed in under 24 hours for each model. That number comes from together, so performance across different models and workloads will show how broadly it carries. The important change is that the compiler treats an execution plan as something that can be revisited after deployment rather than fixed permanently when a service launches. That fits production traffic better because request lengths, batch sizes, concurrency, and model usage move over time. A setup tuned for yesterday's workload may waste hardware tomorrow. Together compilers agent-driven loop searches for a better execution plan against the traffic actually being served. If the reported gain carries across changing workloads, inference optimization becomes an ongoing service rather than a launch day engineering project. That could translate the same hardware into more completed requests or lower serving cost without changing the model itself. The adaptation still has to remain dependable, extra optimization only pays when the resulting computation stays correct and the throughput gain outweighs the operational complexity. But 2.6 times the token rate is large enough to make continual re-optimization more than a cosmetic improvement. Nanobot has 49,845 stars, up 1,067 in 30 days, and .4 shipped October 28th. It provides a lightweight personal agent foundation. Codebase Memory MCP has 48,151 stars, gained 2,382, and released .121 in October. Its persistent graph connects code, documentation, and infrastructure, while its change-aware capabilities help relate edits to affected areas. A compact worker such as Nanobot could therefore operate with richer, durable repository context instead of rediscovering the same relationships every time it enters a project. MCP for Blender extends that connected agent idea into three-dimensional creation. It reached 33,360 stars after gaining 3,415 in 30 days, 11.4% growth, and was updated November 4th. It lets an LLM operate Blender through an integration layer, though it's a community project rather than an official Blender foundation tool. The three projects occupy different scales, Nanobot supplies a focused worker, codebase memory preserves relationships across a software system, and MCP for Blender gives an agent a specialized creative environment it can control. Recursive AI's Ripple 65B preview is available through OpenRouter as a 65 billion parameter, text-to-text model served in 16-bit precision. It supports native tool calling and a context window of 1,048,576 tokens. That combination targets agents that need to reason across unusually large coding contexts and invoke external functions, with immediate API access through OpenRouter and OpenWeights available through Recursive's wider release. Moonshot AI's Kimi K3.1 Pro is trending on hugging face with 711 likes and 11,658 downloads. It accepts images and text and produces text, supporting visual questions, screenshots, figures, and image-grounded conversations instead of operating as a text-only model. Its repository uses transformers, safetensors, compressed tensors, and custom code, with evaluation results attached. The appeal is multimodal work under self-managed deployment, technical documents with figures, interface screenshots, and visual material that needs explanation in context. Its license, weight format, runtime requirements, context capacity, and hardware demands determine where that deployment is realistic, especially for a ProClass model. The download count shows active interest, while the image and text surface gives it a more concrete role than another general conversational model. SonyArc's STT version 6 adds agent text input and echo filtering for voice agents. It can receive the voice agent's own text while listening to a caller, helping it recognize short replies and filter the agent's speech rather than transcribing both sides as one confused stream. Its streaming and asynchronous surfaces are aimed at live and recorded voice workloads. OpenAI is also rewarding defenders with bigger bug bounties, adding bonuses tied to report quality, loyalty, and priority campaigns for independent security researchers. And OpenAI is accelerating engineering for the physical world by applying chat GPT and codecs across computer-aided design, circuit board design, simulation, and related engineering work. That connects the other two developments nicely, SonyAux is helping agents hear accurately during live interaction, while larger security rewards encourage people to document consequential flaws clearly. Across voice, defensive research, and physical engineering, AI systems are moving closer to work where misunderstood context becomes an expensive mistake. For the primary sources and more detail behind these developments, look at the show notes at Toby on Fitnesstech.com. Thanks for listening to Agent Stack Daily. We'll be back soon.