Saturday, November 21, 2026
-
Inkling 2 Mini: open 26.4B looped MoE that runs in about 20GB
Thinking Machines Lab released Inkling 2 Mini on November 20 as an open weight model under Apache 2.0. It is a mixture of experts with 26.4B total and 3.4B active parameters, built from 24 layers in four blocks of six where the two middle blocks run three times per token, giving 48 layer passes from 24 stored layers. The lab reports 79.2% on SWE-bench Verified bash only, 71.6% on Terminal Bench v2.1 and 48.2% on DeepSWE v1.1, close to Qwen3.8-27B, which leads on Terminal Bench at 73.0%.
Heat · Hacker News 585 points and 96 comments; the Hugging Face model page shows 159 likesWhat people foundThe single checkpoint is about 20GB in NVFP4 with the last four layers in MXFP8, and at launch Ollama runs it on any Mac with at least 32GB RAM; it also serves withvllm serve "thinkingmachines/Inkling-2-Mini", SGLang ordocker model run hf.co/thinkingmachines/Inkling-2-Mini. The lab itself says it is not the strongest small model for multi turn chat or many constraint instructions, scoring 50.0% on MultiChallenge and 33.4% on ComplexConstraints v1.1, both behind Qwen3.8-27B. The model card warns it can get stuck in repetitive reasoning loops, so cap output tokens and agent turns, and sandbox agent runs.Learn it15 min · 5 steps
Key ideas
- Looped transformer
- The same stored layers are applied several times per token, buying extra depth of computation without storing extra weights.
- Total versus active parameters
- A mixture of experts model stores many expert networks but routes each token through only a few, here 8 of 128 experts per layer, so compute per token is far below the total size.
- NVFP4 and MXFP8
- Low precision number formats, 4 bit and 8 bit with shared scaling factors, that shrink a checkpoint so it fits in laptop memory.
Steps
- Read the Thinking Machines launch post first, focusing on the section that explains which blocks loop and why looping the middle beat looping the end on 27 of 28 evaluations.
- Open the Hugging Face model card and note the 26.4B total, 3.4B active and 5.4B loop adjusted activation counts.
- Compare the benchmark table rows for Inkling 2 Mini and Qwen3.8-27B to see where each one wins.
- Read the limitations section on the model card about reasoning loops and destructive agent actions.
- Self check: why does looping the middle layers three times raise compute per token but not the 20GB memory footprint?
Try it30 min · 6 steps
You need: A Mac with Apple silicon and at least 32GB memory using Ollama, or a Linux machine with an NVIDIA GPU with 32GB or more VRAM and Python for vLLM; about 20GB free disk. No API key needed.Steps
- On a GPU machine run
pip install vllm, then start the server withvllm serve "thinkingmachines/Inkling-2-Mini". - On a Mac instead, install Ollama and pull Inkling 2 Mini from the Ollama library, as the launch post says it is supported at launch.
- Send a chat request to the local OpenAI compatible endpoint, on vLLM at
http://localhost:8000/v1/chat/completions, with a small coding task from your own repo. - Set a firm max output token limit on every request, since the model card warns about repetitive reasoning loops.
- Give it a prompt with many explicit constraints and count how many it obeys, to check the weakness the lab admits on ComplexConstraints.
- Write down tokens per second and answer quality next to the model you use today.
Small angles to try
- Run the same task against Qwen3.8-27B on the same machine and compare correctness and tokens used.
- Try a GGUF build from Unsloth with llama.cpp and compare speed with the official NVFP4 checkpoint.
- Point an agent at a throwaway container only, and see whether it attempts destructive actions without asking.
-
Wiz AI code scanner finds two critical RCE bugs in NGINX HTTP/2
On November 18, F5 and Wiz disclosed CVE-2026-123633, a use after free in HTTP/2 connection handling, and CVE-2026-123007, an integer underflow in HTTP/2 send_window flow control accounting, both rated 9.2 under CVSS 4.0. Wiz found them with Wiz Atlas, the harness behind its AI code scanning product, and used Gemini 4 Carbon and ChatGPT 5.6 Sol to confirm both lead to code execution. Ikotas Labs, Metnir, Rapid7 and Xint found and reported the same bugs independently.
Heat · Hacker News 1511 points and 641 commentsWhat people foundUpgrade NGINX OSS to 1.30.7 stable or 1.31.9 mainline, or NGINX Plus to the fixed builds F5 lists. If upgrading must wait, Wiz says to sethttp2 off;in affected server blocks on 1.25.1 or later and remove thehttp2parameter fromlistendirectives, then reload and confirm old workers have exited. Wiz says ASLR does not help because either bug can be used to read memory first, and only installs with HTTP/2 enabled are affected.Learn it15 min · 5 steps
Key ideas
- Use after free
- Code keeps using memory after it has been released, so an attacker who controls what gets placed there can steer the program.
- Integer underflow
- Subtracting below zero in an unsigned counter wraps it to a huge value, which can break size checks such as an HTTP/2 flow control window.
- HTTP/2 flow control window
- A per stream and per connection credit counter, send_window in NGINX, that limits how much data a side may send before the peer grants more.
Steps
- Read the Wiz Research post first, especially the affected and fixed version table.
- Read the NGINX
ngx_http_v2_moduledocs to see how thehttp2directive, added in 1.25.1, enables HTTP/2 per server. - Note why Wiz says ASLR offers no protection: a memory read comes before code execution.
- Note that several teams found the same bugs independently, a sign of how common AI assisted bug hunting has become.
- Self check: on a server running NGINX 1.31.8 with only
listen 443 ssl;and nohttp2 on;, is it exposed?
Try it30 min · 5 steps
You need: Shell access to NGINX hosts you own, or Docker on your own machine with the official nginx image; no exploit code, configuration checks only. No API key needed.Steps
- On each server you own, run
nginx -vto print the version and compare it with the fixed 1.30.7 stable and 1.31.9 mainline releases. - Run
nginx -Tto dump the full configuration and search the output forhttp2 on;and forhttp2on anylistenline. - In a local container with a copy of your configuration, apply the mitigation:
http2 off;in each server block and removehttp2fromlistendirectives. - Run
nginx -tto validate the edited configuration, thennginx -s reload, and confirm in the process list that old worker processes have exited. - Plan the real upgrade to a fixed version and re enable HTTP/2 once it is deployed.
Small angles to try
- Write a small script that runs
nginx -vandnginx -Tacross your own fleet and flags hosts with HTTP/2 on and a version below the fix. - Check your container base images and distro packages for which NGINX version they ship.
- Read the F5 advisory diff for each CVE once published, to see how the flow control accounting was changed.
-
Gemini 4 Neon: $3 in, $15 out per M tokens, 1M context, tops MEI
Google DeepMind released Gemini 4 Neon on November 18, positioned between Carbon for the hardest long projects and Hydrogen for fast everyday work. Google reports 65.2% on Terminal-Bench 4.1, first place on the Artificial Analysis Coding Agent Index at 58.6, and a cost per task 32% below Carbon at high thinking. It has four thinking levels with high as the default, a 1M token context, and in Antigravity it can orchestrate parallel Hydrogen subagents.
Heat · Hacker News launch thread 1048 points and 776 comments, plus follow up threads at 362 points and 240 comments and 255 points and 78 commentsWhat people foundThe Models Engineering Index, a composite of 16 coding benchmarks scaled so models average 50, puts 4 Neon first at 68.4, ahead of GPT-6.2 Astra at 67.1 and Fable 5.2 at 66.7. Writing on micjm.com, the author measured 127 tokens per second on OpenRouter on launch day versus 46 for Carbon and called it "an incremental benchmark improvement with a very large speed improvement". Cached input costs $0.15 per M tokens, a 95% discount that matters most for long agent sessions that reuse a prompt prefix.Learn it15 min · 5 steps
Key ideas
- Thinking levels
- A setting that controls how much hidden reasoning the model does before answering, trading cost and latency for quality.
- Cached input pricing
- Tokens in a prompt prefix the provider has already processed are billed at a steep discount when sent again.
- Orchestrator and subagents
- One stronger model splits a task and sends parts to several cheaper, faster models running in parallel.
Steps
- Read the Google blog launch post first, noting the pricing block and where Neon sits between Carbon and Hydrogen.
- Open the Models Engineering Index page and see how a composite of 16 benchmarks is normalized to an average of 50.
- Read the micjm.com post for an outside view on speed versus benchmark gains.
- Work out what a 95% cached input discount does to the cost of an agent loop that resends a 200k token context ten times.
- Self check: if Neon is only slightly better on benchmarks than Carbon, what would make it worth switching for your agent workload?
Try it30 min · 5 steps
You need: A Gemini API key on the paid tier from Google AI Studio, and a few dollars of credit; any language with an HTTP client or the official Google SDK.Steps
- Create or reuse a paid tier key in Google AI Studio and select the model id
gemini-4-neon. - Pick three coding tasks from your own repo, such as a bug fix, a refactor and a test to write, and save the prompts.
- Run each prompt at the default high thinking level and at xhigh, recording wall time, output tokens and cost from the usage data.
- Resend one long prompt with an unchanged prefix and check whether cached input tokens are billed at the lower rate.
- Run the same prompts on the model you use today and score the answers side by side.
Small angles to try
- Compare tokens per second against Gemini 4 Carbon on the same prompts to check the speed gap micjm.com reported.
- In Antigravity, let Neon orchestrate Hydrogen subagents on a multi file change and compare with a single agent run.
- Fill most of the 1M context with your own codebase and ask questions that need facts from far apart files.
-
GPT-6.2 Astra and Sol: CodeRabbit finds more bugs but far more noise
OpenAI's GPT-6.2 Astra costs $8 in and $40 out per M tokens, 20% below GPT-6 Astra, while GPT-6.2 Sol stays at $2 and $10; both are in the API as gpt-6.2-astra and gpt-6.2-sol after a November 17 launch. On November 19 CodeRabbit published the first independent code review test: Astra 6.2 caught 58 of 83 known issues versus 51 for GPT-6 Astra. Its reported comments rose from 331 to 847, and actionable precision fell from 21.74% to 12.22%.
Heat · Hacker News launch thread 1346 points and 863 comments on November 17; the CodeRabbit follow up has no separate measured heatWhat people foundCodeRabbit is keeping its current review defaults while it tests further: Sol 6.2 at high reasoning caught 60 of 81 issues versus 58 for Sol 6.1, but precision fell from 35.3% to 25.9% and mean recorded cost per review rose from $0.772 to $1.146. The lesson for anyone running an AI reviewer is to measure precision and cost, not only bugs caught, before switching defaults. Simon Willison found both models weaker than Fable 5.2 and Gemini 4 Carbon on his Yonkers mech prompt, and shipped LLM 0.38 with support for both.Learn it15 min · 5 steps
Key ideas
- Recall versus precision in code review
- Recall is the share of known bugs the reviewer flags, while precision is the share of its comments that point to a real known bug.
- Actionable comment
- A review comment that asks for a concrete change, as opposed to a nitpick or a remark outside the diff.
- Replay cost
- CodeRabbit's cost figures come from replaying recorded runs, so they compare configurations rather than predict a production bill.
Steps
- Read the CodeRabbit review post first, including the methodology on how an issue counts as caught.
- Read the OpenAI launch page for pricing and the model ids.
- Read Simon Willison's post for an outside qualitative view and the LLM 0.38 note.
- Compute for yourself how many extra comments a reviewer must read when precision drops from 35.3% to 25.9%.
- Self check: why can a model that catches more bugs still be a worse default for automated review?
Try it30 min · 5 steps
You need: Python, thellmCLI at version 0.38 or later, and an OpenAI API key with a few dollars of credit.Steps
- Install LLM with
pip install llm, or upgrade an existing install withllm install -U llm, then runllm keys set openaiand paste your key. - Take a diff from your own repo and plant three known bugs in it, writing them down.
- Ask each model to review it, for example
llm -m gpt-6.2-sol 'Review this diff and list concrete bugs'with the diff included in the prompt, then repeat withgpt-6.2-astra. - Count bugs caught and total comments for each model, then compute precision the way CodeRabbit does.
- Repeat with the model you use today and note cost per review from the token usage.
Small angles to try
- Run the same diff three times per model to see how stable the comment count is.
- Add an instruction to report only bugs, no style notes, and see whether precision recovers.
- Compare against Fable 5.2 or Gemini 4 Carbon on the same planted bugs.
-
Report card season × prompt templates: one line halves rewrites
A posfie roundup published November 20 of seven "paste at the top" prompts from X user @ikayaki_aiafi went viral in Japan. The prompts cover an expert persona, conclusion first, a three line plain summary, the strongest counterargument, sources required with "source unknown" otherwise, admitting uncertainty, and a self check. The most quoted reply came from a teacher, who said adding "as a junior high homeroom teacher, in positive words" before asking for report card comments cut rewrites roughly in half.
Heat · 181 Hatena bookmarks and a spot in Hatena's Technology hot entries on November 21What people foundThe poster's claim that the self check prompt makes answers 1.5 times more accurate comes with no data, and the teacher's halved rewrites is a single anecdote. A reply from @growaiskills added the useful fix: a required citation only helps if someone opens the link and confirms it supports the claim. The practical pattern is that concrete role plus tone context did more for a real task than the generic tricks.Learn it15 min · 4 steps
Key ideas
- Role and audience context
- Telling the model who is writing and for whom narrows tone and content far more than a generic expert persona.
- Citation grounding
- Asking for sources only reduces errors when the sources are checked, since models can produce plausible links that do not support the claim.
- Self check prompting
- Asking the model to review its own answer for contradictions can catch some slips but gives no guarantee of accuracy.
Steps
- Read the posfie roundup first, using a browser translation if needed, and list the seven prompts.
- Read the teacher reply and the citation check reply, and note which claims are measured and which are anecdotes.
- Pick one real writing task of your own and decide what role and audience line would fit it.
- Self check: which of the seven prompts would you expect to change output the most for your task, and how would you measure it?
Try it30 min · 5 steps
You need: Any chat model you already use, a text editor and a short task of your own; No API key needed if you use a chat app.Steps
- Pick a recurring writing task of your own, such as release notes or code review summaries, and gather five past inputs.
- Run each input with your usual prompt and count how many outputs you would rewrite.
- Add one specific role and tone line in the teacher's style, for example the team and audience you write for, and run the same inputs again.
- Add the source requirement prompt to a factual question, then open every cited link and count how many truly support the claim.
- Compare rewrite counts and verified citations between the runs and keep only the lines that helped.
Small angles to try
- Test the self check prompt alone and see whether it changes any factual errors you can verify.
- Combine all seven prompts at once and check whether the answer gets better or just longer.
- Try the same role line in Japanese and English to see whether language changes the effect.
Sources:posfie roundup, Japanese -
Ruby2Shell: a one byte overflow on ß gives pre auth RCE on stock Rails
Veria Labs disclosed Ruby2Shell, tracked by Veria as CVE-2026-132825 and by ruby-lang as GHSA-34m4-m9fh-gqp5 while the CVE is pending. Upcasing the German ß in ISO-8859 or Windows-125x strings writes two bytes where the bounds check allows one, and Veria says this reaches unauthenticated remote code execution on default Rails and classic style Sinatra. Stephan Lipp of Ada Logics with Anthropic, and Moritz Sanft working with OpenAI, are credited with the underlying primitive; GitLab, Mastodon, Discourse, Chatwoot and OpenProject have shipped fixes, while GitHub Enterprise Server 3.22.5 and earlier has none yet.
Heat · Hacker News: 391 points and 169 comments on the Veria write up, plus 341 points and 131 comments on the ruby-lang advisoryWhat people foundUpgrade to Ruby 3.3.14, 3.4.13 or 4.0.10 now; Ruby 3.2 and older are end of life and get no fix. Veria plans to publish a stock Rails proof of concept on 25 November 2026, so the patch window is days, not weeks.Learn it15 min · 5 steps
Key ideas
- Case conversion expansion
- Some characters grow when upcased, so ß becomes the two letters SS, and code that assumes one output byte per input byte can overrun its buffer.
- Single byte encodings
- ISO-8859 and Windows-125x store each character in one byte and take a different code path in Ruby than UTF-8, which is not affected.
- Heap overflow to RCE
- Writing even one byte past a heap buffer can corrupt nearby memory structures that an attacker then steers into running code.
Steps
- Read the Veria Labs Ruby2Shell post first for the affected versions table and the downstream product list.
- Read the ruby-lang advisory of 18 November, which lists seven related regex and string flaws with GHSA ids and the fixed releases.
- Note which string methods are affected according to Veria: upcase, swapcase, downcase with :fold, and casecmp?.
- Map the affected range: code present since Ruby 2.4.0, fixed in 3.3.14, 3.4.13 and 4.0.10.
- Self check: why does a UTF-8 only Rails app on Ruby 3.4.12 still need the upgrade, according to Veria?
Try it30 min · 5 steps
You need: Your own machines or containers with Ruby installed, read access to your own repos and self hosted services. No API key needed. No exploit code; inventory and patch checks only.Steps
- On each of your own servers and containers, run
ruby -vand compare the result against the fixed versions 3.3.14, 3.4.13 and 4.0.10. - Search your own repos for pinned Ruby versions, such as a .ruby-version file, the ruby line in a Gemfile, and base image tags in Dockerfiles, and list every one below the fixed releases.
- For self hosted GitLab, Mastodon, Discourse, Chatwoot or OpenProject, compare your installed version with the fixed releases in the Veria table and schedule the vendor upgrade.
- Search your own application code for upcase, swapcase and casecmp? calls on strings in legacy encodings, since Veria warns these can be exposed even outside Rails.
- After upgrading, rebuild your containers, rerun
ruby -vinside them, and run your test suite to confirm nothing regressed.
Small angles to try
- Add a CI check that fails the build when the Ruby version is below the patched releases.
- Read the seven GHSA entries in the ruby-lang advisory and note which ones touch regex compilation versus string case conversion.
- If you run GitHub Enterprise Server 3.22.5 or earlier, track the vendor advisory since no fix exists yet.
-
LLM assisted reverse engineering: Ghidra MCP, skills and a hypothesis loop
A practitioner post on slowchronicle.com describes reverse engineering binaries mostly with DeepSeek v4.1 Flash in the DeepSeek Harness, driving Ghidra through an MCP bridge and using radare2 as a faster command line option. It shares a Ghidra tooling skill and a hypothesis debugging skill that logs every hypothesis and result to a CSV file. Quick probes are Python scripts run with uv, and the final hacks and tools are written in Rust.
Heat · Hacker News: 315 points and 82 comments, posted 18 NovemberWhat people foundThe author says agents without a tooling skill give up too quickly. The practical lessons: make the agent keep Markdown notes so it does not lose track after compaction or handoff, read its full traces to spot blind paths, and pick Rust for the final code because the strict compiler points the agent straight at memory and syntax issues.Learn it15 min · 5 steps
Key ideas
- MCP bridge
- A Model Context Protocol server that exposes a desktop tool such as Ghidra as callable functions an agent can use.
- Agent skill
- A packaged set of instructions and scripts an agent loads to learn a workflow, such as how to drive a decompiler.
- Hypothesis loop
- A cycle of one testable guess, one experiment and one recorded conclusion, repeated so the agent stops trying random things.
Steps
- Read the slowchronicle.com post first, focusing on the process section and the list of skills.
- Open the hypothesis debugging repo README and note the five step loop and the HYPOTHESES.csv log.
- Skim the ghidra decompile skill repo to see how it describes Ghidra, radare2 and kuna to the agent.
- Compare the lessons on Markdown notes and trace reading with how you currently run long agent sessions.
- Self check: what two problems do the Markdown notes and the CSV log each solve for a long agent run?
Try it30 min · 5 steps
You need: A coding agent that supports skills, Node.js for npx, uv, and radare2 or Ghidra installed locally. A small binary you compiled yourself from your own code. The agent needs whatever model API key it normally uses.Steps
- Write a tiny C or Rust program of your own with a hidden check, such as a password compare, and compile it to a binary.
- Install the hypothesis debugging skill with
npx skills add ioma8/hypothesis-debugging. - Ask the agent to find the hidden check with radare2 or Ghidra, keeping notes in a Markdown file and logging each hypothesis in HYPOTHESES.csv.
- Have it write a probe script with
uv init --script probe.py, add any packages withuv add --script probe.pyfollowed by the package names, and run it withuv run probe.py. - Read the full trace and the CSV afterwards and count how many hypotheses were disproved before the right one.
Small angles to try
- Run the same task with and without the tooling skill and compare how early the agent stops.
- Force a compaction or start a fresh session halfway and see whether the Markdown notes let it resume.
- Apply the hypothesis loop to a flaky test in your own codebase instead of a binary.
-
Signal blocks OS AI agents from reading chats and asks for an opt out
In a 20 November post, Meredith Whittaker says Signal now blocks screenshots on iOS 27 behind a Block Siri AI setting, and on Android turns on Screen security when it detects an AI assistant reading the screen. On macOS 27 Signal cannot block Siri AI, so users must add Signal to the Excluded Apps list under System Settings, Siri. Signal asks Apple, Google and Microsoft for a documented developer opt out from AI data access covering screen reading, the filesystem, notifications and APIs.
Heat · Hacker News: 548 points and 320 commentsWhat people foundSignal says third party agents such as Meta's Muse use accessibility permissions as a skeleton key to read app data, and admits screenshot blocking is incomplete because agents can still reach stored content through the filesystem. Any app handling sensitive data has the same gap and no clean OS opt out today.Learn it15 min · 5 steps
Key ideas
- OS level AI agent
- An assistant built into or granted deep access to the operating system that can see screens, files and notifications across apps.
- Accessibility permissions
- OS permissions meant to help people with disabilities use apps, which also let software read and act on any app's interface.
- Screen security
- An app setting that marks its windows as secure so screenshots and screen readers capture nothing.
Steps
- Read the Signal blog post by Meredith Whittaker first, especially the per platform sections.
- List the four access paths Signal names in its opt out request: screen reading, filesystem, notifications and APIs.
- Note why Signal says confidential computing alone does not solve the problem.
- Think about which of those paths your own app's sensitive data travels through.
- Self check: why does blocking screenshots not protect messages already stored on the device?
Try it30 min · 5 steps
You need: Your own phone or Mac with Signal updated, and optionally your own app project. No API key needed.Steps
- Update Signal on your own iOS 27 device and find the Block Siri AI setting in Signal settings.
- On your own Mac running macOS 27, open System Settings, Siri, and add Signal under Excluded Apps.
- On your own Android phone, open Signal settings and check whether Screen security is on.
- Try a screenshot in Signal on each device and note what is captured.
- In your own app, list every screen that shows sensitive data and check whether it uses the platform's secure window option.
Small angles to try
- Review which apps on your own devices hold accessibility permissions and revoke the ones you do not need.
- Check which of your own app's data is readable from the filesystem by other apps, not just from the screen.
- Draft the opt out API you would want from the OS vendors for your app's threat model.
-
Microsoft's Ignite models: MAI Code 2 lands in GitHub Copilot
On 17 November at Ignite, Microsoft AI announced seven in house models: MAI Code 2 and MAI Code 2 Flash for coding, MAI Cyber 2 Flash, MAI Image 2.7, MAI Realtime 1 for speech to speech, Dragon Copilot Transcribe and the Decision 1.1 routing model. Microsoft says MAI Code 2 reaches 98% of GPT-6.1 Sol's performance at about 40% of its cost, averaged over DeepSWE 1.1, Terminal Bench 2.1, SWE-Atlas and FrontierCode v1.1, with the cost shown at a 50% promotional price. No parameter counts were disclosed.
Heat · Hacker News: 602 points and 377 comments on the seven models post, plus 422 points and 171 comments on the MAI Code 2 threadWhat people foundMAI Code 2 and Code 2 Flash are already selectable in GitHub Copilot, and Microsoft puts MAI Code 2 at 96% of Claude Opus 5.5's performance for about 5% of the cost, again at promotional pricing. These are vendor averages run at max reasoning effort, and Microsoft says the models are not yet tuned for very long horizon agent work, so test on your own repo before switching.Learn it15 min · 5 steps
Key ideas
- Vendor benchmark average
- A single score the model maker computes across several benchmarks it picked, which can hide weak spots on any one task.
- Promotional pricing
- A temporary discount, here 50%, that makes cost comparisons look better than standard pricing will.
- Model router
- A small model like Decision 1.1 that sends each request to the cheapest model able to handle it.
Steps
- Read the Microsoft AI post on MAI Code 2 and MAI Code 2 Flash first, including its caveats section.
- Read the seven models overview for availability and pricing of the rest of the batch.
- Note what each comparison is against: GPT-6.1 Sol and Claude Opus 5.5 for Code 2, GPT-6 Luna and Claude Haiku 5.5 for Code 2 Flash.
- Note where each model is available: Copilot, Foundry limited access preview, MAI Labs, or a registration form.
- Self check: which two conditions behind the 40% cost figure would change your real bill?
Try it30 min · 5 steps
You need: A GitHub Copilot plan with model selection, an editor with Copilot, and your own repo. No separate API key needed for Copilot; MAI Realtime 1 is tried in MAI Labs.Steps
- In GitHub Copilot, open the model picker and select MAI Code 2.
- Give it a real multi file task from your own repo, such as a small refactor with tests, and save the result on a branch.
- Repeat the identical task with the model you use today and save that result on a second branch.
- Compare test pass rate, number of fix up turns and review time for the two branches.
- Repeat with MAI Code 2 Flash on a routine fix to see whether the cheaper model is enough for that class of task.
Small angles to try
- Try a frontend UI task, since Microsoft claims developers preferred MAI Code 2 over GPT-6 Sol 64% of the time in blind tests.
- Try MAI Realtime 1 in MAI Labs at labs.microsoft.ai and judge speech to speech latency yourself.
- Give it a long agent task and see where it breaks, given Microsoft's own warning about long horizon work.
-
SenseNova Loop-9B: SenseTime loops 24 layers twice for 14.6B compute
SenseTime released SenseNova Loop-9B on 17 November, a text and image input model with 32 distinct decoder layers where layers 4 to 27 run twice with shared weights, giving 56 layer computations per pass and about 14.6B inference equivalent parameters. It groups three linear attention layers with one full attention layer and supports up to 512K tokens of context. Weights are on Hugging Face under Apache 2.0, gated behind accepting the access conditions.
Heat · Hugging Face: sensenova/SenseNova-Loop-9B shows 453 likes and 1,631 downloads last month; no Hacker News thread foundWhat people foundThe official 4 bit AWQ build is about 4.9GB and needs roughly 15 GiB of GPU memory at 256K context with an 8 bit KV cache, but SenseTime says the vLLM PR supports only unquantized text inference so far. Loop count matters: four loops lifted LiveCodeBench V6 by 8.10% over a single pass, though the release defaults to two loops for efficiency.Learn it15 min · 5 steps
Key ideas
- Looped layers
- Running the same block of layers more than once per token so a small download spends more compute at inference.
- Hybrid linear attention
- Mixing cheap linear attention layers with occasional full attention layers to keep long contexts affordable.
- AWQ quantization
- A 4 bit weight compression method that shrinks the model so it fits on a consumer GPU with little quality loss.
Steps
- Read the SenseTime release post first for the architecture and the loop ablation table.
- Read the Hugging Face model card for the config details, memory table and serving instructions.
- Compare the loop ablation results: three loops best on AIDAbench QA, four loops best on LiveCodeBench V6.
- Check the memory table for 64K, 128K and 256K context with 8 bit and 4 bit KV cache.
- Self check: what does the model gain from 56 layer computations while storing only 32 layers of weights?
Try it30 min · 5 steps
You need: Python with a CUDA build of PyTorch, a large NVIDIA GPU for BF16 weights, and a Hugging Face account that has accepted the model's access conditions. No paid API key needed.Steps
- Log in to Hugging Face and accept the access conditions on the sensenova/SenseNova-Loop-9B page.
- Install the pinned packages from the model card with
python -m pip install "transformers==5.18.0" accelerate safetensors. - Load the tokenizer and model with
trust_remote_code=Trueanddtype=torch.bfloat16, following the model card quickstart. - Generate with the chat template,
enable_thinking=Trueandmax_new_tokens=512, on a few coding prompts of your own. - Record GPU memory use and tokens per second, then compare answers against a single pass 9B class model you already use.
Small angles to try
- Serve the BF16 model with vLLM built from PR #64832 as described on the model card, and skip the AWQ path for now.
- Try the SGLang build from PR #47281 and compare throughput with vLLM.
- Feed it a long document of your own near 128K tokens and check whether answers hold up.
-
DreamCoder: a tiling coding agent IDE from the Mastering Emacs author
Mickey Petersen, author of Mastering Emacs, launched DreamCoder, a browser based coding harness and IDE he built over about 15 months starting in May 2025. It offers backgroundable subagents, MCP servers, skills, hooks, an agent studio, terminals beside chats and a tiling pane manager with Emacs style keys, plus an importer for Pi, OpenCode and Codex configs. Builds are listed for macOS, Windows, Linux and Docker, and the author recommends local open weight models such as Qwen 3.8 27B.
Heat · Hacker News, 202 points and 56 comments on 20 NovemberWhat people foundDreamCoder runs its own tool loop rather than wrapping another harness. HN commenter cmrdporcupine pointed out that it runs locally yet asks for account registration and a EULA, and called the coding harness market saturated, so weigh that before moving a team over.Learn it15 min · 4 steps
Key ideas
- Coding harness
- The program around a model that runs the tool loop, reads files, calls commands and feeds results back to the model.
- Backgroundable subagent
- A helper agent that keeps working on a side task while the main chat stays free for other requests.
- Tiling pane manager
- A layout system that splits the screen into non overlapping panes, here used to watch several chats and terminals at once.
Steps
- Read the announcement post on masteringemacs.org first, focusing on the feature list and the section on local models.
- Skim the HN thread for the objections about registration, the EULA and how crowded the harness market is.
- Compare the feature list with the harness already in use, such as Codex or OpenCode, and note what is new: pane management, agent studio, event graph.
- Self check: what does it mean that DreamCoder uses its own tool loop, and why would that matter when switching models?
Try it30 min · 6 steps
You need: A macOS, Windows or Linux machine or Docker; an account registration with DreamCoder; either a model API key or a local model server for an open weight model such as Qwen 3.8 27B on a high end GPU or Mac.Steps
- Download the build for your platform from the dreamcoder.ai download page and read the EULA before accepting it.
- Create a throwaway git repo of your own with a small bug and a failing test to use as the task.
- Use the importer to bring in an existing Pi, OpenCode or Codex config, or set up a model by hand following the in app settings.
- Ask the agent to fix the failing test while a background subagent writes a short README, and watch both in tiled panes.
- Try the type to search palette with
Alt+xand the pane local palette withAlt+cto see how keyboard driven the workflow is. - Record how many turns the fix took and whether the diff was clean.
Small angles to try
- Run the same task on a local Qwen 3.8 27B and on a hosted model and compare quality and speed.
- Run the same task in your current harness and compare the number of tool calls.
- Try the Docker build to keep the agent isolated from your main machine.
-
Mastra Factory: open source agent kanban behind 238 PRs in one week
The Mastra team open sourced Factory, the agent system they use to maintain their TypeScript agent framework. It is a configurable agentic kanban board that can be tagged in Slack, built on Mastra durable agents, conversational memory, a markdown wiki with source citations, PR comment signals and cloud sandboxes. It can run fully on your own infrastructure, and a hosted version is also offered.
Heat · Show HN, 154 points and 43 comments on 18 NovemberWhat people foundThe Mastra team reports 238 PRs opened by Factory in one week across the mastra-ai org, next to 630 PRs from humans, and says it closed its repo to outside contributors in favor of detailed issue repros. That is a concrete data point on how an agent pipeline changes contribution policy, not only throughput.Learn it15 min · 4 steps
Key ideas
- Agentic kanban
- A task board where cards move from issue to plan to implementation to reviewed PR, with agents doing the work at each stage.
- Durable agent
- An agent whose long running session state is persisted, so it can pause, resume and survive restarts.
- pgvector
- A Postgres extension that stores embeddings and runs similarity search, used here for memory and retrieval.
Steps
- Read the Show HN post first for the motivation, the PR numbers and the decision to close the repo to outside PRs.
- Read the template-factory README sections on requirements and environment variables.
- Map the pipeline in your head: issue, plan, implementation in a sandbox, PR, review signals from PR comments.
- Self check: why does Factory keep its own project separate from the repository the agents change?
Try it30 min · 6 steps
You need: Node.js matching the version in package.json, Postgres with the pgvector extension, a GitHub App connection to a repo you own, and a model provider API key or supported subscription. Platform mode also needs a Mastra platform sign in.Steps
- Create a small test repository of your own on GitHub with two or three simple issues.
- Scaffold a project with
npm create factory, ornpm create factory -- --no-platformfor the plain template. - Generate an encryption key with
openssl rand -base64 32and put it in.envasFACTORY_CREDENTIAL_ENCRYPTION_KEY, along withDATABASE_URLfor your Postgres. - Start the server with
npm run dev, open the local URL it prints and finish onboarding by picking your test repo and a model provider. - Move one issue onto the board and follow it until a PR appears, then review the diff and the PR comments.
- Leave a review comment on the PR and check whether the agent picks it up as a signal.
Small angles to try
- Connect Slack and tag the board from a channel instead of the UI.
- Compare a vague issue with a detailed repro issue and see which produces a better PR.
- Run
npm run buildandnpm run startto try the production mode on one machine.
-
DaisyRose-27B: RL tuned Qwen3.8-27B agent model in BF16, FP8, NVFP4
RadixArk, the team behind the Miles RL framework, released its first model on 18 November. DaisyRose-27B is Qwen3.8-27B trained with reinforcement learning on about 1,200 curated long horizon agent tasks with sessions up to 1M tokens, over 18 days on 144 H200 GPUs. Terminal Bench 4.1 pass@1 went from 5.6% to 12.0% and DeepSWE v1.1 from 42.2 to 46.2, with smaller gains on other benchmarks.
Heat · Hacker News, 193 points and 63 comments; the Hugging Face page shows 261 likesWhat people foundRadixArk credits the gains mostly to data: each task targets a known failure of the base model, difficulty is calibrated, and tasks that could be passed without real work were fixed or dropped. The weights are Apache 2.0 on Hugging Face in BF16, FP8, NVFP4 and GGUF, and the card says one GPU is enough, from H200 down to an RTX 5090.Learn it15 min · 4 steps
Key ideas
- Agentic RL
- Reinforcement learning where the model is rewarded for finishing multi step tool using tasks, not for single answers.
- Reward hacking
- When a model finds a shortcut that earns the reward without solving the task, which careful task review tries to prevent.
- NVFP4
- A 4 bit floating point weight format for NVIDIA Blackwell GPUs that cuts memory to roughly 23 GB for this model.
Steps
- Read the RadixArk blog post first, especially the sections on task curation and sandboxes.
- Open the Hugging Face model card and compare the benchmark table for DaisyRose against base Qwen3.8-27B.
- Note which benchmarks moved most and which barely moved, such as HLE at 33.9 to 34.3.
- Self check: why would targeting the base model's specific failure modes matter more than adding more generic tasks?
Try it30 min · 5 steps
You need: An NVIDIA GPU with enough memory: about 52 GB for BF16, 29 GB for FP8, or 23 GB for NVFP4 on Blackwell only; Python with vLLM or SGLang; No API key needed.Steps
- Pick the variant that fits your GPU:
RadixArk/DaisyRose-27B,RadixArk/DaisyRose-27B-FP8orRadixArk/DaisyRose-27B-NVFP4. - Install the server with
pip install vllm. - Start it with
vllm serve "RadixArk/DaisyRose-27B", swapping in the variant id you chose. - Send it a multi step task on a scratch repo of your own through the OpenAI compatible endpoint, for example fixing a failing test.
- Run the same prompt against base Qwen3.8-27B and compare success and number of tool calls.
Small angles to try
- Serve it with SGLang using
python3 -m sglang.launch_server --model-path "RadixArk/DaisyRose-27B"and compare throughput. - Try the GGUF variant on a smaller local setup.
- Plug the endpoint into your own coding harness and run a small set of your real tasks.
-
Onlook relaunches as an agentic design canvas over your real codebase
Onlook, from YC W25, relaunched as an Electron desktop app that puts an infinite canvas over your repo, where every frame is a live webview of the running app. It creates a git worktree, starts your dev server and turns each agent change into a normal git diff that can become a GitHub PR. It ships no model of its own and runs Claude Code or Codex on your existing subscription.
Heat · Launch HN, 124 points and 85 comments on 19 November; the GitHub repo shows 27.0k stars, mostly earned by the earlier productWhat people foundThe founder explained that all canvas frames share one browser session, so Chromium's limit of six connections per host makes many frames of one app compete for connections. The desktop editor is Apache 2.0, and an MCP server so any agent can drive Onlook is announced as coming soon.Learn it15 min · 4 steps
Key ideas
- Git worktree
- A second working directory linked to the same repo, so an agent can edit a branch without touching your main checkout.
- Live webview frame
- An embedded browser view showing the real running app, rather than a static mockup.
- Connections per host limit
- Browsers cap simultaneous connections to one host, which slows pages when many frames load from the same dev server.
Steps
- Read the Launch HN post first for how the canvas, worktree and agent fit together.
- Read the founder comments in the thread about the Chromium connection limit and the MCP plans.
- Skim the GitHub README to see what the open source editor contains.
- Self check: why does running edits in a git worktree make agent design changes easier to review?
Try it30 min · 5 steps
You need: A desktop machine that can run the Electron app, an existing Claude Code or Codex subscription, and a frontend repo of your own with a working dev server.Steps
- Download the desktop editor from the onlook.com install page.
- Import a small frontend repo of your own or upload a local folder, and let Onlook create the worktree and start the dev server.
- Open two or three frames of different pages on the canvas and ask the agent for one visual change, such as spacing or a button style.
- Inspect the resulting git diff in the worktree and decide whether you would merge it.
- Open more frames of the same app and note whether loading slows, matching the connection limit the founder described.
Small angles to try
- Run the same change once with Claude Code and once with Codex and compare the diffs.
- Ask for a responsive layout change and check the frames at different widths.
- Compare against making the same edit directly in your coding agent without the canvas.
-
AI assisted math: unverified Lean only RH proof and Navier-Stokes blowup
Mathematician Levent Alpöge posted a note saying that, working with Claude, he believes he found a proof of the Riemann Hypothesis and that the method extends to the Generalized Riemann Hypothesis. He released only a Lean formalization, split into 14 archive parts, because the argument is too long to write up readably; Terence Tao describes the AI as an internal AI model. Tao's 20 November post also covers claims of finite time blowup for the unforced 3D Euler and Navier-Stokes equations by Alpöge, Tristan Buckmaster and coauthors, made with heavy AI use and formalized in Lean, and none of the results has been verified by experts yet.
Heat · HN, 2,592 points and 1,787 comments on the PDF; Tao's post 435 points; Scott Aaronson's post 278 points and 248 commentsWhat people foundScott Aaronson writes that he is not certain but that his bet is the proof will stand, and notes it runs to 17.4 million lines of Lean. Tao gives no verdict, ranks the results from the Euler blowup as most digested to the RH claim as least, and points readers to a Lean Zulip thread where checking is happening.Learn it15 min · 5 steps
Key ideas
- Lean formalization
- A proof written in the Lean language so that a small trusted kernel can check every step mechanically.
- Generalized Riemann Hypothesis
- The claim that the nontrivial zeros of a whole family of L functions, not only the zeta function, lie on one critical line.
- Finite time blowup
- A solution of a fluid equation that starts smooth but develops an infinite value in finite time.
Steps
- Read Terence Tao's 20 November post first, since it separates the three results by how digested they are.
- Read the first pages of Alpöge's remark PDF for what is claimed and why only Lean was released.
- Read Scott Aaronson's post for an outside view on trusting a machine checked proof no human has read.
- Skim the Lean Zulip discussion thread to see what checkers are looking at.
- Self check: if the Lean kernel accepts the proof, what else must be true before mathematicians accept the theorem?
Try it30 min · 5 steps
You need: A laptop with Lean 4 installed through the official installer and git; No API key needed. The full RH archive is very large, so this test uses the smaller public Euler repo.Steps
- Install Lean 4 following the official Lean documentation.
- Clone the public Euler blowup formalization from github.com/mcoiculescu/EulerBlowupPublic.
- Read its README and build it with the tool it names, noting how long the build takes.
- Open the main theorem file and find the statement that is claimed, then compare it with the statement in the paper linked from Tao's post.
- Use Lean's command for printing the axioms a theorem depends on, as described in the Lean docs, to see what the result relies on.
Small angles to try
- Do the same with the Navier-Stokes repo from github.com/tristanbuckmaster/navier-stokes and compare sizes.
- Count the lines of Lean in one repo and estimate how long a full human review would take.
- Follow the Zulip thread for a week and note which concerns are raised.
-
Xing 4 report: a 285B model pretrained on 8,192 Huawei Ascend 910C chips
Xingchen AGI Lab's Xing 4 technical report describes pretraining a 285B parameter model on 8,192 Ascend 910C cards with MindSpore HyperParallel, using topology aware hybrid sharding, a distributed optimizer and CPU core isolation with CPU affinity to cut host scheduling noise. It also introduces TeleGym, a platform that ties agent execution, evaluation and trajectory building to policy optimization. Smaller Xing4.0-29B-A4B weights, including GGUF and FP8 builds, are on Hugging Face under Apache 2.0.
Heat · Hugging Face #1 Paper of the day on Nov 18, 164 upvotes on the paper page; the Xing4.0-29B-A4B-GGUF repo shows 164 likes and 13,856 downloads last monthWhat people foundThe abstract reports no benchmark scores, so the value is the systems detail: a public account of frontier scale training on a non NVIDIA stack. Neither the paper page nor the GGUF model card says the released 29B model comes from the 285B run, and the HF header lists 31B parameters while the card says 29B.Learn it15 min · 5 steps
Key ideas
- Hybrid sharding
- Splitting model weights, gradients and optimizer state across devices in more than one way at once, arranged to match how the chips are physically connected.
- CPU core isolation
- Reserving host CPU cores for the training processes so other system work does not interrupt them and stall the accelerators.
- Mixture of experts A4B
- A model where only about 4B of its 29B parameters run for each token, which keeps inference cheap relative to total size.
Steps
- Read the abstract on the Hugging Face paper page for 2611.22115 first, noting the hardware count and the three systems techniques named.
- Open the arXiv PDF and skim the pretraining infrastructure section on MindSpore HyperParallel and sharding.
- Read the TeleGym section to see how agent runs feed evaluation and policy optimization.
- Open the Xing4.0-29B-A4B-GGUF model card and compare what it claims with what the paper claims.
- Self check: which parts of this report would still matter to a team training on NVIDIA GPUs, and which are specific to Ascend?
Try it30 min · 5 steps
You need: A Mac or Linux machine with enough RAM or VRAM for a 20.1 GB IQ4_NL file, or 11.8 GB for IQ2_M; Ollama or a recent llama.cpp build. No API key neededSteps
- Install Ollama, or build llama.cpp from source as the model card describes.
- Pull and chat with the 4 bit build using
ollama run hf.co/XingChen-AGI/Xing4.0-29B-A4B-GGUF:IQ4_NL. - Alternatively serve it with llama.cpp: download a quant file, then run
llama-server -m ./models/<quant-file>.gguf -c 32768 -ngl 99, dropping-ngl 99for CPU only use. - Give it a short multi step agent style task from your own work, such as planning a refactor, and note tokens per second and answer quality.
- Compare speed and memory use against a dense model of similar file size you already run.
Small angles to try
- Try the smaller IQ2_M file on a 16 GB laptop and see how much quality drops.
- Run the FP8 build on a GPU server and compare with the GGUF output.
- Read the paper's sharding section and map each idea to its PyTorch FSDP equivalent.
-
Stealth model 'Gestalt' tops a blind design benchmark, ahead of humans
The Frontier Design Benchmark by Contra Labs and BenchFlow ranks entries by Elo from 4,311 blind votes by 68 professional designers on 33 real client briefs. An unnamed entry labelled Gestalt, stealth, is first at 1931 Elo with a 90% win rate, above human designers at 1739 and Claude Fable 5.2 at 1713. Claude Opus 5.5 is 4th at 1691, GPT-6.1 Sol 5th at 1668 and Gemini 4 Carbon 12th at 1366.
Heat · Hacker News, 149 points and 50 comments, posted 2026-11-19 under the title 'Two stealth models just appeared on the leaderboard, both ahead of Fable 5.2'What people foundThe page now marks only one stealth model and shows no update date, so the HN headline is already out of date and the stealth entry cannot be verified. The reusable idea is the 35 dimension Design Critique Rubric, whose scores correlate with designer Elo at r = 0.94 across models, a template for grading UI output automatically.Learn it15 min · 5 steps
Key ideas
- Elo from pairwise votes
- Each blind vote between two designs moves the winner's rating up and the loser's down, so ratings reflect head to head preference.
- Stealth model
- An unreleased model entered under a code name, so its maker and details stay hidden until launch.
- Critique rubric
- A fixed checklist of design aspects, such as hierarchy, typography and contrast, that a grader scores one by one.
Steps
- Read the Contra Labs Frontier Design Benchmark leaderboard page first and note the votes, designers and briefs.
- Open the methodology page to see how briefs were chosen and how votes were collected.
- Open the rubric page and list the three areas and their 35 aspects.
- Look at the scatter plot of rubric score against Elo and think about what r = 0.94 across a handful of models does and does not prove.
- Self check: why might a design that wins blind votes still score poorly on accessibility items in the rubric?
Try it30 min · 5 steps
You need: A browser, any chat model you already use, and two or three UI screenshots or HTML pages you made yourself; an API key only if you script itSteps
- Copy the rubric areas and aspects from the Contra Labs rubric page into a checklist.
- Generate two versions of the same landing page for one of your own briefs, using two different models.
- Ask a model to score each version against every checklist aspect on a simple scale, with one sentence of evidence per aspect.
- Have two colleagues pick the better version blind, without seeing the scores.
- Compare the rubric totals with the human picks and note which aspects drove disagreements.
Small angles to try
- Score only the accessibility aspects and check them against a real contrast checker.
- Run the same grading with two different judge models and compare consistency.
- Turn the checklist into a review step in your own UI pull requests.
-
Rumble-2-Flash: a 0.5B Apache 2.0 speech recognizer for 40+ languages
Reson8 open sourced Rumble-2-Flash on November 18, a 0.5B parameter speech recognition model with automatic language detection; the blog says 40+ languages and the model card lists 45. It reports 6.96% average word error rate on the Open ASR Leaderboard multilingual track and 6.6% on English. On a 302 hour AppTek call centre benchmark it scored 7.86% versus 7.78% for the 30B NVIDIA Nemotron 3.5 Transcribe.
Heat · Modest: the Hugging Face model page shows 172 likes and 929 downloads last month, with no Hacker News thread foundWhat people foundReson8 claims over 7,000 RTFx on full batches, roughly an hour of audio in about half a second. It loads in plain Transformers throughprocessor.apply_transcription_request()and serves on vLLM with no custom code, so it is quick to try on a laptop.Learn it15 min · 4 steps
Key ideas
- Word error rate
- The share of words a transcript gets wrong through substitutions, deletions or insertions, where lower is better.
- RTFx
- How many seconds of audio a model transcribes per second of compute, so 7,000 means far faster than real time.
- Language identification
- The model guesses the spoken language itself when none is given.
Steps
- Read the Hugging Face blog post on Rumble-2-Flash first for the benchmark table and design notes.
- Open the model card and read the Transformers and vLLM usage sections.
- Look up the Open ASR Leaderboard to see where 6.96% multilingual WER sits among other models.
- Self check: why can a model with similar WER to a 30B model still be the better choice for batch transcription?
Try it30 min · 6 steps
You need: Python, a CPU or a small GPU,torch,transformersandaccelerate;vllm[audio]andopenaifor the server path. No API key neededSteps
- Install the packages with
uv pip install torch transformers accelerate. - Load the model with
AutoProcessor.from_pretrainedandAutoModelForMultimodalLM.from_pretrainedusing the idReson8/Rumble-2-Flash, as on the model card. - Transcribe a recording you own with
processor.apply_transcription_request(audio=...), leaving outlanguageto test automatic detection. - Decode with
return_format="transcription_only", orreturn_format="parsed"to see the detected language. - For batch work, run
uv pip install "vllm[audio]" openaithenvllm serve Reson8/Rumble-2-Flash --max-model-len 4096and send audio from the OpenAI client as on the model card. - Correct one transcript by hand and count errors to estimate your own WER.
Small angles to try
- Feed the same clip in two languages you speak and compare detection accuracy.
- Time a folder of your own meeting recordings on CPU versus GPU.
- Compare its output with whatever transcription tool you use today on the same files.
-
AI as confidant × student counseling: Kyoto Univ. says step away from AI
Kyoto University's Student Support Center published a guide on taking personal worries to generative AI. It warns that AI can be confidently wrong, can carry bias, tends to agree with the user, and is a machine rather than a person. A six item checklist flags dependence, such as chatting with AI over 3 hours a day, consulting AI more than people, or never questioning its answers, and the center suggests living without AI for a while if any item applies.
Heat · 679 Hatena bookmarks on the Kyoto University page, listed in Hatena's Technology hot entries on 2026-11-21; ITmedia AI+ covered it on 2026-11-20What people foundThe guide's practical advice is to use AI as a thinking partner: describe the situation, ask for viewpoints, and have it ask one question at a time instead of deciding for you. It calls deciding on AI advice alone 'extremely dangerous', 非常に危険, for choices about health, school or family, and says to always talk to people too.Learn it15 min · 4 steps
Key ideas
- Sycophancy
- A model's tendency to agree with and flatter the user even when pushback would help more.
- Over reliance
- Trusting or using a tool so much that your own judgment and human contacts weaken.
- Socratic prompting
- Asking the model to question you step by step so you reach your own answer.
Steps
- Read the Kyoto University SSC guide first, using a browser translation if needed, and list its five warnings.
- Read the six item dependence checklist and note which items describe behaviour a chat product could detect.
- Read the ITmedia AI+ article for how Japanese media framed it.
- Self check: which of the guide's warnings can a model developer reduce through training, and which only the user can manage?
Try it30 min · 5 steps
You need: Any chat model you already have access to, or a local model through Ollama; no API key needed for the local routeSteps
- Write five short personal dilemmas of your own in which the stated plan is clearly unwise.
- Send each one to a model with a plain ask for its opinion and save the replies.
- Send the same dilemmas again with a system prompt that tells the model to ask one clarifying question at a time and not to decide for you.
- Score each reply for whether it simply agreed, pushed back, or redirected you to people.
- Compare the two runs and note how much the prompt changed sycophantic replies.
Small angles to try
- Repeat the test in Japanese and English and compare agreement rates.
- Try two different models with the same dilemmas.
- Draft a short in app notice for your own chat product based on the checklist.
-
Resale × desktop agents: Gemini on Mac drafts listings from your photos
Google added computer use to the Gemini app for Mac on Nov 19, letting Gemini click, type, navigate menus and fill forms across local files, desktop apps and websites. It works in an isolated background window with a live preview, leaving the main screen and cursor free. Google's examples include analyzing a folder of clothing photos, researching prices and staging resale listings, pulling shipping details from PDFs and batch color grading photos.
Heat · Modest: two Japanese write ups in Hatena's Technology hot entries on 2026-11-21, Impress Watch with 23 bookmarks and CNET Japan with 16What people foundAt launch it needs an Apple Silicon Mac on macOS Sequoia 15.0 or later and a Google AI Plus, Pro or Ultra plan, and it is English only, US only, for personal accounts of users 18 and over. Impress Watch reports Japan availability is undecided. For web teams, agents filling forms from a hidden window will start reaching resale and shipping sites.Learn it15 min · 4 steps
Key ideas
- Computer use
- An agent operating apps the way a person does, by reading the screen and sending clicks and keystrokes.
- Isolated background window
- A separate workspace where the agent acts so it does not take over the user's own screen.
- Action approval
- A checkpoint where the agent pauses and asks the user before a key step such as submitting a form.
Steps
- Read the Google blog post on Gemini computer use for Mac first and list the example tasks and controls.
- Read the Impress Watch article for the Japan availability status.
- Compare the controls, app permissions, live preview, pause and approval, with any other desktop agent you know.
- Self check: what parts of a web form would confuse an agent that reads the screen, and how would you make them clearer?
Try it30 min · 5 steps
You need: For the hands on route: an Apple Silicon Mac on macOS Sequoia 15.0 or later, a US English personal Google account aged 18 and over, and an AI Plus, Pro or Ultra plan. Otherwise only a browser and a web form you ownSteps
- If eligible, download the Gemini app for Mac from the link in Google's post and enable computer use.
- Grant access to a single app only and give it a folder of your own test photos to describe and price.
- Watch the live preview, pause once mid task, and note which actions asked for approval.
- If not eligible, open a form on a site you own and list every field, label and button an agent would need to read.
- Fix any unlabeled inputs or icon only buttons you find and recheck the form with a screen reader.
Small angles to try
- Ask it to pull figures from a local PDF of your own into a spreadsheet.
- Check your own site's server logs for unusual automated form submissions after the launch.
- Compare its permission model with the agent tools your team already uses.