Java4Shell: 64 'A' characters and one '=' make OpenJDK write past the end of a buffer. Calif says that is enough for remote code execution on x86-64 servers with AVX-512 VBMI, no credentials needed (CVE-2026-114938, CVSS 4.0: 9.2).
The mechanism, from their write-up: the x86-64 Base64 intrinsic miscalculates the store mask for the padded tail. For that 65-character input Java allocates a 50-byte result array, the routine computes a negative output length, and a 64-byte write lands 62 bytes past the end. Java then rejects the input with an exception, but neighbouring objects may already be corrupted. (Older OpenJDK 17 needs 128 A's.)
What they demonstrated: pre-auth RCE in default configs of Keycloak, Jira, Confluence, Artifactory, Jenkins and PingFederate; post-auth RCE in Kafka broker, Solr, Elasticsearch, Gerrit and Spinnaker. They call that list non-exhaustive, and add a client-side exploit: a Java program that opens a TLS connection to a malicious server. There is no universal exploit; each app needs its own steps.
Who is hit: only x86-64 CPUs with AVX-512 VBMI (Intel Xeon Ice Lake through Granite Rapids, AMD EPYC and Ryzen Zen 4 or newer). ARM64 is not affected. Builds listed: Corretto, Temurin, Microsoft, Zulu, Liberica, SapMachine, Red Hat, Oracle. Oracle's vulnerable versions: 8u511b33-perf, 17.0.21.0.3, 21.0.13.0.3, 25.0.5.0.3, 27.0.1.0.3.
Check a Linux host (all four flags must appear):
grep -m1 '^flags' /proc/cpuinfo | tr ' ' '\n' | grep -E '^(avx512f|avx512bw|avx512vbmi|bmi2)$'
The fix is a patched JDK; OpenJDK's advisory and Oracle's patch went out 17 Nov, 1pm PT. Stopgaps, x86-64 only: -XX:-UseBASE64Intrinsics, or -XX:UseAVX=2. On ARM the AVX flag stops the JVM from starting.
Limits: Calif found it and wrote the exploits, I have not run any of this, and the product list is theirs. They say AI helped find it in about an hour for under $200 of tokens.
https://t.co/edDVk1wXXi
Rust's Jiff datetime library reached 1.0 on 15 November, and its author, Andrew Gallant, says he plans to commit to that API indefinitely.
Why that matters beyond one library: he lists uv, Cargo, Starship, fd, Nushell, mise, Jujutsu and uutils/coreutils as projects already using it in production, plus AWS LLRT, which uses it as the basis for a Temporal implementation. A date library shows up in other libraries' public APIs, so a breaking release forces everyone downstream to change. His 1.0 promise is to avoid that: breaking releases "will not be made lightly".
The design idea is to put time zones at the front. The post builds it as an onion: a plain civil date and a plain clock time, which belong to no place; a Timestamp, which is one exact instant; a TimeZone, the rules that map between them; and a ZonedDateTime that holds all of it. Daylight saving is the hard part: when New York set its clocks back at 2AM, the 1AM hour happened twice, and a civil time can correspond to two moments or none. Jiff makes you deal with that in the types instead of discovering it in production.
One of his own caveats is worth copying: if you are measuring how long something takes, use monotonic time, std::time::Instant, not a datetime library.
Try it: cargo add jiff anyhow, then paste any example from the post into src/main.rs. His first one turns 2026-11-01 17:30 in America/New_York into the timestamp 1793572200.
Limits: the 1.0 promise holds "unless some significant defect is found" in the API, and the post is the author's own tour, not an independent review.
Do you reach for chrono, time or Jiff?
https://t.co/uhCnr94yeC
Windows 11 has a component that records which coding agents you run, and by default the report is queued for upload to Microsoft. That is the finding of Xusheng Li, who reverse engineered it and published the steps on 16 November.
What he found: MissionControlAggregator.dll, loaded by the DiagTrack telemetry service, matches process names. Four command-line agents (copilot, claude, codex, agy), five desktop agents (including cursor, antigravity and claude) and twelve broader developer-tool categories such as Python, Node, .NET and GCC. A match sets one bit. Windows then emits a report called Segments.SubCohorts with those bits, not prompts or source code, and not how long you used the tool.
How he tested it: he copied cmd.exe to a file named codex.exe and ran it. The name alone set the Codex bit, and the event showed CliAgentSubCohorts: 4 (1 << 2). The same trick with gcc.exe set a developer-tool bit, and that event appeared in DiagTrack's upload queue.
Does it leave your machine? The report is marked optional diagnostic data. On a clean US install of Windows 11 Home ARM64, optional diagnostics was on by default, so the report was queued for upload. If you turn it off under Settings > Privacy & security > Diagnostics & feedback > Send optional diagnostic data, this report should not be queued, because the post marks it optional.
Limits, which he states himself: this is one researcher's reverse engineering on his own machines (a VM and a clean install), the feature was disabled by default in the public ISO's baseline VM, so it is not proven active on every Windows install, and he found no prompt text or source code in the report.
Check your own machine (admin PowerShell):
Get-Service DiagTrack
tasklist /m MissionControlAggregator.dll
https://t.co/C6MpmNDcsh
Edge0-145B is a 145B-parameter open-weights model that its makers say runs on a 48 GB laptop: 29 GB peak memory and 80+ tokens a second, because only about 10B parameters work on each step.
Edge0 published the weights and its own inference framework this week. Here is the vendor's own table (Edge0's internal evaluations, not independent) against the two open models it chose to compare:
Edge0-145B / Qwen3.8-Flash-Next / DeepSeek-V4-Flash-0731
DeepSWE 1.1: 64.6 / 58.7 / 54.4
Terminal-Bench 2.1: 86.52 / 83.3 / 82.7
GPQA-Diamond: 90.4 / 91.7 / 90.8
IFBench: 80.6 / 81.3 / 79.2
HLE: 35.4 / 35.9 / 33.8
It leads on both coding-agent rows. It trails Qwen3.8-Flash-Next on GPQA-Diamond, IFBench and HLE, and DeepSeek on GPQA-Diamond.
The memory comparison needs care. 29 GB is Edge0's measured peak. Its figures for the others, about 70 GB for Qwen3.8-Flash-Next and about 87 GB for DeepSeek at standard 4-bit, are estimates it says remain to be measured. The same page also puts an expert library of about 40 GB in system memory and about 48 GB of vocabulary data on the SSD, so read the hardware guide before planning around a 32 GB machine.
Licence: the Edge0 Community Model License 1.0, which is not an OSI open-source licence. Personal, research and internal business use are allowed. You need a separate commercial licence to sell or host access to the model, or to ship a paid coding or office assistant built on it. The text says the Qwen parts keep their own Qwen licence.
No Ollama library page for it exists yet (checked 13 Nov). The weights are on Hugging Face as Edge0-145B-NVFP4.
Which would you rather run for coding: this 145B at 29 GB peak, or Qwen3.8-27B at roughly 18 GB (Edge0's estimate)?
https://t.co/FK7YOACUE4
Rust 1.100 (12 Nov) lets Cargo refuse crate versions that are too new. The Rust team's reason: malicious versions are often caught within hours or days of being published, so waiting a few days avoids most of them.
Opt in, in .cargo/config.toml:
[registry]
global-min-publish-age = "3 days"
Then cargo update skips anything newer and tells you what it held back. In the release notes' example, clap 4.6.9 was published 2 days ago, so Cargo stays on 4.6.7.
Need one version now? CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow cargo update clap --precise 4.6.9
Two limits the notes name: a version with no pubtime field in the registry index is never held back, and cargo install ignores the minimum age (pin with cargo install [email protected]). Cooldowns reduce some supply chain risk, not all of it.
https://t.co/dpE1aOEKps
A number parser can run more than twice as fast if you tell it what your data looks like: Daniel Lemire's fast_float goes from 153 to 345 million numbers per second on an Apple M4 Max for random-sign prices, with one hint.
fast_float turns text like -731.51 into a floating-point value and ships inside GCC's C++ standard library. Every decision it makes (is there a sign, how many digits, where is the point) is a branch. A wrong guess by the processor costs 15 to 20 cycles. With random signs, Lemire measured a mispredict on 60% of numbers on an Intel Xeon Gold 6338.
He is adding three hints, passed as a template argument: unpredictable_sign, short_numbers (up to 8 characters, parsed in one go) and assume_round_to_nearest (you promise nothing changes the rounding mode). Numbers parsed per second, in millions, Intel then Apple:
- Price changes (random signs, short): 73 to 105, and 153 to 345
- Account balances (random signs, long): 61 to 82, and 132 to 199
- Sensor readings (no sign, varied shapes): 67 to 92, and 123 to 250
- Regular prices (same shape every time): best with no hint on Intel (152)
It backfires if the hint does not fit: short_numbers on regular prices drops Intel from 152 to 104, and unpredictable_sign on sensor readings drops it to 57. If you promise round-to-nearest and code in your process changes the rounding mode, some results will be wrong.
The call is one line: fast_float::from_chars<performance_hints::unpredictable_sign>(first, last, value). The hints are still in a pull request, so this is not a release yet.
Does your parsing code know anything about its data that the library does not?
https://t.co/zjli1kyXwq
Google's new Decisions API returns a probability instead of a paragraph, at $0.10 per million input tokens with zero output tokens billed.
It is built for closed-set choices: routing a query, checking a policy rule, grading content. You send one input (text, images, audio, video or PDFs, up to 256K tokens) plus up to 1,000 questions, and the model scores the options in a single pass instead of writing an answer. Google gives 150 to 250 ms end to end.
Three question types: a yes/no check, a choice from 2 to 255 options, and an ordered rubric score. Each answer carries a confidence from 0 to 1, so your code can send the unsure cases to a person or a stronger model.
The cost claim is Google's own: nearly 5x cheaper than Gemini 3.5 Flash-Lite on its benchmark suite. The client example uses the v1beta API, and the benchmarks are not independent.
https://t.co/Gi06eMoP1i
AMD's Zen 6 doubles its VNNI units from two to four, and Chips and Cheese's 512-bit VNNI test goes from 1.99 to 3.88 instructions per cycle.
George Cozma published the microarchitecture breakdown on 10 Nov. VNNI instructions do the inner loop of quantized inference (running a model with smaller numbers to save memory) and some video filters. The denser Zen 6c core matches the result.
The trade, from the same article: integer multiply units drop from three to two, because AMD says Zen 5's third unit did not justify its area. L3 latency rises from about 47 cycles on Zen 5 to 55 on Zen 6 and 66 on Zen 6c. And 256-bit vector loads go to four per cycle, so 256-bit and 512-bit loads both reach 128 bytes per cycle.
These are one site's microbenchmarks. No LLM tokens-per-second figure is in the article, so it does not say how much faster a model runs.
If you run models on a CPU, would you rather have more vector throughput or lower cache latency?
https://t.co/DgzDg3iVyt
A CPU without SSE4.2 and POPCNT cannot run .NET 11. Microsoft raised the minimum from x86-64-v1 to x86-64-v2 on Windows, Linux and Apple, and moved the precompiled-code target on Windows and Linux up to x86-64-v3.
This is from Microsoft's 'What's new in the .NET 11 runtime' page, which says it was last updated for release candidate 2 (RC 2), so it describes the candidate, not the final release.
What changes:
- Minimum for JIT and AOT code: v1 to v2. v2 adds CX16, POPCNT, SSE3, SSSE3, SSE4.1 and SSE4.2. Microsoft says the last older chips went out of support around 2013.
- Precompiled (ReadyToRun) target on Windows and Linux: v2 to v3, which adds AVX, AVX2, BMI1, BMI2, F16C, FMA, LZCNT and MOVBE. A machine with v2 but not v3 still runs, but the page warns of extra startup work.
- Arm64: Windows now requires the LSE instruction set. The Linux minimum is unchanged, so Raspberry Pi class devices stay supported. Apple M1 is unchanged.
- On a CPU that is too old, the runtime prints a message like 'The current CPU is missing one or more of the baseline instruction sets.'
Check a Linux machine before you upgrade it:
grep -o -w -E 'cx16|popcnt|ssse3|sse4_1|sse4_2' /proc/cpuinfo | sort -u
Five names listed means the v2 minimum is met (SSE3 shows up as pni).
grep -o -w -E 'avx2|bmi2|fma' /proc/cpuinfo | sort -u
Three names listed means it has the main v3 features. That is a quick proxy, not the full v3 list.
On a virtual machine, run it inside the VM: the hypervisor decides which flags the guest sees.
https://t.co/L9QgmfCbl7
Google now has four TPU systems from one chip generation. The two new ones solve two different problems for agents.
TPU 8tx is for confidential inference (running a trained model on private data). Data is normally encrypted when stored and when sent, but sits unlocked in memory while it is processed. Google says 8tx keeps data and model weights isolated even while in use. It runs on the same silicon as TPU 8t with AMD EPYC hosts, and Google puts latency at up to 2x lower than 8t, with a near-zero performance penalty.
TPU 8i Max is for long context: two 8i chips on one package, with double the compute, double the SRAM (on-chip memory) and double the HBM bandwidth (memory speed) of the 8i, in the same rack footprint.
A 3-item check before an agent touches regulated data:
1. Is the data protected while it is being processed, not only stored and sent?
2. Are the model weights covered the same way?
3. What does that protection cost in latency?
All figures are Google's own, from its 9 Nov post, and the page gives no price or date for either system.
For sensitive data, which is the harder part of running agents: the speed, or being able to prove it stayed private?
https://t.co/jjH38WuOqg
Meta's Muse Ember matches Claude Haiku 5.5's best index score for about a third of the cost per task: 35.8 at $0.136, against 36.2 at $0.411. That is Meta's chart of Artificial Analysis results, published 9 Nov.
What it is: Meta's smallest Muse model, built for the work agents repeat all day (tool calls, routing, extraction, long documents). 1M-token context, up to 512K tokens of output, $0.10 per million input tokens and $0.50 per million output, on Meta's own API.
Index score and cost per task, from Meta's chart:
- Muse Ember: 33.9 for $0.116, 35.8 for $0.136
- Claude Haiku 5.5: 24.6 for $0.092, 29.6 for $0.159, 34.3 for $0.248, 36.2 for $0.411
- GPT-6 Luna: 21.4 for $0.073, 23.3 for $0.104, 27.8 for $0.152
Where Meta's table has it ahead, at max reasoning: AutomationBench-AA 37.8 against 20.2 for Luna and 13.9 for Haiku. Agents' Last Exam 61.6 against 57.1 and 57.0. Terminal-Bench 4.0 40.9 against 39.2 for Haiku and 16.4 for Luna.
Where it trails: FrontierCode 2.0-AA, real engineering tasks judged on whether the change is mergeable, 27.2 against 34.9 for Haiku. On GDP.pdf-AA, work over long documents, it ties Luna at 22.8.
Limits: Meta picked the benchmarks and the framing, Ember's costs are its own estimates at its proposed price, Agents' Last Exam is Meta's internal run, and the rivals are the two small tiers from Anthropic and OpenAI, nothing bigger.
https://t.co/069TxI9PfP
Kimi K3.1 Pro scores 65.7 on Terminal-Bench 4.0 in its own lab's table: ahead of GPT-6 Astra (58.2) and Claude Fable 5.1 (57.9), 0.7 behind Opus 5.5 (66.4). Open weights, 2.8T MoE, 104B active.
Moonshot's table, where it leads:
- Terminal-Bench 4.0: 65.7 vs 58.2 GPT-6 Astra, 57.9 Fable 5.1
- SWE Marathon v1.1: 51.7 vs 46.3 Opus 5.5
- BrowseComp: 92.1 vs 91.5 GPT-6 Astra
- HLE-Full with tools: 70.0 vs 67.7 Opus 5.5
Where it trails:
- Program Bench: 31.5 vs 65.0 Opus 5.5
- Terminal-Bench-Science 0.1: 38.1 vs 68.1 GPT-6 Astra
- HLE-Diamond: 39.4 vs 65.8 GPT-6 Astra
- ExploitBench: 74.7 vs 100 GPT-6 Astra
Fine print: Moonshot ran its own model with the Claude Code harness; the rival scores are the highest from those labs' blogs or public leaderboards. Not an outside test.
Licence: free to use and fine-tune, but a company selling model-as-a-service with over $20M in 12 months needs a separate deal (section 2). Not OSI. No Ollama page for K3.1 (checked today), and at 2.8T it is rented, not run at home.
For agent work: the open model with the published table, or the closed one that wins on Program Bench and the science test?
https://t.co/cdLrVsmSoV
Baidu released the base weights of ERNIE 5.5 Flash on 5 November: 280B parameters in total, 14B active per token, and the checkpoint straight out of pre-training, before any instruction tuning. So it is a starting point to fine-tune, not a chat model.
In Baidu's own table, against three base models of similar size (DeepSeek V4 Flash Base, Hy3 preview Base, MiMo V2.5 Base), it beats the best of the three on MMLU-Pro (78.4 vs 69.2), HumanEval+ (82.3 vs 78.0) and LiveCodeBench (40.1 vs 33.5). It falls behind on ChineseSimpleQA (73.0 vs 75.3), FullStackBench (54.6 vs 56.7) and HELMET-Rerank (56.2 vs 60.0).
Weights are on Hugging Face in FP8 and BF16. There is no Ollama page for it (checked today), and at 280B it is not a laptop model anyway.
The licence is Baidu's own (ERNIE 5.5 Flash Base Model License v1.0), not an OSI licence. Non-commercial use is free. Commercial use is free up to US$50 million a year in related revenue after a one-time notice to Baidu; above that you need written authorisation. And the grant only covers its "Territory": everywhere except the European Union, the United Kingdom and South Korea.
https://t.co/CFxF29CSkd
A self-hosted container kept failing to reach one site. Plain DNS lookups through most public resolvers returned one IP address; Cloudflare's DNS-over-HTTPS returned a different one. The first address belonged to the ISP.
Karthikey Hegde's write-up (3 November) corrects three assumptions that came up in the replies:
• DNSSEC signs answers, it does not encrypt them. Queries still travel in plain text, and validation only helps when the domain is signed. The post cites the October 2026 https://t.co/CC8014qCPb census: 7.03% of graded domains have a valid, fully validating DNSSEC chain.
• Running your own resolver (Unbound) does not hide queries either. It talks to several nameservers over plain DNS unless you forward to a resolver over DNS-over-TLS.
• DoH and DoT encrypt the trip, not the resolver. You still trust whoever runs it, and the ISP can still see hostnames in the TLS handshake (SNI).
If a service fails with "site cannot be reached" only on some networks, compare a plain dig with a DoH lookup before you debug the app.
https://t.co/8m1mq3rk0V
Ripple-65B Preview scores 80.5 on Terminal-Bench 2.1 in its own lab's table, level with or ahead of open models 8 to 15 times its size. 65B dense, Apache 2.0, out 4 Nov.
Ricursive's table, where it leads:
- Terminal-Bench 2.1: 80.5 vs 80.1 Reflection Beam 501B, 76.4 Muse Spark Open 816B, 63.8 Inkling 975B, 56.4 Nemotron 3 Ultra 550B
- SWE-bench Pro v2.0 Hard: 79.1 vs 76.5 Reflection
Where it trails:
- SWE-bench Verified: 76.5 vs 81.6 Reflection
- MCP Atlas: 71.7 vs 89.2 Muse Spark Open
- DeepSWE 1.1: 44.3 vs 60.0 Muse Spark Open
- GPQA Diamond: 85.2 vs 90.6 Reflection
Dense means all 65B parameters run on every token; those rivals are MoE. The lab says most models scored lower on Terminal-Bench under the official harness, some rival numbers are its own re-runs, and the release is a Preview with light post-training. 1M context, 12T training tokens, an NVFP4 build it says fits a DGX Spark. No Ollama page (checked today).
For a coding agent, which one do you run: the 65B model that fits on one box, or a 500B+ MoE that wins on SWE-bench Verified and tool use?
https://t.co/6ecC6hajUG