Monday, November 16, 2026
-
Project Zero drops 90+30 and moves to a fixed 30 day disclosure by 2028
Google Project Zero replaced its 90+30 policy with fixed disclosure deadlines counted from the vendor report: Full 90 now, Full 60 from February 2, 2027, and Full 30 from January 3, 2028. The 30 day patch soak, the grace period and the variant policy are gone, so severity and fix status no longer change the date. The team says LLMs speed up both finding and exploiting bugs, and that it now finds "several vulnerabilities a week" in targets where it once found a few a year.
Heat · HN front page, 312 points and 192 comments; rated HIGH in the Cloud Security Alliance CISO Daily Briefing of November 15What people foundProject Zero argues that attackers can now read a patch and build an exploit almost at once, so keeping details secret after a fix buys little. For teams that ship software, the practical result is that the gap between a fix release and your users installing it becomes the risk window, and that window now has a public clock that halves twice in 14 months. Exceptions remain for bugs exploited in the wild, bugs already public and vendor requests.Learn it15 min · 5 steps
Key ideas
- Coordinated disclosure deadline
- A fixed number of days after a researcher reports a bug to a vendor, after which the details are published whether or not a fix exists.
- Patch soak
- The extra 30 days the old policy waited after a fix shipped so users could install it before technical details went public.
- Patch gap
- The time between a vendor releasing a fix and users actually running it, which attackers can exploit by studying the fix.
Steps
- Read the Project Zero post of November 13 first and write down the three deadlines with their start dates.
- List what was removed, namely the patch soak, the grace period and the variant policy, and note the exceptions that survive.
- Read the LLM rationale section and summarize in one sentence why the team now treats patch to exploit time as near zero.
- Skim the HN thread for vendor and maintainer objections and pick the strongest one.
- Self check: if a vendor ships a fix on day 50 of a Full 60 window, when do the details become public, and what changed compared with 90+30?
Try it30 min · 5 steps
You need: A repo you own with a lockfile, a terminal, and a dependency audit tool your ecosystem provides, such asnpm auditorpip-audit. No API key needed.Steps
- Pick one service you own and run your ecosystem's dependency audit against its lockfile.
- For each finding, record the date the advisory was published and the date your project picked up the fixed version.
- Compute the median days from advisory to upgrade across the findings.
- Compare that median with 90, 60 and 30 days and mark which findings would have been public before you patched under each window.
- Write a one paragraph upgrade policy for the team, such as a weekly automated dependency update job, that keeps the median under 30 days.
Small angles to try
- Repeat the measurement for container base images instead of language packages.
- Check your git history for how long security pull requests from a dependency bot waited before merge.
- Map which of your vendors ship fixes on a fixed monthly cycle and how that fits a 30 day window.
-
DeepSeek-V3's architecture rebuilt in about 190 lines of plain JAX
An MIT licensed repo implements the core ideas of DeepSeek-V3 in about 190 lines of JAX with no Flax or PyTorch: Multi-head Latent Attention, a mixture of experts with 1 shared and 16 routed experts using top 4 routing, bias based load balancing without an auxiliary loss, and multi token prediction. The author pretrained a 36.2M parameter version with 13.6M active per token on an M5 MacBook Air, and validation loss fell from 5.02 to 3.51 in about 2.6 hours.
Heat · Show HN front page, 273 points and 28 commentsWhat people foundThe README is candid that this is "an architecture demo, not a strong language model". Every expert runs on every token, so the routing math is exact but there is no sparse speedup, and checkpoints are Python pickles that can run code when loaded. Its value is as a readable reference: the attention cache drops from 480 to 144 numbers per token per layer, and the ablation shows expert load stays near an even split with the bias and swings from 0.09 to 18.6 percent without it.Learn it15 min · 5 steps
Key ideas
- Multi-head Latent Attention
- Keys and values are compressed into a small shared latent vector per token, so the inference cache is much smaller than in standard attention.
- Bias based expert balancing
- Each expert gets a routing bias that is nudged up when it is underused and down when it is overused, which evens out load without an extra loss term.
- Multi token prediction
- An extra head is trained to predict a token further ahead, giving the model a denser training signal.
Steps
- Read the repo README first, especially the configuration table and the warnings section.
- Open
deepseek_v3.pyand find the attention function; trace where the latent vector is created and what gets cached. - Find the router and note where the balancing bias is added for selection but not for the expert weights.
- Look at the ablation numbers in the README comparing expert load with and without the bias.
- Self check: why does this repo train slower than a real MoE even though only 4 of 16 routed experts are selected per token?
Try it30 min · 6 steps
You need: Python 3.12 and uv. An Apple Silicon Mac is used for the GPU path; other machines can use the CPU config. No API key needed.Steps
- Clone the repo, then create the environment with
uv venv -p 3.12 .venvand install the pinned packages withuv pip install --python .venv/bin/python -r requirements.txt; do not upgrade JAX. - Run the test suite on CPU with
JAX_PLATFORMS=cpu .venv/bin/pytest tests.py -qand confirm 39 tests pass. - Build the dataset with
.venv/bin/python prepare_data.py, which downloads about 120 MB of public domain books. - Start a short CPU run with
JAX_PLATFORMS=cpu .venv/bin/python train.py --config smalland stop it after a few logged steps. - On a Mac, run the two 2000 step ablations,
train.py --steps 2000 --out runs/bias_onand the same with--no-bias, then compare expert load in eachmetrics.jsonl. - Load only checkpoints you trained yourself, since
ckpt.pklis a pickle.
Small angles to try
- Change top 4 routing to top 2 in the config and watch the active parameter count and loss.
- Print the cache size per token for MLA versus a plain attention cache using the config values.
- Set the multi token prediction loss weight to zero and compare validation loss at step 2000.
-
Raschka maps how 2026 LLMs encode position: RoPE leads, NoPE rises
Sebastian Raschka's new explainer walks through learned absolute embeddings, sinusoidal encodings, RoPE, partial RoPE, NoPE and learned relative position bias, with current models as examples. MiniMax-M3 rotates 64 of 128 head dimensions, SmolLM3 skips RoPE in every fourth layer, and Thinking Machines' Inkling uses a learned relative position bias. Full RoPE in every layer is still the most common choice in his 2026 model gallery, but its share fell from 2025, while partial RoPE became the majority among RoPE models.
Heat · HN front page, 228 points and 27 commentsWhat people foundRaschka's view is that partial RoPE is "hardly worth it" in most cases: a cited study on 1B to 8B models found rotating about 10 percent of head features often matched full RoPE, and halving the rotation tables for MiniMax-M3's 1M token context saves only about 0.134 GB in BF16 because the KV cache still stores full keys and values. Check which scheme a model uses before porting it or extending its context.Learn it15 min · 5 steps
Key ideas
- RoPE
- Rotary position embedding rotates query and key vectors by an angle that depends on position, so attention scores reflect relative distance.
- Partial RoPE
- Only a subset of each attention head's dimensions is rotated, leaving the rest position free.
- NoPE
- A layer with no explicit position signal, which still learns order from the causal mask.
Steps
- Read Raschka's Ahead of AI post of November 15 first, focusing on the RoPE and partial RoPE sections.
- Open the standalone Qwen3 notebook in his LLMs-from-scratch repo and find the function that applies RoPE.
- Open the MiniMax-M3 config.json on Hugging Face and find the setting that controls how many dimensions are rotated.
- Compare with SmolLM3's layer pattern described in the post and note how NoPE layers are marked.
- Self check: why does partial RoPE barely reduce KV cache memory even though it rotates fewer dimensions?
Try it30 min · 5 steps
You need: Python 3 with NumPy, or a Jupyter notebook. No API key needed.Steps
- Write a small NumPy function that applies RoPE to a query and a key vector of size 128 at given positions.
- Verify that the dot product of the rotated query and key depends only on the position difference by testing positions 3 and 7 against 103 and 107.
- Change the function to rotate only the first 64 dimensions and repeat the check to see which part still carries relative position.
- Compute the size of the cos and sin tables for a 1M token context at head size 128, full versus half rotation, in BF16, and compare with the 0.134 GB figure in the post.
- Download two or three open model config.json files you use and record which position scheme each declares.
Small angles to try
- Plot attention score versus distance for full and partial RoPE with random vectors.
- Remove position encoding entirely and confirm that without a causal mask the scores no longer depend on order.
- Repeat the table size math for a 128K context to see when the savings matter.
-
Brave Search API lets agents pay per request over x402, no API key
Brave's Search API now accepts payment per request over the open x402 protocol. A call without payment returns HTTP 402 with the price, the agent signs a USDC payment on Base and retries, and the results come back with an on chain receipt. Every endpoint, including the LLM Context endpoint for grounding agents plus web, news, image, video and local, costs $0.005 per request.
Heat · HN front page, about 254 points and 143 commentsWhat people foundAgents can buy search with no account, plan or API key, which turns tool access into a payment problem instead of a credentials problem. For now only USDC on Base works, Brave runs its own facilitator to verify payments, and it covers gas fees "for a limited time" with no end date given. The blog post is dated November 12.Learn it15 min · 5 steps
Key ideas
- HTTP 402 Payment Required
- A long reserved status code that x402 uses to tell a client the price and how to pay before retrying.
- x402 facilitator
- The service that checks a signed payment and settles it so the API server can trust it without running blockchain code itself.
- Stablecoin on Base
- USDC is a token pegged to the US dollar, and Base is the low fee blockchain network where the payments settle.
Steps
- Read the Brave blog post first and write down the four step request, 402, sign, retry flow.
- Open the Brave agent payments guide linked from the post and find what the 402 response body contains.
- Note the limits: one token, one network, Brave's own facilitator, temporary gas coverage.
- Skim the HN thread for arguments on cost control and abuse, then decide how you would cap an agent's spending.
- Self check: what does an agent need to hold before it can make its first paid request, and what replaces the API key?
Try it30 min · 5 steps
You need: Python 3 or Node on your own machine. No API key, wallet or real money needed for the mock version.Steps
- Write a tiny local HTTP server that returns status 402 with a JSON body giving a price and a payment address when no payment header is present.
- Write a client that calls the server, reads the 402 body, checks the price against a budget limit you set, and retries with a fake signed payment header.
- Make the server accept the header, return results plus a fake receipt id, and log every charge.
- Add a per session spending cap to the client and confirm it refuses once the cap is reached.
- Estimate a real bill: count search calls in one of your agent traces and multiply by $0.005.
Small angles to try
- Add a second priced endpoint and let the client pick the cheaper one when both answer the question.
- Simulate a server that raises its price mid session and check that the client notices.
- Compare the per request cost with your current search API plan at your real monthly volume.
-
Free AI tiers × faster models: Gemini 4 Hydrogen reaches free users
Google released Gemini 4 Hydrogen on November 12 as a fast, cheaper Gemini 4 model for everyday coding and agent tasks, and says it finishes tasks about 2.5 times faster than Gemini 3.8 Flash. Free Gemini app users get it through automatic model selection, which picks a model per prompt, and it also runs in Google Search for all users. It scores 51 on the Artificial Analysis Intelligence Index and costs $1.50 per million input tokens and $7.50 per million output tokens through the API, with a 1M token context.
Heat · #7 in the ITmedia NEWS access ranking and #4 in the ITmedia AI+ ranking on November 16; the Gemini app is #5 among free apps in Japan and #9 in the US App Store chartsWhat people foundThe earlier Gemini 4 Carbon news was about paid API users; the shift here is that ordinary free users now get a Gemini 4 model without choosing it. For builders, the flat $1.50 and $7.50 pricing undercuts Carbon's $2 and $10 introductory rate, which rises to $4 and $20 on December 1. The model card reports over refusals up 5.57 points versus 3.8 Flash, most visible on prompts with images.Learn it15 min · 5 steps
Key ideas
- Automatic model selection
- The app decides which model answers each prompt, so free users can be served a newer model without picking it.
- Reasoning levels
- Hydrogen offers low, medium, high and a new xhigh setting, trading wait time and cost for deeper thinking, with high as the default.
- Over refusal rate
- How often a model declines a harmless request, which the model card says rose most on prompts with images.
Steps
- Read the ITmedia NEWS article of November 13 first for availability, pricing and model card notes.
- Read the Impress Watch article and compare how each outlet describes who gets the model for free.
- List where Hydrogen appears: free app, Search, AI Studio and Gemini API, Android Studio, Firebase AI Logic.
- Compare its price with Carbon's introductory and post December 1 prices.
- Self check: why might a free user never know which model answered, and how does that change how you judge free tier quality?
Try it30 min · 5 steps
You need: A free Google account and a browser, plus a spreadsheet. No API key needed.Steps
- Write ten everyday prompts from your own work, for example code explanation, a regex, a short refactor and a log summary.
- Run all ten in the free Gemini app, timing each response with a stopwatch and noting answer quality on a 1 to 5 scale.
- Add three prompts that include your own screenshots or diagrams and note any refusals.
- In a spreadsheet, estimate the monthly API cost of one of your agent loops at $1.50 input and $7.50 output per million tokens versus Carbon's $4 and $20 after December 1.
- Write two sentences on whether the free tier is good enough for your daily tasks.
Small angles to try
- Repeat three of the prompts in Google Search's AI answers and compare.
- Run the same prompts in another free chatbot tier and compare speed and refusals.
- Vary the token mix in the cost sheet to see when output price dominates.
-
Zyphra ZONOS3-Mini: Apache 2.0 text to speech that runs in the browser
Zyphra released ZONOS3-Mini, an open weight text to speech model built as a mixture of experts with about 800M total and about 100M active parameters per token, covering 43 languages and cloning a voice from a short reference clip. The model card says it runs in real time on phones, laptops and in the browser through WebGPU, and lists runtimes including an MLX server, a ggml C++ build, Ollama, LM Studio and SGLang-Omni with an OpenAI compatible speech endpoint. The technical report went up around Nov 12.
Heat · Hugging Face trending list on Nov 16; model card shows 413 likes and 39,862 downloads last monthWhat people foundZyphra reports 80 ms median time to first audio at 8 concurrent requests and a peak of 457 seconds of audio per second on one H100. The card gives no matching numbers for laptops or phones, so latency on consumer hardware is something to measure yourself.Learn it15 min · 5 steps
Key ideas
- Mixture of experts
- A model where each token only passes through a few expert sublayers, so compute per token tracks the active parameters, not the total.
- Time to first audio
- How long a speech server takes to send the first playable chunk, which decides whether a voice agent feels responsive.
- Speaker embedding
- A vector computed from a reference recording that tells the model which voice to imitate.
Steps
- Read the ZONOS3-Mini model card on Hugging Face from top to the runtimes table.
- Note the split between 800M total and about 100M active parameters and why that helps on small devices.
- Look at the SGLang-Omni section to see the OpenAI compatible
/v1/audio/speechrequest shape. - Compare the H100 latency figures with what a paid text to speech API you use promises.
- Self check: why can a model with 800M parameters cost about as much per token as a 100M model?
Try it30 min · 5 steps
You need: Python and an NVIDIA GPU for the Zonos or SGLang-Omni path, or a Mac or PC with Ollama installed; a short recording of your own voice. No API key needed.Steps
- Record 5 to 10 seconds of your own voice and save it as
speaker.wav. - Install the Python package with
pip install git+https://github.com/Zyphra/Zonos.git. - Load
Zyphra/ZONOS3-Miniwith the Zonos class as shown on the model card, build a speaker embedding from your clip and generate one English sentence. - On a GPU box, start the server with
sgl-omni serve --model-path Zyphra/ZONOS3-Mini --port 8000and POST a JSON body with aninputfield tohttp://localhost:8000/v1/audio/speech. - Time ten requests and write down the first audio latency on your hardware next to the vendor's H100 figure.
Small angles to try
- Try
ollama run hf.co/Zyphra/ZONOS3-Minion a laptop and compare speed with the GPU run. - Generate the same sentence in two non English languages and judge pronunciation.
- Point an existing OpenAI speech client at the local endpoint and see what breaks.
Sources:Hugging Face model card -
Corelight: pinned MCP servers ran 15 dependency sets in five weeks
Corelight found that one community MCP server pinned to a single release and commit ran with 15 distinct dependency sets over five weeks, with 23 of its 69 packages changing versions, because one step launchers like
uvxandnpxresolve dependencies again on launch. Of 35 MCP servers reviewed, 23 recommended installs that pull fresh from public registries, and the test workstation's MCP servers made more than 1,600 connections in a week to 11 management systems including the firewall and SIEM. Five servers frozen with lock files pinned by hash kept identical package lists across 457 starts, and startup fell from 4 to 11 seconds to about 2.Heat · Help Net Security story on Nov 13 and a HIGH priority entry in the CSA CISO Daily Briefing of Nov 15; the Corelight post itself is dated Nov 10What people foundJames Lagermann of Corelight puts it plainly: pinning the server does not pin its dependencies. For any MCP server that holds credentials, install once from a lock file pinned by hash into its own environment, launch the installed binary directly, and turn off update checks at startup.Learn it15 min · 5 steps
Key ideas
- Transitive dependency drift
- Your direct package stays the same while the packages it depends on move to new versions on every fresh install.
- Hash pinned lock file
- A file listing every package at an exact version with a checksum, so the installer refuses anything that differs.
- One step runner
- Tools like
uvxandnpxthat fetch, resolve and run a package in one command, often doing a fresh resolve each time.
Steps
- Read the Corelight post on MCP server supply chain risk, focusing on the findings list.
- Look at its two anti pattern examples, a
uvx --from git+...@<tag>launch and annpx <proxy>@latestlaunch. - Read the eight mitigations and match each one to a failure in the findings.
- Skim the Help Net Security write up for the short version.
- Self check: why does pinning a git commit of the server still leave you exposed?
Try it30 min · 5 steps
You need: Your own machine with an MCP client config, such as a coding agent's settings file, plus Python or Node. No API key needed.Steps
- Open your own MCP client config and list every server whose command is
uvx,npxor another one step runner. - For one Python based server, resolve its dependencies twice on different days, or compare against the runner cache, and diff the package lists.
- Create a dedicated virtual environment for that server, generate a lock file with hashes for your platform, and install with hash checking enforced.
- Change the config to launch the installed server executable directly and confirm the agent still sees its tools.
- Measure startup time before and after the change.
Small angles to try
- Do the same for one Node based server using a committed lock file and a clean install.
- List which credentials each MCP server can reach and remove any it does not need.
- Check whether any server or proxy is set to a
latesttag.
-
Perplexity releases Decider v1.3 open weight classifier and reranker
Perplexity released Decider v1.3, a decision model that returns a probability distribution over options for yes or no, multiple choice and score questions, answering several questions about the same input in one forward pass. Version 1.3 adds locate, which extracts exact text spans for tasks like named entity recognition, PII detection and extractive QA. The large model is built on Qwen3.8-27B and a Flash version is distilled onto Qwen3.5-4B, both with Apache licensed weights on Hugging Face and listed on OpenRouter.
Heat · Hacker News, 123 points and 22 commentsWhat people foundPerplexity reports 91.6% mean accuracy across 63 query classification tasks, 6.54 points above its production classifiers, and a mean nDCG@10 of 83.99 over 72 retrieval tasks, 1.81 above Qwen3-Reranker-8B. Answers changed on only 0.27% of questions when labels and options were shuffled. All figures are vendor reported.Learn it15 min · 5 steps
Key ideas
- Decision head
- A small linear layer that reads one marked position and turns it into scores over the allowed options, instead of generating free text.
- nDCG@10
- A ranking score that rewards putting the most relevant documents in the top ten results.
- Distillation
- Training a smaller student model to match the output distribution of a larger teacher.
Steps
- Read the Perplexity Decider blog post, especially the prompt format and locate sections.
- Note how state, questions and option labels are laid out and where the prediction is read.
- Open the
perplexity-ai/pplx-decider-flash-v1.3model card on Hugging Face to see the Python API. - Compare the robustness figure with how often your own LLM judge flips when options are reordered.
- Self check: why does a probability over fixed options make routing easier than parsing generated text?
Try it30 min · 5 steps
You need: Python 3.12 or newer, a CUDA GPU with room for about 8.5 GiB of BF16 weights, and a Hugging Face token if the repo asks for access. No paid API key needed.Steps
- Download
perplexity-ai/pplx-decider-flash-v1.3withhuggingface_huband install the bundled requirements and source package as the model card describes. - Load the model with the bundled Decider class on your GPU.
- Write 20 support tickets or queries from your own data and ask one choice question that routes each to a team.
- Compare the predicted label and its probability with what your current LLM prompt returns.
- Shuffle the option order and rerun to see whether any answer changes.
Small angles to try
- Use the score question type to rate the relevance of 10 search results and compare with your reranker.
- Try a locate question to pull a city or a product name out of free text.
- Call the larger model through OpenRouter and compare it with Flash on the same set.
-
Agweb: a macOS WebKit browser that coding agents drive from the shell
Agweb is an MIT licensed browser that agents control with an
agwebcommand in the style of playwright-cli, using actions such as open, snapshot and click. Its windows never steal focus, a dashboard shows every agent's tabs, each action can return a diff of what changed, and each agent gets its own workspace. It also offersfill --secret-cmdto type secrets the model never sees andaskto hand a tab to a human for MFA or a CAPTCHA.Heat · Show HN on Nov 14 with 90 points and 26 comments; 231 GitHub starsWhat people foundThe trade off is stated in the README: it is WebKit only with no Chrome DevTools Protocol, so Playwright and Chrome extensions cannot attach, Chrome only sites may misbehave, and it needs macOS 26 or later. The author recommends Playwright for anything it does not cover.Learn it15 min · 5 steps
Key ideas
- Accessibility snapshot
- A tree of page elements with short reference handles that an agent can read and act on instead of raw HTML.
- Snapshot diff
- Returning only what changed after an action, which keeps the agent's context small.
- Human handoff
- Pausing the agent and giving a person the tab for steps like login, MFA or CAPTCHA.
Steps
- Read the agweb README on GitHub from the overview to the limitations list.
- Study the CLI examples for
open,snapshot,click,fill --secret-cmdandask. - Note how
-wworkspaces and-pprofiles separate agents and shared logins. - Skim the Show HN thread for objections about WebKit and CDP.
- Self check: what does an agent lose when the browser offers no Chrome DevTools Protocol?
Try it30 min · 5 steps
You need: A Mac on macOS 26 or later; Xcode 26 only if building from source. No API key needed.Steps
- Download
Agweb.dmgfrom the GitHub Releases page, drag it to Applications and open it. - Use the Help menu to install the command line tool, and optionally the agent skill for Claude Code or Codex.
- Run
agweb -w demo open https://example.comand thenagweb -w demo snapshotto see the element tree. - Click an element with
agweb -w demo clickand a role selector, then runagweb -w demo snapshot --diff. - On a site where you own the account, try
fill --secret-cmdwith your local password manager CLI and confirm the secret does not appear in the output.
Small angles to try
- Run two workspaces at once and watch them in the dashboard.
- Use
askon a login page and finish it by hand. - Compare token counts of a full snapshot and a diff on the same page.
-
Antigravity /teamwork: Lean Weil conjectures, Borg gains, STOC reviews
A Google Research post on Nov 13 describes /teamwork in Antigravity, a system that runs many agents in parallel and checks their work with verifiers such as the Lean 4 proof checker, test suites and simulators. Reported results include about 1.8 million lines of Lean formalizing the Weil conjectures over 28,800 subagent invocations, a 24% cut in TPU preemption on some hardware from agentic Borg scheduling, and a 4.09x geometric mean speedup on 17 JAXBench kernels. The post says outside scientists and developers can now use /teamwork and /boost with Gemini 4 models in Antigravity, though some patterns are still rolling out.
Heat · Hacker News, 160 points and 36 commentsWhat people foundAuthors of 578 STOC 2027 submissions, over a third of the total, opted into AI Deep Review; in an ongoing survey of 70, 90% called the feedback mostly factual and over 30% said it caught substantive proof bugs or significant typos. These are Google's own and self reported numbers, and the pattern worth copying is the loop built around a hard automated check, not the agent count.Learn it15 min · 5 steps
Key ideas
- Verifier first loop
- Agents propose many candidates and only those passing an automated check, like a proof checker or test suite, survive.
- Lean 4
- A proof assistant whose checker accepts a proof only if every step is formally valid.
- Geometric mean speedup
- An average of speedup ratios that keeps one huge win from hiding many small ones.
Steps
- Read the Google Research blog post on Antigravity's /teamwork feature, focusing on how verifiers gate results.
- List each result and name the verifier behind it: Lean, test suites, benchmarks or production SLOs.
- Open one linked public repo, such as the Lean 4 splay tree bound, to see what checked output looks like.
- Read the STOC Deep Review survey figures and note what self reported means for them.
- Self check: which task in your own work has an automated check strict enough to run this loop?
Try it30 min · 5 steps
You need: Antigravity with access to /teamwork for the hosted path, or any coding agent plus a repo of your own with a fast test suite. No API key needed for the local variant beyond your agent's usual setup.Steps
- Pick a small function in your own repo with a failing or missing test and write the test first as the verifier.
- Ask a coding agent for three independent attempts in separate branches or worktrees without sharing context.
- Run the test suite on each attempt and keep only the ones that pass.
- Have a fresh agent session review the passing diffs as a critic with no prior context.
- Record how many attempts passed and whether the critic found anything the tests missed.
Small angles to try
- If you have Antigravity access, run the same task through /teamwork and compare.
- Use a benchmark script as the verifier and optimize one slow function for speed.
- Clone the public Lean splay tree repo and build it to see a verified artifact end to end.
-
Weight Space Misfolding: one model edits another model's weights
Researchers had a frontier model, named ChatGPT 6.1-Sol on the paper page, edit the weights of Qwen2.5-1.5B-Instruct directly, with no gradient training, to cause unauthorized behavior changes. A factual swap worked on 100 of 100 draws while control passes fell only from 49 to 48, but a forced refusal sentence landed on 5 of 22 prompts and a supplier omission on just 1 of 22, with collateral damage along the way. On the authors' IWIBench editing benchmark, mean reward rose from 0.2148 to 0.4250 in under five months, and they state they did not show self propagation or real world offensive capability.
Heat · HN 145 points and 59 commentsWhat people foundThe authors argue that signing a model only shows who changed it, not whether the change was acceptable, so teams need provenance, a list of behaviors that must survive, and inspection of patches against a trusted base before deployment.Learn it15 min · 5 steps
Key ideas
- Weight space misfolding
- The paper's name for one model directly rewriting another model's parameters so it behaves in a way nobody authorized.
- Deep Patch Inspection
- Checking an identifiable patch by comparing the changed model against a trusted base model.
- Collateral damage
- Unrelated behavior that breaks when a targeted edit is applied, such as a control prompt that starts failing.
Steps
- Read the alphaXiv abstract and the results for the three probes first.
- Note which probe succeeded reliably and which mostly failed, and what the editor itself reported.
- Read the defenses section on provenance, preserved behaviors, Deep Patch Inspection and Broad Weight Inspection.
- Skim the HN thread for how engineers map this to model supply chains.
- Self check: why do the authors say authentication alone is not enough to trust a received model?
Try it30 min · 5 steps
You need: Python 3 with the safetensors, torch and huggingface_hub packages, about 10 GB of disk, CPU is enough. No API key needed.Steps
- Download two public checkpoints of the same small architecture to your own machine, for example a base model and its instruct variant from the same family.
- Record a sha256 hash of every weight file with
sha256sumand save the list as your provenance record. - Write a short script that opens both files with the safetensors library and, for each tensor with matching name and shape, computes the relative change as the norm of the difference divided by the norm of the base tensor.
- Sort tensors by relative change and plot or print the top 20 to see which layers fine tuning moved most.
- Run a fixed set of 20 of your own prompts through both models and log which answers differ, as your list of behaviors to preserve.
Small angles to try
- Rehash the files a week later and compare against your saved list.
- Diff an official checkpoint against a community quantized or merged copy you downloaded.
- Group the per tensor changes by layer type, attention versus MLP versus embeddings.
-
NVIDIA serves 753B GLM-5.3 at 607.8 tok/s on two DGX Stations
An NVIDIA technical blog shows GLM-5.3 NVFP4, with 753B total and 40B active parameters and a checkpoint of about 464 GB, served with tensor parallelism of 2 across two DGX Stations, each with a 252 GB GB300 GPU, linked by ConnectX-8 RDMA. Using vLLM v0.30.0 with 4 token MTP speculative decoding, FP8 KV cache and prefix caching, total throughput peaked at 607.8 tok/s at concurrency 16 and fell to 385.0 at concurrency 32, while per user speed dropped from about 115 to about 13 tok/s. The post lists failure checks: verify the network first, confirm identical checkpoints on both nodes, confirm NCCL really uses RDMA, and lock down the unauthenticated endpoint.
Heat · HN 146 points and 70 commentsWhat people foundPast the peak, more users made the whole system slower, not just each user: mean request latency jumped from 136 s at concurrency 16 to 454 s at 32. The post also notes the container bundles NCCL 2.30.7, and older NCCL versions risk cross node CUDA graph deadlocks on RoCE.Learn it15 min · 4 steps
Key ideas
- Tensor parallelism
- Splitting each layer's matrices across GPUs so a model too big for one GPU can run, at the cost of network traffic every layer.
- MTP speculative decoding
- A small draft head proposes several tokens ahead and the main model verifies them in one pass, which helps only when drafts are often accepted.
- Socket fallback
- When NCCL cannot use RDMA it quietly falls back to ordinary TCP sockets, which still works but is much slower.
Steps
- Read the NVIDIA blog post, starting with the results table and the lessons learned section.
- Look at the
vllm servecommand and note which flags control memory:--max-model-len,--max-num-seqs,--kv-cache-dtype fp8and--enable-prefix-caching. - Read the RDMA check that searches NCCL logs written with
NCCL_DEBUG=INFOfor GPU Direct RDMA lines and for socket fallback. - Self check: why did throughput fall between concurrency 16 and 32 even though more requests were in flight?
Try it30 min · 5 steps
You need: One Linux machine with an NVIDIA GPU, Docker or a Python env with vLLM installed, and a small open weight model that fits your GPU. No API key needed.Steps
- Serve a small model on your own GPU with
vllm serveplus--kv-cache-dtype fp8 --enable-prefix-caching, bound to localhost only. - Write a small async client that sends a fixed set of your own coding prompts at concurrency 1, 8, 16 and 32, recording total tokens per second and mean latency.
- Plot total throughput and per user throughput against concurrency and find your peak.
- Restart with a lower
--max-num-seqsset to your peak and rerun the sweep to see whether tail latency improves. - Confirm the server is not reachable from other machines on your network before leaving it running.
Small angles to try
- Repeat with prefix caching off to measure how much shared prompts help.
- Halve
--max-model-lenand see how the peak concurrency shifts. - If you have two GPUs, set
NCCL_DEBUG=INFOwith tensor parallelism of 2 and read which transport NCCL picked.
-
SO-Arena: fast decision models score high but decide unreliably
NUS researchers released SO-Arena, a benchmark for System One models, meaning models that make fast general decisions without long token generation, across 11 domains, five capability families and interactive sandbox tasks. Reliability is tested by changing the option set and by checking whether a model notices when no valid option is offered. Across 21 models, gains from scaling and added reasoning varied a lot by domain, and the best overall System One model ranked only seventh on reliability.
Heat · Top paper on Hugging Face Daily Papers for Nov 13, 138 upvotesWhat people foundIf a small model acts as a router, judge or guard in an agent stack, test it with shuffled options and a case where no option is right, not only on accuracy.Learn it15 min · 4 steps
Key ideas
- System One model
- A model used for quick one shot decisions, like picking a label or route, rather than long step by step reasoning.
- Decision stability
- Whether a model keeps the same answer when options are reordered or irrelevant options are changed.
- Missing answer recognition
- Whether a model says no option fits when the correct answer has been removed.
Steps
- Read the abstract on the Hugging Face paper page for arXiv 2611.15777.
- Open the SO-Arena GitHub repo and the dataset card to see how option perturbations are built.
- Compare the overall leaderboard with the reliability ranking and note which models move most.
- Self check: why can a model with high accuracy still be a poor router?
Try it30 min · 5 steps
You need: Python 3, any local or hosted classifier or small LLM you already use for routing, and 50 of your own labeled examples. No API key needed with a local model.Steps
- Collect 50 real inputs your router or guard sees, each with the correct label from a fixed option list.
- Measure plain accuracy with the options in their usual order.
- Rerun with the option order shuffled three times and count how many inputs change answer.
- Remove the correct option for 10 inputs, add a none of these choice, and count how often the model picks it.
- Report accuracy, flip rate and missing answer rate side by side.
Small angles to try
- Compare a small fast model with a larger reasoning model on the same set.
- Try the same test on a few items from the SO-Arena dataset.
- Rename option labels, for example letters versus words, and check for flips.
-
Haru-4B: open full duplex voice base model on Qwen3.5-4B
higurashi-ai released Haru-4B, a research base model for full duplex spoken dialogue that listens and speaks at the same time. Built on a Qwen3.5-4B text backbone, it emits a frame every 133 ms, 7.5 Hz, using 64 dimension continuous audio latents from the VibeVoice tokenizer instead of discrete audio tokens. It covers nine languages including Japanese, Chinese and Korean, takes a text character card plus a reference voice clip, and is licensed Apache-2.0.
Heat · Hugging Face trending #13 with 265 likes; the model page now shows 357 likes and 2,098 downloads last monthWhat people foundThe model card is blunt: it is a pretrained conversational base, not an instruction following assistant and not a reliable source of facts. It can imitate a reference voice, so use only voices you have the right to use.Learn it15 min · 4 steps
Key ideas
- Full duplex dialogue
- Both sides can talk at once, so the model can be interrupted or backchannel instead of waiting for a turn to end.
- Continuous audio latents
- Audio represented as small vectors of real numbers per frame rather than picked from a fixed codebook of tokens.
- Base model
- A model trained to continue conversations naturally, without the instruction tuning that makes it follow commands.
Steps
- Read the Haru-4B model card on Hugging Face, especially the architecture and limitations sections.
- Note the frame rate and work out how many frames make up one second of speech.
- Look at how the character card and the reference clip each steer the model.
- Self check: why does a 133 ms frame make interruption feel more natural than a turn based voice pipeline?
Try it30 min · 5 steps
You need: Linux with an NVIDIA GPU of about 12 GB, Python 3, git, wired headphones and a wired microphone. No API key needed.Steps
- Clone the code with
git clone https://github.com/higurashi-ai/Haru && cd Haru. - Install it with
pip install -e ./haru. - Start the server with
python -m haru.server --hf-repo higurashi-ai/Haru-4Band open http://localhost:8998. - Record a 10 second clean clip of your own voice and use it as the reference voice.
- Talk over the model mid sentence and note how quickly it yields or keeps going.
Small angles to try
- Swap the character card text and compare the personality and pacing.
- Try Japanese or Spanish and compare naturalness with English.
- Use Bluetooth headphones once and notice the added delay the card warns about.
-
Edge0-145B: 4 bit native MoE claims to run on one 24GB GPU
Edge0 published Edge0-145B-NVFP4, a sparse MoE with 145B total and about 10.1B active parameters, 512 experts per layer with 10 routed plus 1 shared, and 256K context. The card says it was trained natively at 4 bits rather than quantized afterwards, with the expert layer of Qwen3.8-Flash-Next rebuilt as a latent MoE and post trained on Edge0 data. Builds come as NVFP4 at 47.79 GiB and Q3_K at 40.81 GiB, with a separate Edge0 inference engine.
Heat · Hugging Face trending #14 with 274 likes; the model page now shows 301 likes and 41,606 downloads last monthWhat people foundAll numbers are self reported on an RTX 5090 D 24GB: 98.3 tok/s agent decode, 3,165.7 tok/s at 16K prefill, and 86.5 on Terminal-Bench 2.1 versus 83.3 for the Qwen base. The custom license needs a separate written deal for commercial model serving or bundling.Learn it15 min · 4 steps
Key ideas
- Mixture of Experts
- Each token only uses a few expert sub networks, so a huge model costs about as much per token as a much smaller one.
- Native 4 bit training
- The model learns with low precision weights from the start, instead of being trained in high precision and compressed later.
- NVFP4
- NVIDIA's 4 bit floating point format with small block scales, supported natively on recent NVIDIA GPUs.
Steps
- Read the Edge0-145B-NVFP4 model card, starting with the architecture table.
- Work out why 145B total parameters can fit on 24 GB plus system RAM when only about 10B are active per token.
- Read the license section and list what needs a separate commercial agreement.
- Self check: which claims on the card would you need to reproduce before using it for agent work?
Try it30 min · 5 steps
You need: A Linux machine with a recent NVIDIA GPU of 24 GB plus ample system RAM, or 16 GB VRAM plus 20 GB RAM for the constrained mode the card describes, and about 50 GB of disk. No API key needed.Steps
- Read the license and confirm your use is personal, research or internal.
- Download the NVFP4 build and build the Edge0 engine following the repository instructions.
- Start it with
build/cpu/bin/edge0-infer serve --model /path/to/Edge0-145B-NVFP4, bound to your own machine. - Time decode speed on 10 of your own coding prompts and compare with the 98.3 tok/s claim.
- Run the same prompts on a model you already trust and compare answer quality side by side.
Small angles to try
- Measure prefill speed on a 16K token prompt from your own codebase.
- Try the constrained memory setup and compare with the reported 36.8 tok/s.
- Check whether quality holds on long context tasks near 32K tokens.
Sources:Hugging Face: Edge0-145B-NVFP4 -
llama.cpp and ggml reach v1.0.0 with a semantic versioning promise
After about three and a half years of development, libllama and libggml are both tagged v1.0.0. A breaking change to the public C API now means a major version bump, new features, backends and model support go into minor releases, and bug fixes go into patches. The announcement also cites more than 150 supported architecture variants and support for all mainstream speculative decoding methods.
Heat · Two HN posts, 26 points with 4 comments and 20 points with 2 comments; modestWhat people foundThe useful change is stability: Go, Rust, Python and mobile bindings that link libllama can pin a major version instead of chasing master. Each ggml backend can also be built as a dynamic library and loaded at runtime, so one binary can serve machines with different GPUs.Learn it15 min · 5 steps
Key ideas
- Semantic versioning
- A MAJOR.MINOR.PATCH scheme where only a major bump is allowed to break code that depends on the library.
- Public C API
- The functions and types in the headers under the include folder that other programs call, which is the surface the new promise covers.
- Dynamic backend loading
- Building CPU, CUDA, Vulkan and other backends as separate shared libraries that the program picks up at runtime.
Steps
- Read the Hugging Face blog post on llama.cpp v1 and note what counts as a major, minor or patch change.
- Open the llama.cpp repository and look at the include folder to see which header defines the public API.
- Read the GPU backend notes in docs/build.md about the
GGML_BACKEND_DLoption. - Check how your favourite binding, such as a Python or Go wrapper, currently pins llama.cpp, usually by commit hash.
- Self check: if a release renames a function in the public header, which version number must change, and why does that help a binding author?
Try it30 min · 5 steps
You need: Linux or macOS with CMake and a C compiler, git, a small GGUF model file; No API key neededSteps
- Clone the llama.cpp repository and check out the v1.0.0 tag listed on its releases page.
- Build for CPU with
cmake -B buildfollowed bycmake --build build --config Release. - Look in the build output for the shared libllama and libggml libraries and list their exported symbols with your platform's symbol tool.
- Write a tiny C program that includes the public llama header, loads a small GGUF model and prints its context length, then link it against the built libllama.
- Rebuild with
-DBUILD_SHARED_LIBS=OFFand compare binary size and startup behaviour with the shared build.
Small angles to try
- Rebuild with the
GGML_BACKEND_DLoption and see which backend libraries load at runtime. - Diff the public headers between v1.0.0 and an older tag to see how much the API moved before the promise.
- Pin a binding you use to the v1 major version and note what breaks, if anything.
-
datasette-llm 0.1a11 talks to local models via OpenAI style endpoints
Simon Willison released datasette-llm 0.1a11, the plugin other Datasette plugins rely on for LLM access. It can now target any OpenAI compatible server, and he names LM Studio, Ollama and llama.cpp as examples. His demo runs Datasette Agent on a local Qwen model served by LM Studio and answers questions about a SQLite database by calling SQL tools.
Heat · simonwillison.net release note on Nov 14; no separate HN thread foundWhat people foundSetup is a single plugin setting: point plugins.datasette-llm.default_model at a model with an api_base of the local server and launch with uvx. In Willison's demo the local model called list_databases_and_tables and sql_query and correctly reported 200 repos and 1,889 releases.Learn it15 min · 4 steps
Key ideas
- OpenAI compatible endpoint
- A local server that speaks the same HTTP API shape as OpenAI, so any client can switch to it by changing the base URL.
- Tool calling
- The model asks the host app to run named functions, here listing tables and running SQL, and reads the results before answering.
- uvx
- A uv command that runs a Python tool in a throwaway environment without installing it globally.
Steps
- Read Simon Willison's datasette-llm 0.1a11 post and look closely at the full launch command.
- Identify the three keys in the model config: model, model_name and api_base.
- Read the datasette-agent plugin page to see which tools the agent exposes.
- Self check: what single value would you change to move the same setup from LM Studio to Ollama?
Try it30 min · 5 steps
You need: Python with uv installed, LM Studio or another OpenAI compatible local server with a tool capable model loaded, about 16 GB RAM or more for mid size models; No API key neededSteps
- Start the LM Studio local server so it listens on
http://localhost:1234/v1and load a Qwen model that supports tool calls. - Download the demo database with
wget https://datasette.io/content.db. - Run the launch command from the post,
uvx --with datasette-agent datasette --root --secret 1plus the-s plugins.datasette-llm.default_modelJSON with model, model_name and api_base, followed bycontent.db, replacing model_name with the model you loaded. - Open the agent page and ask how many repos and releases there are, then confirm the generated SQL and the counts.
- Ask a harder question that needs a join between tables and check the SQL by hand in Datasette.
Small angles to try
- Swap in your own SQLite file, such as an exported bank CSV turned into a table, and see where the model writes wrong SQL.
- Compare a small and a larger local model on the same five questions and count correct answers.
- Point api_base at Ollama or llama-server instead of LM Studio.
-
MiniMax H3-Image: open 33B text to image model with native 16MP output
MiniMax released H3-Image, a 33.1B parameter diffusion transformer for text to image generation and editing, distilled to 6 sampling steps with no classifier free guidance. It produces about 16 megapixels at every aspect ratio, from 4096x4096 to 6272x2688, without an upscaler, and accepts up to 16 reference images for edits.
Heat · Hugging Face trending, 1.18k likes and about 571k downloads last monthWhat people foundThis is not a laptop model: the BF16 transformer alone is 66.28 GB and the text encoder from the separate MiniMax-H3 repo adds 66.7 GB. It ships under the MiniMax-H3-Image Community License, whose Section IV requires separate written authorization in some cases, so read it before any commercial use.Learn it15 min · 4 steps
Key ideas
- Step distillation
- Training a model to reach good images in a handful of denoising steps instead of dozens, which cuts generation time.
- Classifier free guidance
- A common trick that runs the model twice per step to push images toward the prompt; dropping it halves compute per step.
- Reference image editing
- Feeding existing images alongside the prompt so the output keeps their subjects, styles or layouts.
Steps
- Read the MiniMax-H3-Image model card on Hugging Face, especially the file size table and sampling notes.
- Read the license section and find what Section IV asks for.
- Look at the showcase example that uses ten reference images to see what multi reference editing looks like.
- Self check: why does the API reject step counts other than 6 and any guidance value?
Try it30 min · 5 steps
You need: A browser for the official Hugging Face Space; running locally needs a data center class GPU and about 135 GB of weights; No API key needed for the SpaceSteps
- Open the official MiniMaxAI minimax-h3-image Space linked from the model card.
- Write five prompts that stress text rendering, hands, wide 21:9 scenes, small print and a product shot.
- Generate each and zoom to 100 percent to check whether the native 16MP detail holds up or is just smooth upscaling.
- Run the same prompts in an open model you can run locally and compare detail and prompt following side by side.
- Read the diffusers snippet on the card,
pip install -U diffusers transformers acceleratewithDiffusionPipeline.from_pretrained, and estimate whether your hardware could load it.
Small angles to try
- Upload two of your own photos as references and test identity and style preservation.
- Time a generation in the Space and compare with a 30 step model.
- Check the license against a concrete use you have in mind and list open questions.
-
Citizen developers × Gemini: JR Kyushu rail staff build Python apps
Keyman's Net reports that JR Kyushu's transport department, whose staff have no programming background, used Google Workspace with Gemini, adopted in fall 2025, to build two Streamlit web apps. One visualizes data from trains in service in near real time and is being tested as a possible future substitute for some inspections. The other generates duty rosters that weigh night shifts, holiday duty and individual skills while balancing workload; the headline says about 2 to 3 months, while the body only says several months.
Heat · #1 in the ITmedia AI+ access ranking, observed 2026-11-16What people foundThe driver is a labour shortage and an IT team that cannot keep up with requests from the field. The article says nothing about testing, review or who maintains the apps, and that gap matters most for the inspection use, which is still under verification.Learn it15 min · 4 steps
Key ideas
- Citizen developer
- A business user who builds internal software, now often by asking an AI assistant to write the code.
- Streamlit
- A Python framework that turns a script into a simple web app with tables, charts and inputs, with no front end code.
- Constraint based scheduling
- Building a roster by stating hard rules such as rest after night shifts and soft goals such as fair workload, then searching for an assignment.
Steps
- Read the Keyman's Net article, using a translator if needed, and list the two apps and their inputs.
- Write down which roster rules the article mentions: night shifts, holidays, skills and workload balance.
- Run
streamlit helloafter installing Streamlit to see what kind of app staff were building. - Self check: which of the two apps would you require a code review for before production, and what would the review check?
Try it30 min · 5 steps
You need: Python,pip install streamlit, a free tier chat LLM in the browser; No API key neededSteps
- Make a sample CSV of 8 fictional staff with skills and days off, plus a 14 day calendar with day and night slots.
- Ask a free LLM to write a Streamlit app that loads the CSV and builds a roster with rules: no day shift right after a night shift, each slot needs one qualified person, and nights are spread evenly.
- Save the code as
streamlit_app.pyand run it withstreamlit run streamlit_app.py. - Write a short checker script, by hand, that scans the output roster and counts rule violations.
- Feed any violations back to the LLM and see how many rounds it takes to reach zero.
Small angles to try
- Ask for a version using a constraint solver library and compare correctness with the greedy version the LLM writes first.
- Add a mid month sick day and see whether the app can repair the roster without reshuffling everyone.
- Hand the code to a colleague who did not see the prompts and time how long they take to understand it.
-
Agent inboxes × Meta Muse: @muse.ai addresses as Muse holds #1 in Japan
Since Nov 11 Japan time, Meta's Muse agent can have its own @muse.ai email address, first for paid users and later for everyone. It can email restaurants to request reservations, add events from forwarded schedule emails to your calendar, summarize long emails, and take commands from one separate address you verify. Muse is still the #1 free iPhone app in Japan and #2 in the US on today's Apple charts, and Japanese users reported getting addresses within a day.
Heat · Apple top free charts on 2026-11-16: #1 in Japan with feed updated 10:40 UTC, #2 in the US; the Muse email story is #9 in the ITmedia AI+ access rankingWhat people foundMuse was covered here on 11-11; the new part is that the agent now has its own inbox and can act on what arrives. Sender verification limits who can give commands, but forwarded mail and replies still carry text written by strangers into something that can send email and edit your calendar, which is a prompt injection surface worth testing.Learn it15 min · 4 steps
Key ideas
- Agent email address
- A mailbox owned by the AI agent rather than by you, so outside parties can write to it and it can write back.
- Sender verification
- Muse only takes commands from an address you have confirmed, which limits who can instruct it directly.
- Indirect prompt injection
- Instructions hidden in content the agent reads, such as a forwarded email, that try to make it act against the user.
Steps
- Read the ITmedia AI+ article on Muse email addresses and list each email action Muse can take.
- Check the Apple Japan top free feed to see the current rank and update time.
- For each action, write who controls the input text and what the agent can do with it.
- Self check: a restaurant replies to a reservation request with text telling the assistant to forward your calendar; which design choices would stop that?
Try it30 min · 5 steps
You need: Python 3, an mbox export of your own mailbox such as a Google Takeout Gmail export, a local model via Ollama or LM Studio or a free chat LLM for small samples; No API key needed with a local modelSteps
- Export one label of your own mail as mbox and open it with the standard library
mailbox.mboxclass, readingmessage['subject']and the From header for the latest 50 messages. - Send each subject and first 500 characters to a local model with a fixed prompt that labels it as reply needed, calendar event, receipt or ignore, and save the labels to a CSV.
- Hand check 20 labels and record accuracy, especially for calendar events, since that is the Muse forwarding use case.
- Add three fake emails you write yourself containing hidden instructions, such as a line telling the assistant to mark everything as ignore, and see whether the triage output changes.
- Change the prompt to treat email bodies strictly as data and rerun the three fake emails to compare.
Small angles to try
- Have the model extract event date, time and place as JSON and count how many would create a wrong calendar entry.
- Compare a small and a larger local model on the injected emails.
- If you are a paid Muse user, forward one of your own schedule emails to your Muse address and compare its calendar entry with your script's extraction.