Code415 Radar

by Ziyu Guo · @Code415zg

What people are paying attention to in AI, LLMs and CS today. Every item comes with a short path to learn it and a small test to try it yourself. Updated every evening, Japan time.

Monday, November 9, 2026

20 items · A 284B model on a 64 GB CPU box, and a git queue for agent brain fry
  1. #1Tools & open source

    llama-modchip: DeepSeek-V4-Flash 284B on a 64 GB CPU box, no GPU

    llama-modchip is an Apache-2.0 toolkit built on a patched llama.cpp that runs sparse MoE models such as Nemotron-3.5-30B-A3B, Qwen3-30B-A3B and DeepSeek-V4-Flash 284B on CPU only, with up to 256K context on 64 GB of RAM. It mixes a custom expert quantization, HugePages and AVX-512 build tuning, and a gateway that wires Claude Code to the local engine. Running ./modchip chat builds the engine, downloads Nemotron-3.5-30B-A3B at Q4_0 and starts a local server and web UI on first run.

    Heat · Hacker News, 417 points and 187 comments in an Algolia search on Nov 9 for the Nov 8 post; an earlier Algolia read showed 150 and 43, so counts were still moving. The GitHub repo showed 71 stars and 11 forks.
    What people foundAll speed figures are the author's own: on a Ryzen 9 9955HX with 64 GB DDR5, DeepSeek-V4-Flash as a 56.56 GiB file decodes at about 6.4 to 9.7 tok/s. Hacker News commenters push back hard: efficax says the big model runs at about 2 bits and is probably not great for real work, adrian17 says the file sizes do not match the cited GGUFs, and embedding-shape notes roughly 4 seconds for 43 input tokens is far from fast enough for coding agents. Treat it as a fun experiment until independent benchmarks land.
    Learn it15 min · 4 steps

    Key ideas

    Sparse MoE
    A mixture of experts model only activates a few expert blocks per token, so DeepSeek-V4-Flash uses about 13B of its 284B weights each step, which is why CPU decoding is even possible.
    Low bit quantization
    Storing weights in 2 to 4 bits shrinks a model to fit in RAM, but below about 4 bits answer quality usually drops noticeably.
    Prefill versus decode
    Prefill is reading the prompt and decode is generating new tokens; coding agents send huge prompts, so slow prefill hurts them even when decode looks fine.

    Steps

    1. Read the llama-modchip README on GitHub, focusing on the model table, the benchmark hardware and the list of ./modchip subcommands.
    2. Read the Hacker News thread and note which comments question quantization level and which point to prefill speed.
    3. Compare the README's DeepSeek file size of 56.56 GiB with the full model size mentioned in the thread to estimate how aggressively it was compressed.
    4. Self check: why can a 284B MoE model decode on a CPU at all, and why might it still be a poor fit for an agent that sends 50K token prompts?
    Try it30 min · 5 steps
    You need: A spare Linux x86 machine or VM you control, ideally with an AVX-512 CPU; 24 GB of RAM or more for the 30B Nemotron model and 64 GB for DeepSeek; git, Python 3 and about 20 GB of free disk. No API key needed.

    Steps

    1. Run git clone https://github.com/synchopate/llama-modchip.git and cd llama-modchip, then read scripts/check_cpu_readiness.py before running it with python3 scripts/check_cpu_readiness.py to get a speed estimate without downloading a model.
    2. Run ./modchip status to see CPU readiness and HugePages state; the build may want to change HugePages settings, so only do this on a machine you can reconfigure.
    3. Run ./modchip chat, let it build and download Nemotron, then ask a few coding questions and watch the live tok/s readout.
    4. Run ./modchip bench for the 30 second scorecard and compare it with the README numbers for the closest listed CPU.
    5. Run ./modchip stop when done.

    Small angles to try

    • Point ./modchip start at a standard Q4_K_M GGUF you already trust and compare speed and answers with the bundled build.
    • Try ./modchip claude on a throwaway repo and time how long the first turn takes with a large prompt.
    • Ask the same five questions to this setup and to a hosted model and grade the answers blind.
  2. #2Engineering & CS

    AI brain fry: a ticket queue in git for many parallel agent sessions

    Sergey Kuhne writes that juggling about 20 Claude Code or Codex threads at once broke his focus, and names the two real problems as sequencing and context. His fix keeps every ticket as a markdown file in the repo, lets an agent work the board in cycles that research tickets, build only the ones he has tagged as safe, run tests and a browser check, and never deploy to production. Anything that needs a human decision lands in one ranked owner inbox produced by a script.

    Heat · Hacker News, 243 points and 170 comments in an Algolia search on Nov 9 for the Nov 8 post.
    What people foundUnlike the coordinator agent setup covered on Nov 8, where an agent picks the next task, here the human stays the scheduler: a script ranks what waits on him, he handles one item at a time, and his verdict is written back to the ticket in git so closing it also closes the context in his head. A review page rebuilt from git each cycle is only a viewer, git stays the record, and the target is about a minute to load a ticket instead of twenty. On HN, wallstop argued the real fix is less parallel work, since the author is still tired.
    Learn it15 min · 4 steps

    Key ideas

    Priority queue of human decisions
    Instead of switching between open agent tabs, every pending judgment call goes into one ranked list that the human drains one item at a time.
    State in git
    Tickets, verdicts and board snapshots are committed files, so nothing important lives only in a chat window and a crashed session loses nothing.
    Human tagged build gate
    The agent may only build tickets a person has marked as safe, and production deploys always stay with the person.

    Steps

    1. Read Sergey Kuhne's post How I'm fighting the AI Brain Fry and sketch his loop: tickets, agent cycle, owner inbox, review page, verdict.
    2. Skim the Hacker News thread for the GitHub issues versus files in the repo debate and the argument that fewer parallel tasks is the better fix.
    3. List which steps in your own agent workflow currently live only in your head or in terminal scrollback.
    4. Self check: what does writing the verdict back into the ticket buy you that a separate dashboard or chat log does not?
    Try it30 min · 5 steps
    You need: git, Python 3, and Claude Code signed in to your own account or API key; a throwaway repo you own.

    Steps

    1. In a throwaway repo run git init and create a tickets folder with four markdown files, each with a short frontmatter block holding status, priority and a safe_to_build flag.
    2. Write a 20 line Python script that reads the folder and prints an owner inbox: tickets whose status is waiting on owner, sorted by priority.
    3. Mark one small ticket as safe to build, then start Claude Code in the repo and ask it to implement only tickets marked safe, run the tests and set the ticket status to waiting on owner with a summary.
    4. Run the inbox script, review the change, write your verdict into the ticket file and commit it.
    5. Time how long it takes to load the context for the next ticket from the file alone.

    Small angles to try

    • Swap the markdown files for GitHub issues on a private repo and compare which one is faster to review.
    • Add a loop counter field so a ticket that bounces back to you three times gets flagged.
    • Run two agent sessions on separate tickets and check whether the inbox keeps you on one decision at a time.
  3. #3Tools & open source

    Claude Code 2.1.319: background MCP tasks and deny instead of prompt

    Claude Code v2.1.319, released Nov 6, moves MCP tool calls that a server runs as tasks to the background right away and tells Claude the result when they finish. A new permissions.denyInsteadOfPrompting setting denies any tool call that would wait on a permission prompt and lets the turn continue, in terminal sessions, subagents and teammates. Auto mode with telemetry or feature flags off, including behind LLM gateways, now asks or denies calls the server cannot check instead of falling back to the built in classifier.

    Heat · Marked Latest on the anthropics/claude-code releases page, after 2.1.317 on Nov 3 and 2.1.318 on Nov 4.
    What people foundGateway users in auto mode should check their setup: set CLAUDE_CODE_AUTO_MODE_SERVER=0 to keep the old classifier, and CLAUDE_CODE_DISABLE_MCP_TASK_BACKGROUND if scripts expect Claude to wait on an MCP task inside the tool call. For unattended runs, the deny setting is the cleaner way to make sure a session never hangs on a prompt nobody will answer. The release also adds CLAUDE_CODE_DISABLE_FEATURE_FLAGS and fixes several permission bypasses, including one through a crafted environment prefix.
    Learn it15 min · 4 steps

    Key ideas

    Permission prompt
    When a tool call is not covered by an allow rule, Claude Code stops and asks a human, which stalls any run where nobody is watching.
    MCP task
    An MCP server can run a slow tool call as a task, and Claude Code now lets Claude keep working and reports the result when the task ends.
    Auto mode server check
    In auto mode a server side review decides which actions are safe; when that review cannot be reached, the new default is to ask or deny.

    Steps

    1. Read the v2.1.319 notes on the anthropics/claude-code releases page, starting with the first five Changed and Added lines.
    2. Read the Claude Code settings docs on settings files and precedence to see where a key like this belongs, project local versus user.
    3. Note which of your own sessions run behind an LLM gateway, with telemetry off, or unattended.
    4. Self check: in an unattended run, what is the practical difference between a prompt that waits forever and a call that is denied while the turn continues?
    Try it30 min · 5 steps
    You need: Claude Code 2.1.319 or later signed in to your own account or API key; a throwaway git repo. Optional: an MCP server you run yourself that supports tasks.

    Steps

    1. Update Claude Code and confirm the version is 2.1.319 or later.
    2. In a throwaway repo create .claude/settings.local.json with a permissions block that turns on denyInsteadOfPrompting, and add no allow rules for Bash.
    3. Start claude in the repo, run /status to confirm the local settings file loaded, then ask it to run a shell command such as listing files and writing a new file.
    4. Watch whether the call is denied and the turn continues with Claude explaining what it could not do, then remove the setting and repeat to see the normal prompt.
    5. If you have a task capable MCP server, trigger a slow tool call, check /tasks, then restart with CLAUDE_CODE_DISABLE_MCP_TASK_BACKGROUND set and compare.

    Small angles to try

    • Combine the deny setting with a narrow allow list and count how many calls get denied on a real small chore.
    • Ask a subagent to do the same work and confirm the setting applies there too.
    • Behind your own gateway, check the Auto mode server line in /status before and after setting CLAUDE_CODE_AUTO_MODE_SERVER=0.
  4. #4Tools & open source

    LoreKit author pitches an OpenTelemetry style spec for agent memory

    Mads Thines, who builds the LoreKit memory tool, argues that every agent stores memory in its own format and that what is missing is an agreement, not another tool. He sketches Markdown records with frontmatter fields such as id, address, key, kind, written_by, lifecycle and namespaced attributes, a small MCP contract of write, read, list, search and archive, and conformance tests instead of a reference implementation. Storage, ranking and embeddings stay with each tool, and he warns that shared memory is a prompt injection channel.

    Heat · Hacker News, 181 points and 107 comments in an Algolia search on Nov 9 for the Nov 8 post.
    What people foundWhere Anthropic's Nov 8 post looked at how one agent should remember, this one is about letting different tools read and write the same memory. The field names are illustrative, not a finished spec, and who should coordinate it is left open; LoreKit's own schema and on disk format are MIT licensed. On HN, Fordec agreed with the premise but warned that standardizing now risks a SOAP style abstraction, and others said they turn agent memory off entirely.
    Learn it15 min · 4 steps

    Key ideas

    Addressed record
    Each memory has a scope such as a repo or branch plus a key, so a second write updates the same memory instead of creating a duplicate.
    Conformance tests
    Instead of shipping one official library, the spec would ship tests such as round trips without loss and unknown attributes surviving a rewrite.
    Memory poisoning
    Anything an agent reads can steer it, so recording who wrote each memory and allowing signatures helps readers decide what to trust.

    Steps

    1. Read Agent memory needs its OpenTelemetry moment on the LoreKit blog, focusing on the record table and the skeptics section.
    2. Skim the formats it surveys, from AGENTS.md and CLAUDE.md to Mem0, Letta and Graphiti, and note which ones you already use.
    3. Read the Hacker News thread for the arguments that it is too early to standardize.
    4. Self check: why does the author put storage and ranking out of scope, and what would break if two tools disagreed on the address field?
    Try it30 min · 5 steps
    You need: Node.js with npx, Claude Code or Cursor on your own account, and a throwaway git repo. LoreKit local mode needs no LoreKit token.

    Steps

    1. In the throwaway repo run npx @lorekit/cli install and skip the token to use local mode, as the LoreKit README describes.
    2. Run npx @lorekit/cli doctor to confirm the MCP server and detected scopes.
    3. Ask your agent to store two lessons about the repo, then open the markdown files on disk and compare their frontmatter with the fields in the blog post.
    4. Store a third lesson that contains an instruction like ignore the tests, start a fresh session and see whether the agent follows it, using only your own throwaway repo.
    5. Write down which fields would let a second tool read these files without LoreKit.

    Small angles to try

    • Hand write a record in the proposed format and see whether the agent picks it up.
    • Add a written_by note to each lesson and ask the agent to rank memories by source.
    • Diff the memory files after a week of use to see how often lessons get updated instead of duplicated.
  5. #5Trends × tech

    Clinics × local LLMs: Tokyo heart clinic runs its AI on one Mac Studio

    Hongo Masago Heart Clinic in Bunkyo, Tokyo, runs a 4 bit quantized open weight LLM, a vision model that matches scanned handwritten questionnaires to patient charts, and Whisper transcription locally on a Mac Studio with an M3 Ultra and 96 GB, bought for about 690,000 yen. Director Hironori Muraoka built the booking system, check in and a dashboard beside the electronic charts with Claude Code, which builds the software but never handles medical data, and the apps only read the charts. Each night the Mac summarizes past records for the next day's patients.

    Heat · ITmedia AI+ feature published Nov 9; no ranking or share counts seen.
    What people foundMuraoka says the system reliably does about one clerk's work, but on transcription he still types faster. Larger models and 8 bit versions did not noticeably improve answers and ran slower, which matters because an extra minute per patient can add an hour to the overnight batch. Staff still confirm every questionnaire match, and he calls the AI an aid, not a substitute for a doctor's judgment.
    Learn it15 min · 4 steps

    Key ideas

    Read only integration
    The custom apps read from the electronic chart system but never write to it, so a bug cannot corrupt the record of truth.
    Overnight batch inference
    Slow local models are fine when work runs while the clinic is closed, as long as total time per patient stays small.
    Human confirmed matching
    The vision model only proposes chart candidates for a scanned form and a person makes the final link.

    Steps

    1. Read the ITmedia AI+ article, using a browser translation if needed, and list each AI part, where it runs and what data it can touch.
    2. Read the Whisper README on GitHub to see the model sizes and how the turbo model trades accuracy for speed.
    3. Draw the clinic's data flow and mark which arrows are read only and which steps need a human.
    4. Self check: why does keeping Claude Code away from patient data still let the director use it to build the whole system?
    Try it30 min · 5 steps
    You need: A Mac or Linux machine with Python 3, ffmpeg and about 2 GB of free disk; optional local LLM runner you already use. Use only synthetic or your own data, never real patient records. No API key needed.

    Steps

    1. Install Whisper with pip install -U openai-whisper and install ffmpeg with your package manager, such as brew install ffmpeg on macOS.
    2. Record yourself reading a two minute made up clinic note, then run whisper note.m4a --model turbo --language Japanese or use English, and time it.
    3. Type the same note by hand and compare time and errors with the Whisper output, the same test the director describes.
    4. Write ten fake patient histories as text files and run a small loop that asks a local model to summarize each into a short table of contents, logging seconds per file.
    5. Multiply seconds per file by 100 patients to see whether the batch would finish overnight.

    Small angles to try

    • Rerun the transcription with the small and medium models and chart speed against error count.
    • Swap a 4 bit model for an 8 bit version of the same model and compare summary quality and runtime.
    • Feed a photo of a handwritten form you made yourself to a local vision model and check how often it reads the name and birth date correctly.
  6. #6Tools & open source

    Hugging Face publishes The Ultimate MoE Training Handbook

    Hugging Face researchers Nouamane Tazi, Leandro von Werra and Thomas Wolf published a hands on handbook for training Mixture of Experts models with Megatron-LM, released as an interactive Space on Nov 5. Its chapters run from a first single node run on H100 nodes linked by EFA, through the anatomy of MoE training, to serving, and each setting is backed by runs on their own cluster. Topics include keeping the router in fp32, DeepSeek style loss free bias versus an auxiliary loss, how finely to cut experts, and serving with fewer experts per token than the model was trained with.

    Heat · Trending Space on Hugging Face; the Space page showed 387 likes. AI Weekly and posts by Thomas Wolf and Sung Kim spread it on Nov 6.
    What people foundTwo concrete rules from the handbook: forcing even routing made the same model run 1.5x faster at init, yet the authors say never to train with that flag. On serving, Qwen3.6-35B-A3B trained with top 8 lost only 0.35 MMLU points at top 4 when outputs were divided by the top 16 mass, while dropping to top 6 with no renormalization cost 27.45 points.
    Learn it15 min · 5 steps

    Key ideas

    Router
    A small layer that scores every expert for each token and sends the token to the top k experts.
    Load balancing
    Keeping tokens spread evenly over experts, either with an auxiliary loss term or with a bias that only changes which experts get picked.
    Top k at serving time
    The number of experts each token uses can be lowered after training to save compute, as long as expert outputs are rescaled sensibly.

    Steps

    1. Read the introduction chapter of the handbook Space first to see the reading plan and the cluster setup it assumes.
    2. Read section 3.1 on router precision, where a bf16 router can round two close logits to the same value and change the winning experts.
    3. Read section 3.3 on aux loss versus loss free bias and the forced even routing experiment.
    4. Skim chapter 4 on serving fewer experts and note the renormalization choices it compares.
    5. Self check: why can a model run faster with forced even routing, and why is that still a bad training setting?
    Try it30 min · 5 steps
    You need: Python 3, a GPU with about 16 GB of memory or a machine with enough RAM for a 7B bf16 model, packages transformers and accelerate. No API key needed.

    Steps

    1. Install the libraries with pip install -U transformers accelerate; the model card notes OLMoE support may need a recent or source build of transformers.
    2. Load allenai/OLMoE-1B-7B-0924 with AutoModelForCausalLM.from_pretrained and its tokenizer, as shown on the model card.
    3. Confirm in the config that num_experts is 64 and num_experts_per_tok is 8, then compute perplexity on a few paragraphs of your own text.
    4. Reload the model with num_experts_per_tok set to 4 and then 16, and compute perplexity on the same text each time.
    5. Compare the three results with the handbook's chapter 4 finding that serving more experts than trained costs compute without a guaranteed quality gain.

    Small angles to try

    • Time generation per token at top 4, 8 and 16 to see the compute side of the tradeoff.
    • Hook the router outputs and plot how many tokens each expert receives on your text to see load imbalance.
    • Cast only the router layers to fp32 and check whether any top k choices change on the same inputs.
  7. #7Models & launches

    Is Opus 5.5 nerfed? Trackers say no; check the medium effort default

    A post by Shane Melaugh, reported by AICoder, says Gemini 4 Argon analysed 1,400 of his Claude Code sessions and found Opus 5.5's reasoning style shifted sharply around November 3; the raw data was not published. Theo of T3 replied that Anthropic appears to be rolling out a per account change to the reasoning summarizer and saw no sign of lost capability. MODEL found AI Stupid Level and LiveNerf showing no sustained decline as of Nov 7, BridgeBench's Oct 16 post reporting no nerfs, and no public Anthropic statement.

    Heat · HN thread "Is Opus 5.5 nerfed?" at about 73 points and 48 comments on Nov 9; Melaugh's X post about 966 likes per AICoder; i10x counted roughly 2,700 posts on the topic in 24 hours, per MODEL.
    What people foundAnthropic's docs say Opus 5.5 and Haiku 5.5 default to medium effort, while Opus 5 and earlier Opus models defaulted to high, so a request that omits effort runs one level lower. In Claude Code, a top level effortLevel in user settings does not apply to Opus 5.5, so check /effort before concluding the model got worse. Different looking thinking summaries do not by themselves show a weaker model.
    Learn it15 min · 4 steps

    Key ideas

    Effort
    An API setting from low to max that controls how much thinking and output the model spends on a request.
    Reasoning summarizer
    A component that condenses the model's raw thinking into the summary shown to users, so changing it alters what you see without changing the model.
    Nerf tracker
    A service that reruns a fixed benchmark against a model over time to detect quality drops.

    Steps

    1. Read the MODEL article first for the tracker results and the effort default.
    2. Read the Anthropic effort docs to see the five levels and the per model defaults.
    3. Read the AICoder piece for the session analysis claim and Theo's reply, noting that one user's data was judged by another model.
    4. Self check: if Claude Code feels weaker on Opus 5.5, which two settings do you check before blaming the model?
    Try it30 min · 5 steps
    You need: An Anthropic API key, Python 3 with the anthropic package, optionally Claude Code.

    Steps

    1. Pick five tasks from your own work with checkable answers, such as small refactors with unit tests.
    2. Call claude-opus-5-5 through the Messages API once with no effort set and once with output_config={"effort": "high"} for each task.
    3. Record pass or fail, output tokens and latency for each run in a small table.
    4. In Claude Code, run /effort high or launch with claude --effort high, repeat one task, and compare with the medium default.
    5. Decide from your own numbers whether the difference you felt matches the effort change.

    Small angles to try

    • Add xhigh to see whether the extra cost pays off on your hardest task.
    • Rerun the same set weekly to build a tiny private nerf tracker for your workload.
    • Set a per model level via modelSettings in Claude Code and confirm it applies to Opus 5.5.
  8. #8AI in the world

    PSI says an unreleased Anthropic model proved Aaronson-Ambainis in Lean

    Physical Superintelligence says its internal research system, running an unreleased Anthropic model on PSI's own infrastructure, found a complete proof of the Aaronson-Ambainis conjecture, open since 2008, on the third day of a run and then improved the bound twice, each version checked in Lean. The result says that for yes or no questions on random inputs, a classical algorithm can imitate a quantum one with only polynomially more input reads. The paper, Lean proofs and check scripts are public on GitHub.

    Heat · Covered on Nov 6 by The Quantum Insider and RuntimeWire; traction on HN was low, about 11 points. No independent expert quotes seen yet.
    What people foundThe human roles are spelled out: David Turturean scoped the problem, ran the system and takes responsibility for correctness, Jim Halverson audited the proof, and the Stanford group of Blanc, Docter, Strassle and Tan is reviewing it and writing a shorter exposition. The Quantum Insider stresses that the bound limits input reads, not total computing time.
    Learn it15 min · 4 steps

    Key ideas

    Query complexity
    Counting how many input bits an algorithm reads, ignoring the computation it does between reads.
    Lean kernel check
    A small trusted core of the Lean proof assistant that verifies every step of a formal proof, so correctness does not rest on the author's word.
    Influence of a bit
    How much flipping one input bit can change a function's output on average, the quantity the proof bounds.

    Steps

    1. Read the PSI research page first for the claim, the timeline and who did what.
    2. Read The Quantum Insider article for the plain language caveats about reads versus computing time.
    3. Open the GitHub README and see how Conjecture.lean holds the statements while Main.lean holds the final theorems.
    4. Self check: why does a Lean check of the proof still require humans to confirm the formal statement matches the conjecture?
    Try it30 min · 5 steps
    You need: A Linux or macOS machine, elan, make and python3; full replay needs a lot of memory, about 7.4 GB single threaded. No API key needed.

    Steps

    1. Install elan, the Lean version manager, and clone the physical-superintelligence aaronson-ambainis repository.
    2. Run lake exe cache get to download compiled Mathlib.
    3. Run make audit to confirm the sources contain no placeholders or added axioms.
    4. Run lake build, then make axioms to print the axioms behind the final theorems.
    5. Open AaronsonAmbainis/Conjecture.lean and compare the formal statement with the plain language claim on the PSI page.

    Small angles to try

    • Run LEAN_NUM_THREADS=1 make replay on a lower memory machine to recheck every declaration.
    • Apply the same audit idea to your own AI generated code: a script that rejects stubs and skipped tests before review.
    • Run make digest and compare the hash with the recorded outputs in the verification folder.
  9. #9Engineering & CS

    Google: stale TODO bug links cost coding agents 77% more tokens

    Google analysed millions of internal file reading sessions by coding agents and found 13% of them hit inline TODO or FIXME comments pointing at bug IDs. Agents ignored these 94% of the time, but when they acted, 83% of the detours were unprompted and 41% of those chased tickets that were already closed. Sessions with such detours used 70% more steps, 77% more tokens and 105% more wait time after controls, and an agent driven cleanup removed thousands of obsolete references with over 95% reviewer acceptance.

    Heat · Google Developers Blog post on Nov 6, backed by a fixed effects regression controlling for developer, task type, model tier, codebase complexity and more.
    What people foundCodebase hygiene now has a measured price for agent workloads. Google recommends presubmit analyzers for dead TODO references, corpus scanners for links to fixed or obsolete bugs, and cleanup agents that verify bug and file history before proposing a deletion for human review.
    Learn it15 min · 4 steps

    Key ideas

    Agent detour
    Work an agent does on something the user did not ask for, such as investigating a bug mentioned in a comment.
    Stale reference
    A comment that links to a ticket which is already fixed, obsolete or a duplicate.
    Fixed effects regression
    A statistical model that compares sessions within the same developer and task type so differences are not just due to who ran them.

    Steps

    1. Read the Google Developers Blog post Agent Distraction first.
    2. Note the split between closed ticket detours and open ticket scope creep, 41% versus 57% of unprompted detours.
    3. Read the recommendations section on presubmit checks and verified cleanup.
    4. Self check: why does an open ticket in a TODO still cost tokens even when the bug is real?
    Try it30 min · 5 steps
    You need: A git repository you own that tracks bugs in GitHub Issues, the gh CLI logged in, Python 3. No API key needed.

    Steps

    1. In your own repo, list comments that reference issues with git grep -nE "(TODO|FIXME).*#[0-9]+".
    2. Extract the issue numbers with a short Python script.
    3. For each number, run gh issue view NUMBER --json state,closedAt and record the state.
    4. Print every TODO that points to a closed issue, with file and line.
    5. Review each one by hand and remove or rewrite the stale ones in a single commit.

    Small angles to try

    • Turn the script into a CI step that fails when a TODO links to a closed issue.
    • Ask your coding agent to do the cleanup but require it to cite the issue history before each deletion.
    • Give an agent the same task on the repo before and after cleanup and compare token usage.
  10. #10Engineering & CS

    Counterpoint: a Finnish developer on why he won't code with LLMs

    Kristian Polso, a PHP and JavaScript developer in Finland who has built production ML systems for about 10 years, explains why he keeps LLMs out of his professional coding. His reasons are cognitive effects, citing a Microsoft Research paper and two arXiv papers, hidden flaws in output quality, long term maintainability, the enjoyment of writing code, datacenter energy use, and GDPR and US CLOUD Act concerns about relying on US providers.

    Heat · Hacker News, 113 points and 229 comments on Nov 8; comments outnumber points about two to one, a sign of a heated thread.
    What people foundHis quality example from his day job: Claude built new logic with framework hooks and several tests for a single field, where a few lines of schema change and a migration would have done. He concedes AI has helped him get unstuck with a coherent plan and that AI assisted coding is not going away.
    Learn it15 min · 4 steps

    Key ideas

    Cognitive debt
    The idea that leaning on an assistant reduces the thinking you do yourself, so understanding erodes over time.
    Data residency
    Rules about where data is stored and which jurisdictions can reach it, such as GDPR in the EU and the US CLOUD Act.
    Overengineered fix
    A change that adds new code paths and tests where a smaller change to existing structure would solve the problem.

    Steps

    1. Read Polso's blog post first and list his six reasons.
    2. Pick the two reasons most relevant to your team, for example maintainability and data residency.
    3. Skim the HN thread for the strongest counterargument to each of those two.
    4. Self check: which of his objections can a team address with process, and which are about values?
    Try it30 min · 5 steps
    You need: A repository you own, any coding assistant you already use, git. No API key needed beyond your usual assistant.

    Steps

    1. Pick a small real change in your repo, such as adding one field, and write down the minimal change you would make by hand.
    2. Ask your coding assistant for the same change on a separate branch without hinting at the solution.
    3. Compare the two diffs by lines changed, new files and new tests.
    4. Mark each extra piece in the assistant's diff as needed or unneeded.
    5. Write one rule for your prompts or review checklist that would have blocked the unneeded parts.

    Small angles to try

    • Repeat with a prompt that asks for the smallest possible change and compare again.
    • Check where your assistant's provider processes data and whether that fits your GDPR obligations.
    • Write the change yourself first, then have the assistant review it instead of writing it.
  11. #11Models & launches

    Ai2 ToyBlocks: open robot models, 85K demos, a sim that tracks reality

    Ai2 released ToyBlocks, an open simulation framework built around a robot arm and tabletop blocks that generates tasks, demonstrations and evaluation metrics. It ships with two trained models, a Molmo 2 based planner and a ManiFlow based low level policy, plus 85,336 generated long horizon demonstrations covering nearly 1,600 hours and about 144 million frames. ManiFlow's atomic skills scored 80.0% in simulation and 81.1% on a real Franka FR3 arm.

    Heat · Ai2 blog post; the Hugging Face pages for allenai/maniflow-tb and the toyblocks-data dataset each showed 2 likes when checked
    What people foundSim and real scores line up closely: the hierarchical Molmo 2 plus ManiFlow setup hit 55.5% in sim, 111 of 200 episodes, against 50.0% on the real robot, 15 of 30. Ai2 itself says more real trials are needed for statistical confidence. Adding 100 trajectories generated by the Wan 2.2 video model lifted success in an unseen region from 19% to 78%.
    Learn it15 min · 5 steps

    Key ideas

    Hierarchical policy
    A high level model picks the next skill in plain language and a low level controller turns that skill into arm motions.
    Sim to real gap
    The drop in success rate when a policy trained or scored in simulation runs on physical hardware.
    World model rollouts
    Synthetic training trajectories produced by a video generation model instead of a simulator or a human teleoperator.

    Steps

    1. Read the Ai2 ToyBlocks blog post first, focusing on the results table that compares simulation and real robot success.
    2. Open the allenai/maniflow-tb model card on Hugging Face to see what the low level policy expects as input and how it is evaluated.
    3. Skim the ToyBlocks installation page to see the stack: Isaac Sim 5.1, cuRobo for motion planning and LeRobot style parquet data.
    4. Compare the atomic skill numbers with the hierarchical numbers and note where errors compound across steps.
    5. Self check: why does a sim score that matches the real robot score matter more than a high sim score on its own?
    Try it30 min · 5 steps
    You need: Linux x86_64, an NVIDIA GPU with driver 570 or newer for CUDA 12.8, Python 3.11, uv, tmux and git; Ai2 tested on an RTX 5090 with 32 GB. No API key needed for the core install.

    Steps

    1. Clone and enter the repo: git clone https://github.com/allenai/ToyBlocks.git then cd ToyBlocks.
    2. Create the environment with uv venv --python 3.11, run source .venv/bin/activate, then git submodule update --init --recursive.
    3. Install with policies included: uv pip install -e ".[dev,isaac,torch-cu128,maniflow]" and accept the Isaac Sim EULA with export OMNI_KIT_ACCEPT_EULA=YES.
    4. Fetch about 280 MB of assets with get-toyblocks-assets --asset-manifest asset_manifest.json, then run pytest tests/install and pytest tests/install --install-gpu.
    5. Download the policy with hf download allenai/maniflow-tb --local-dir maniflow-tb and follow the Policy Evaluation page to run scripts/launch_eval.py with --policy maniflow against a ToyBlocks eval dataset.

    Small angles to try

    • Run the same eval on the easy and hard splits and compare how success drops with task length.
    • Try the agentic robotics extra, which drives episodes through an LLM and needs your own OpenRouter API key.
    • Load a few episodes of allenai/toyblocks-data in Polars and count how many skills a typical long horizon episode chains.
  12. #12Tools & open source

    @GitHub in Slack and Teams goes GA: Copilot opens PRs from a chat thread

    GitHub made the @GitHub app for Slack and Microsoft Teams generally available on Nov 6. From a conversation it can investigate bugs, create issues, implement changes and open pull requests; it now infers the repository from your message, adds a canvas in Teams for reviewing plans, code changes and previews, and stamps issues and PRs with a note saying which chat conversation created them.

    Heat · GitHub changelog entry and a matching GitHub Community announcement, both dated Nov 6
    What people foundPer GitHub's docs, each request starts an asynchronous Copilot cloud agent session in a sandbox and uses the whole thread as context, so anything said in the thread can end up in the PR. PRs started in shared channels are attributed to the app rather than to you, and you need write access to every repository involved.
    Learn it15 min · 4 steps

    Key ideas

    Copilot cloud agent
    A Copilot agent that works on a task in a GitHub hosted sandbox and returns a branch, issue or pull request.
    Thread as context
    The agent reads the full chat thread, not only the message that mentions it, when it plans the change.
    Default repository
    A per channel setting that tells the app which repository to use when the message does not name one.

    Steps

    1. Read the GitHub changelog entry from Nov 6 to see what changed at GA.
    2. Read the GitHub docs page on integrating the cloud agent with Slack, especially prerequisites and the note on attribution.
    3. Note the limits: paid Copilot access, write access to every repository, up to 11 repositories under one owner per session.
    4. Self check: in a shared channel, whose identity appears on the PR, and what in the thread could leak into it?
    Try it30 min · 5 steps
    You need: A paid Copilot plan, a Slack workspace or Teams tenant where you may install apps, and a throwaway GitHub repository you own. No API key needed.

    Steps

    1. Create a small test repository with a README and one failing unit test.
    2. Install the app from slack.github.com or teams.github.com and connect your GitHub account when asked.
    3. In a test channel, run @GitHub help, then @GitHub settings to set the owner and default repository.
    4. Post a bug description in a thread, then ask the app in owner/repo form to fix the failing test in your repository.
    5. Open the resulting PR, read the diff and check the description for the line saying it came from a Slack or Teams conversation.

    Small angles to try

    • Repeat the request in a direct message, where you must name the repository, and compare who the PR is attributed to.
    • Ask for a change spanning two of your repositories under the same owner in one prompt.
    • In Teams, review the plan in the canvas and push back on it before the change is made.
  13. #13Tools & open source

    MAPLE prunes Gemma 4 26B MoE to 4.75 GB to fit a 6 GB laptop GPU

    MAPLE is an Apache 2.0 research pipeline by Aman Sachan that profiles real forward passes with llama-imatrix, scores each MoE expert by routing count and activation energy, and keeps 48 of 128 experts in each of 30 layers. Applied to Gemma 4 26B-A4B, the GGUF shrinks from 9.92 GB to 4.75 GB, about 1.48 effective bits per parameter. The pruned model is tuned for Python, algorithms and STEM reasoning; multilingual and conversational experts were removed.

    Heat · Show HN on Nov 8 with about 20 points and 5 comments; the Hugging Face model page showed 2 likes
    What people foundOn an RTX 4050 6 GB the author measured 6.9 tok/s for the original model with only 16 of 30 layers on the GPU, and 45.4 tok/s for the pruned model with all 30 layers in VRAM. Mean fidelity was 93.8% on four small self reported tests, with the binary search tree test at 75%. The calibration corpus is a swappable text file, so you can prune toward your own domain.
    Learn it15 min · 4 steps

    Key ideas

    Mixture of experts
    A model where a router sends each token to a few expert sublayers, so only part of the weights work per token.
    Expert pruning
    Deleting experts the router rarely uses on a calibration corpus, which cuts memory but also removes skills outside that corpus.
    Importance matrix
    Activation statistics gathered by llama.cpp's llama-imatrix tool while running sample text through the model.

    Steps

    1. Read the MAPLE README on GitHub first, especially the method section and the key numbers table.
    2. Look at the scoring formula and the three failure modes the author fixed, such as output scaling compounding over 30 layers.
    3. Open engine/calibration_corpus.txt in the repo to see how small the calibration set is, about 1,979 tokens.
    4. Self check: why could a model pruned on a code and STEM corpus fail badly on a Japanese customer support chat?
    Try it30 min · 5 steps
    You need: A llama.cpp build with llama-cli or Ollama, about 5 GB of disk and ideally an NVIDIA GPU with 6 GB or more; CPU works but slower. No API key needed.

    Steps

    1. Run the model straight from Hugging Face: llama-cli -hf AmSach/Gemma-4-26B-A4B-MAPLE-Sub5GB-GGUF -ngl 99 -c 2048 -n 512 --temp 0.4 --top-p 0.9 --repeat-penalty 1.1 with a short prompt.
    2. Or with Ollama: ollama run hf.co/AmSach/Gemma-4-26B-A4B-MAPLE-Sub5GB-GGUF:IQ2_XXS.
    3. Write five prompts from your own work, such as a SQL query, a Python bug fix and a short email, and record tokens per second and whether each answer is correct.
    4. Run the same five prompts on an unpruned Gemma 4 26B-A4B quantization you already use, if your hardware allows, and compare quality and speed.
    5. Clone the repo, run pip install -r requirements.txt and read engine/maple_profile.py to see how you would profile with your own corpus.

    Small angles to try

    • Ask non English or casual chat questions to see what the removed experts cost.
    • Replace engine/calibration_corpus.txt with your own codebase text and follow the README's calibrate, select and build steps.
    • Compare VRAM use with your GPU monitor while running the original and the pruned model.
  14. #14Tools & open source

    Zalando open sources an identity broker for AI agents calling MCP

    Zalando's incubator released the Agentic Identity Broker, an MIT licensed Go service that sits between agents and MCP servers, typically behind a gateway such as Agentgateway. Users consent to give an agent specific permissions in services like Google, GitHub, Databricks or Linear, and the broker centrally handles OAuth2 delegation, an encrypted token vault, delegation chains and audit logs, so each MCP server does not have to.

    Heat · Show HN on Nov 6: 24 points and 3 comments; the repo showed 0 stars and 13 commits
    What people foundThe HN author says agents never see user tokens because the broker swaps them via RFC 8693 token exchange through the gateway, and that v0.1 already runs in production for several internal MCP servers. The README's clone command points to a different GitHub organisation than the zalando-incubator repo, so clone from the repo you actually reviewed. Roadmap: OPA based tool authorization, headless agents and agent to agent token exchange.
    Learn it15 min · 4 steps

    Key ideas

    On behalf of delegation
    An agent acts with a user's permissions for a limited scope that the user approved and can revoke.
    Token exchange
    An OAuth2 flow, RFC 8693, where one token is traded for another with a different audience or scope.
    Token vault
    A central encrypted store for third party tokens so agents and MCP servers never hold them directly.

    Steps

    1. Read the zalando-incubator/agentic-identity-broker README first, focusing on architecture and the dual port server.
    2. Read the Show HN thread to see the questions people raised about why plain OAuth delegation is not enough.
    3. Sketch the request path: user consent, agent, gateway, broker, MCP server, third party API.
    4. Self check: what breaks if every MCP server stores its own OAuth tokens, and which piece of this design fixes it?
    Try it30 min · 5 steps
    You need: Docker with Compose, git and the just command runner; Go 1.26.8 or newer if you build outside Docker. No API key needed, the compose stack uses mock services.

    Steps

    1. Clone the repo from the zalando-incubator organisation on GitHub, not the URL printed in the README, and enter the folder.
    2. Start the full stack with just compose-up-detached, which runs the broker, the consent frontend and three mock services on ports 9000 to 9002 with sample data.
    3. Watch startup with just compose-logs, then open the consent UI on localhost port 3000 and walk through granting a mock service to the sample agent.
    4. Inspect the structured JSON audit log entries for that grant, and check that token values are redacted.
    5. Shut everything down with just compose-down.

    Small angles to try

    • Revoke the grant you created and confirm the next agent call through the mock path is refused.
    • Read the administrative API on port 14000 locally and list which agents and grants exist.
    • Run just dev instead of Compose to step through the Go handlers with in memory storage.
  15. #15Trends × tech

    TV dramas × generative AI: Fuji TV plans AI in every drama by Oct 2027

    Fuji Television announced on Nov 5 that by October 2027 it will have a setup to use generative AI in every drama it produces, with at least one drama per quarter in an AI enhanced slot from the October 2026 season. The currently airing 救命病棟24時 already uses AI for pre shoot concept visuals, detailed medical and accident effects, and an explosion scene where smoke was composited onto an AI generated aerial style landscape. In tests on specific production steps, labor fell by up to 70 to 80%.

    Heat · ITmedia NEWS article from Nov 6; it was not in the site's top 10 access ranking when checked, and no other ranking was confirmed
    What people foundShinya Masaki, technical director of Fuji TV's AI Sandbox, says not every shot is made with AI; the team mixes it with conventional VFX and picks per work. The 70 to 80% cut applies to specific steps in tests, not whole series cost. The sandbox works with AI firm ANDENT, and Fuji TV wants its whole group AI capable by fiscal 2029.
    Learn it15 min · 4 steps

    Key ideas

    Previsualization
    Rough visuals made before filming so the whole crew shares the director's picture of a scene.
    Compositing
    Layering separate elements, such as generated scenery and smoke, into one final frame.
    Step level savings
    Time saved on one production task, which can be large even when total project cost barely moves.

    Steps

    1. Read the ITmedia NEWS article first, using a browser translator if needed, and list each place AI is used in the drama.
    2. Separate the claims into AI used for planning, AI used in final frames, and the labor figures with their scope.
    3. Note where Daisuke Nagashima says AI helps: scenes limited by location, weather, legal or safety constraints.
    4. Self check: why is a 70 to 80% cut on one step not the same as a 70 to 80% cheaper drama?
    Try it30 min · 5 steps
    You need: Any image generation tool you already use, local or hosted, plus a free image editor with layers; whether an API key is needed depends on the tool you pick.

    Steps

    1. Pick one shot from a short script of your own, such as a building seen from above at dusk.
    2. Time yourself making a rough concept frame by hand, by sketch or by assembling your own photos.
    3. Generate three candidate frames for the same shot with your image tool and time that too.
    4. Composite a separate smoke or weather layer onto the best frame in your editor, keeping the layers editable.
    5. Write down time per step for both paths and which step actually got faster.

    Small angles to try

    • Use the AI frames only as previs and compare how clearly each version communicates the shot to a friend.
    • Try the same exercise with your own real photos as the base plate, mirroring the mix of AI and conventional VFX.
    • Track rejected generations to see how much of the saved time goes into selection.
  16. #16Trends × tech

    AI photo spotting × browser extension: GIGAZINE tests Pangram

    GIGAZINE tried Pangram AI Detection, a Chrome and Firefox extension running the Pangram Image 1.0 model that Pangram released on Nov 4. All four test images were judged as expected: a ChatGPT image, a Qwen Image 2.1 image with no C2PA metadata, a real camera photo, and a real photo edited with AI to add a boiled egg. The free plan allows 4 images per day.

    Heat · GIGAZINE hands on review published Nov 8; no ranking position or social traction seen
    What people foundFor the ChatGPT image the verdict came from the C2PA provenance data ChatGPT embeds, so only the Qwen image really tested pixel analysis. Pangram's 99.96% accuracy figure comes from its own set of 1,200 synthetic images mirrored from 100 real photos, and GIGAZINE advises treating results as one reference among several.
    Learn it15 min · 4 steps

    Key ideas

    C2PA
    A provenance standard that lets tools such as ChatGPT attach signed metadata saying how an image was made, which a detector can read without looking at pixels.
    Pixel based detection
    A classifier that judges whether an image is AI made from the image content alone, needed when metadata is missing or stripped.
    Localization heatmap
    An overlay that marks which regions of an image the model thinks are AI generated, useful for partly edited photos.

    Steps

    1. Read the Pangram blog post introducing Pangram Image 1.0, focusing on how the 1,200 image evaluation set was built.
    2. Read the GIGAZINE review and note which verdict relied on C2PA and which on pixels.
    3. Skim the Pangram image detection API reference to see the fields a result returns, such as prediction, ai_likelihood and detection_source.
    4. Self check: why does a correct verdict on a ChatGPT image say little about how well the detector handles images from a model that adds no C2PA data?
    Try it30 min · 5 steps
    You need: Chrome or Firefox, a free Pangram account, your own photos and a few images you generate yourself; the optional API step needs a Pangram API key with prepaid credits

    Steps

    1. Install Pangram AI Detection from the Chrome Web Store or Firefox Add-ons and sign in on the free plan.
    2. Pick 4 images you own: one camera photo, one image from a generator that embeds C2PA, one from a generator that does not, and one real photo you edited with an AI tool.
    3. Run each through the extension and record the verdict and whether it cites metadata or pixels.
    4. Strip metadata from the C2PA image by taking a screenshot of it, run it again, and compare the verdict.
    5. Optional, with an API key: pip install pangram-sdk, set PANGRAM_API_KEY, then call Pangram().predict_image("image.png", model="pangram-image-1") from from pangram import Pangram and read the returned fields.

    Small angles to try

    • Downscale your edited photo to 256 pixels wide and see whether the verdict or heatmap changes.
    • Compress the same AI image several times as JPEG and track how the likelihood moves.
    • Compare the pixel only verdict on screenshots of images from two different generators.
  17. #17Models & launches

    NVIDIA publishes Dynamo serving recipes for four Korean open models

    At NVIDIA AI Day Seoul, NVIDIA released optimized Dynamo deployment recipes for SK Telecom's A.X K2, LG AI Research's K-EXAONE 2.0, Upstage's Solar Open 2 and Motif Technologies' Motif-3. Dynamo is NVIDIA's open source framework for serving models across many GPUs and nodes, with vLLM, SGLang and TensorRT-LLM backends. The recipes are tuned for B200 GPUs.

    Heat · NVIDIA blog post and AI Day Seoul live blog; no Hacker News or Hugging Face traction seen
    What people foundNVIDIA says the recipes give up to 2x performance out of the box on B200, but the post names no baseline or benchmark for that figure and does not link the recipe files, so treat the number as a vendor claim until you can reproduce it.
    Learn it15 min · 4 steps

    Key ideas

    Disaggregated serving
    Running the prompt processing phase and the token generation phase on separate GPUs so each can be sized and tuned on its own.
    KV cache aware routing
    Sending a request to the worker that already holds matching cached context, which avoids recomputing it.
    Deployment recipe
    A tested bundle of engine, parallelism and config settings for one model on one GPU type.

    Steps

    1. Read the NVIDIA blog post on Dynamo recipes for Korean open models and note what it does and does not specify.
    2. Read the ai-dynamo/dynamo README on GitHub, including the quick start and the section pointing to the recipes/ directory.
    3. Compare one existing recipe in that directory, such as the DeepSeek-R1 disaggregated SGLang example, with an aggregated one to see which settings change.
    4. Self check: what would you need to know before trusting a claim of up to 2x performance, and which of those facts does the NVIDIA post give?
    Try it30 min · 5 steps
    You need: Linux machine with an NVIDIA GPU, Docker with GPU support; No API key needed. The Korean models themselves need B200 class hardware, so this test uses a small model

    Steps

    1. Start the vLLM runtime container from the README: docker run --gpus all --network host --rm -it nvcr.io/nvidia/ai-dynamo/vllm-runtime:1.5.1.
    2. Inside it, start the frontend: python3 -m dynamo.frontend --http-port 8000 --discovery-backend file > /dev/null 2>&1 &.
    3. Start a worker with the README's small model: python3 -m dynamo.vllm --model Qwen/Qwen3-0.6B --discovery-backend file &.
    4. Send a chat request to the OpenAI compatible endpoint at localhost:8000/v1/chat/completions and time the response.
    5. Run the same prompt set against plain vLLM on the same GPU and compare latency and throughput, so you have your own baseline.

    Small angles to try

    • Swap in the SGLang runtime image and compare results on the same prompts.
    • Search the repo's recipes/ directory for the Korean model recipes and read their parallelism settings.
    • Increase concurrency step by step and note where latency starts to climb.
  18. #18Tools & open source

    Recto: a free desktop canvas to visually edit what coding agents build

    Recto is a free desktop app for Mac, Windows and Linux that detects coding agents already on your machine, including Claude Code, Codex, Cursor and OpenCode, and runs them inside a visual canvas for UI, motion, SVG and 3D work. You can edit elements directly or pin a comment that sends feedback to the agent, and several agents can work on one design with no MCP or API setup. Version 0.1.8, dated Nov 8, adds share links, embedding and reworked comment threads.

    Heat · Show HN on Nov 8 with 8 points and 5 comments; earlier Show HN posts on Oct 29 with 4 points and Nov 3 with 8 points and 10 comments
    What people foundRecto is not a model; it sits on top of agents you already pay for and exports plain HTML and CSS. The site does not say whether it is open source, and Figma import is listed as coming soon.
    Learn it15 min · 4 steps

    Key ideas

    Agent harness
    The program that drives a coding agent's CLI, here a canvas app instead of a terminal.
    Direct manipulation
    Changing a design by dragging and editing it instead of describing the change in a prompt.
    Design tokens as CSS variables
    Colors, spacing and type stored as variables that the agent reads before it designs, which keeps output consistent.

    Steps

    1. Read the Recto home page and FAQ for the list of supported agents and how they connect.
    2. Read the Recto changelog entries for 0.1.1 to 0.1.8 to see how the product has grown.
    3. Watch how a pinned comment carries the selected element to the agent, as described on the site.
    4. Self check: what does Recto add that a coding agent in a terminal plus a browser preview does not?
    Try it30 min · 5 steps
    You need: Mac, Windows or Linux desktop with at least one supported coding agent installed and signed in; no extra API key beyond your agent's own

    Steps

    1. Download the 0.1.8 build for your platform from recto.design and open it.
    2. Confirm it detects your installed agent, such as Claude Code or Codex.
    3. Ask the agent for a simple landing page section, then nudge spacing and colors by hand on the canvas.
    4. Pin a comment on one element asking for a change and check that the agent edits only that element.
    5. Export the result as HTML and CSS and open it in a browser to compare with the canvas.

    Small angles to try

    • Give two agents the same design and compare their output side by side.
    • Define a small design system as CSS variables first and see whether the agent respects it.
    • Import a page you own via the web import and restyle it.
  19. #19Trends × tech

    Everyday shopping × LINE Yahoo Agent i: AI drives 22% of Yahoo! Shopping

    At its second quarter earnings, LINE Yahoo said AI assisted transactions were 22% of Yahoo! Shopping's gross merchandise value in September, up 10 points year over year, and that AI users showed 1.7x the conversion rate and 1.7x the pre purchase page views. Its Agent i assistant gets a standalone app in late November, a schedule coordination agent that launches from LINE chats, and a higher paid tier this fiscal year aimed first at heavy token users. Commissions on AI assisted purchases are being tested.

    Heat · Impress Watch earnings coverage; as context, Meta's rival assistant Muse was #1 on the App Store Japan free chart in the feed updated Nov 8
    What people foundAsked about competition, CEO Tsuyoshi Degawa said Agent i's edge is its Japanese restaurant and ryokan data, reviews and partner networks, plus LINE and Yahoo as entry points. The shopping numbers come from LINE Yahoo itself; paid LYP Premium Standard members reached 7.27M, while the 10.9M direct member total includes a counting change.
    Learn it15 min · 4 steps

    Key ideas

    Gross merchandise value
    The total value of goods sold through a marketplace, before fees and returns.
    Conversion rate
    The share of shoppers who end up buying, here compared between AI users and other users.
    Token based pricing
    Charging heavy users by how much model output they consume, which the planned higher tier targets.

    Steps

    1. Read the Impress Watch earnings article, using a translator if needed, and list each Agent i number with its unit.
    2. Separate the figures into usage, conversion and revenue model buckets.
    3. Check the App Store Japan top free feed to see where Muse and ChatGPT rank today.
    4. Self check: why does a 1.7x conversion rate for AI users not prove that the AI caused the extra purchases?
    Try it30 min · 5 steps
    You need: Terminal with curl and jq, any chat assistant you already use, a list of your own past purchases; No API key needed

    Steps

    1. Fetch the Japan top free apps feed: curl -s https://rss.marketingtools.apple.com/api/v2/jp/apps/top-free/50/apps.json | jq '.feed.results[].name'.
    2. Save the output with a date and repeat daily to track where AI assistants such as Muse and ChatGPT sit.
    3. Take 10 of your own past purchases and, for each, ask a chat assistant to recommend a product from the same need without naming the item.
    4. Count how often the suggestion matches or beats what you bought, as a rough personal conversion check.
    5. Note which recommendations needed local data such as reviews or store inventory that a general assistant lacked.

    Small angles to try

    • Run the feed for the US store by swapping jp for us and compare rankings.
    • Repeat the purchase test with a restaurant or hotel search, where Degawa says local data matters most.
    • Track the rank of Yahoo! JAPAN and LINE apps in the same feed over a week.
  20. #20Models & launches

    Meta's Muse Wonder models add Active Memory and Active Focus

    Meta is rolling out specialized versions of its models to Muse and Meta AI users, trained with its Muse Wonder frontier series. They add Active Memory, which tells temporary from permanent and current from stale context, and Active Focus, which lets the model retry, recover or find another route when a task hits an obstacle. On Meta's own tests, the new models score 90% versus 76% on its Active Memory Eval and 47% versus 38% on its Personal Superintelligence Index against the previous Muse model.

    Heat · Announced by Mark Zuckerberg on X and covered by RuntimeWire; engagement counts not verified. Muse was #1 on the App Store Japan free chart in the Nov 8 feed
    What people foundMeta also claims a 2.4x reduction in forgetting critical information and 67% better completion of everyday tasks with unexpected issues. All of these are Meta's own evals with no outside comparison, and the post does not say whether the models are available through the Meta Model API.
    Learn it15 min · 4 steps

    Key ideas

    Context staleness
    Information that was true earlier in a conversation but has since been replaced, which a model must stop relying on.
    Trained recovery
    Teaching the model itself to retry or switch approach after a failure instead of leaving that logic to the agent code around it.
    Vendor eval
    A benchmark built and scored by the company whose model is being measured, useful as a signal but not independent.

    Steps

    1. Read the Meta Research post Bringing Specialized Models to Muse and Meta AI and list each metric with its comparison.
    2. Read the RuntimeWire coverage for context on how Meta positions Muse against other assistants.
    3. Think about how your own agent code currently handles stale memory and failed tool calls.
    4. Self check: what would a fair independent test of the 90% versus 76% memory claim need to control for?
    Try it30 min · 5 steps
    You need: Access to Muse or Meta AI and one other assistant you use, a text file for notes; No API key needed

    Steps

    1. Write 5 short conversation scripts from your own life where a fact changes midway, such as a moved meeting or a changed budget.
    2. Run each script in Muse or Meta AI, then ask a question that depends on the latest value.
    3. Run the same scripts in a second assistant and record which answers used the stale value.
    4. Write 3 tasks with a built in obstacle, such as a requested format the assistant cannot produce, and note whether it recovers or stalls.
    5. Tally your results in a small table as your own mini memory and recovery eval.

    Small angles to try

    • Spread the changed fact across separate sessions to test memory across conversations.
    • Change a fact twice and check whether the assistant tracks the newest version.
    • Steer the assistant mid task and see whether it adapts without restarting.

Get the Radar by email

One email each evening, Japan time, with that day's items. Opening soon: leave your email and we'll send a confirm link when it starts.