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.

Sunday, November 22, 2026

20 items · Lean certifies AI made RH proof; canaries catch providers leaking prompts
  1. #1Engineering & CS

    Canary tokens catch inference providers leaking prompts, OpenRouter drops 3

    Dragos researcher HD Moore sent about 2 million prompts carrying unique canary URLs, hostnames and AWS keys to AI services from July to November 2026, and found attackers had stolen data from three hosting providers. In the biggest case a couple hundred AWS keys were taken and used for tens of thousands of AWS API calls; in the other two breaches some stolen requests were flagged Zero Data Retention. On Nov 22 OpenRouter said it off boarded three providers, removed 125 endpoints from ZDR eligibility and notified affected customers, while Novita, Phala and Together have posted incident notes.

    Heat · HN: OpenRouter post 136 points and 53 comments, plus a related Minimax thread at 52 points and 9 comments; the Dragos post itself drew only about 11 points
    What people foundHD Moore at Dragos: "A privacy flag doesn't help when the attacker is already inside." His advice is to seed fake credentials into the context agents send, treat any use as an incident, pick upstream providers yourself instead of reseller marketplaces, and add the user agents artex-agent and artex-judge-r121 to detections.
    Learn it15 min · 5 steps

    Key ideas

    Canary token
    A fake credential or unique URL that has no real use, so any attempt to use it proves someone copied the data it was hidden in.
    Zero data retention
    A provider promise not to store prompts or outputs, which only covers the first hop and does nothing if an attacker is already inside the provider.
    Inference router
    A service like OpenRouter that forwards a request to one of many upstream model hosts, each with its own security posture.

    Steps

    1. Read the Dragos post by HD Moore first, focusing on how the canaries were built and how the largest breach unfolded.
    2. Read the OpenRouter incident post to see what a router can and cannot guarantee about upstream providers.
    3. List every provider and router your own agents send prompts through, and note which ones receive secrets in context.
    4. Compare that list with the provider notices linked from the OpenRouter post.
    5. Self check: why did ZDR flags fail to protect the stolen requests, and what signal would tell you your own prompts leaked?
    Try it30 min · 5 steps
    You need: A free Thinkst Canarytokens account or any canary service, an inference API account you already use, and a test AWS account with no resources if you choose an AWS key canary. No paid tools required.

    Steps

    1. Create a canary AWS key or a canary URL token on canarytokens.org and set alert delivery to your email.
    2. Put the token into a throwaway system prompt or tool context for an agent you run, against your own account only.
    3. Send a handful of ordinary requests through the provider or router you normally use.
    4. Wait several days and check your alert inbox; if you used an AWS canary, also review CloudTrail in that empty account.
    5. Record which provider and route each token went through so any alert maps to one hop.

    Small angles to try

    • Use a different token per provider to pinpoint which hop leaked.
    • Repeat with your router's provider allowlist on and off to see if routing settings actually change where requests go.
    • Add the artex-agent and artex-judge-r121 user agents to a CloudTrail alert rule in your own account.
  2. #2Models & launches

    Hugging Face harness adapters: RL LoRAs tune Qwen3.8-27B to pi, OpenCode

    Hugging Face released harness adapters, LoRA adapters trained with RL using TRL's AsyncGRPOTrainer inside one specific agent harness while the Qwen3.8-27B base weights stay frozen; there are specialists for pi, OpenCode and Hermes Agent plus one merged adapter. With thinking off, the pi adapter lifts SWE-bench Pro hard 51 from 40.0% to 64.0% and Terminal-Bench 2.1 from 40.0% to 56.5% in the results table, and the specialists use 56 to 72% fewer tool calls on SWE-bench Pro and 53 to 70% fewer on Terminal-Bench. Each adapter trained on two B200 GPUs, one for vLLM and one for training, and the tasks, environments and trajectories are published.

    Heat · harness-hub/Qwen3.8-27B-pi-adapted has 941 likes and about 2,383 downloads last month, with about 30 community quants and MLX ports in six days
    What people foundThe pi adapter model card says that with thinking off it scores 56.6% on Terminal-Bench 2.1 versus 54.2% for the base model at its highest reasoning effort, while generating about 4.5x fewer tokens per task. On SWE-bench Pro the base model with thinking still beats the adapter without thinking, 74.5% to 64.7%. The card is Apache 2.0.
    Learn it15 min · 5 steps

    Key ideas

    LoRA
    A small set of low rank weight updates trained on top of a frozen model, cheap to train and easy to swap.
    GRPO
    An RL method that samples several attempts per task and rewards the ones that pass a verifier relative to the group.
    Agent harness
    The loop, tools and prompt format a coding agent like pi or OpenCode wraps around a model.

    Steps

    1. Read the Hugging Face blog post harness-adapters-at-scale, focusing on the training setup and results table.
    2. Open the pi adapter model card and compare its thinking on and thinking off numbers.
    3. Skim the harness-hub collection to see which adapters and GGUF builds exist.
    4. Note how the reward combines verifier pass or fail with a small tool efficiency bonus.
    5. Self check: why could a LoRA tuned to one harness beat a larger model or more thinking in that same harness?
    Try it30 min · 5 steps
    You need: A Linux machine with enough GPU memory to serve a 27B model, Python, vLLM and the pi agent installed; Hugging Face access to Qwen/Qwen3.8-27B. No API key needed beyond a local dummy key.

    Steps

    1. Serve the base model with the adapter using the vLLM command from the model card, starting with vllm serve Qwen/Qwen3.8-27B --enable-lora --max-lora-rank 32 --lora-modules qwen3.8-pi=harness-hub/Qwen3.8-27B-pi-adapted plus the other flags listed there.
    2. Add a local provider pointing at http://localhost:8000/v1 in ~/.pi/agent/models.json as shown on the card.
    3. Run pi --provider local --model qwen3.8-pi --print with a bug fixing prompt on a small repo of your own.
    4. Serve the base model without the LoRA and run the same prompt.
    5. Compare pass or fail, number of tool calls and total tokens between the two runs.

    Small angles to try

    • Try the OpenCode adapter GGUF in OpenCode on a smaller machine.
    • Turn thinking on for the base model and see whether it matches the adapter at a higher token cost.
    • Run the pi adapter inside a different harness to see how much the gain depends on the harness.
  3. #3Tools & open source

    AI gives everyone the same advice: 65 models, 127,918 asks, and fixes

    Cody Collier asked 65 models from 30 companies everyday questions 127,918 times through OpenRouter, with default settings and no system prompt. 98% of answers to a $10,000 investing question named an index fund, 73 in 100 book picks were Man's Search for Meaning, and 69% of 3,151 invented people were exactly 34. In OLMo 2 1B, random number answers were nearly random after pretraining and the favorite answer appeared during supervised fine tuning.

    Heat · HN, Nov 20: 123 points and 51 comments
    What people foundPer Collier, asking the model to "be original" did not help. Describing yourself in detail cut matching answers to a 4% chance, and asking for ten options then picking one by number reached 7%. Gemini's invented person Elena Vance appeared in 684 new GitHub projects in 2026.
    Learn it15 min · 5 steps

    Key ideas

    Mode collapse
    When a model keeps returning the same few answers even though many good answers exist.
    Supervised fine tuning
    Training on curated example answers after pretraining, which this study links to the shared favorite answers.
    Entropy in bits
    A measure of how spread out answers are; higher means more varied, and 6.64 bits is fully random for this number question.

    Steps

    1. Read the A90 same advice experiment page first, including the prompting fixes section.
    2. Download the answers CSV linked on the page and look at one question across models.
    3. Read the OLMo section to see where in training the convergence appears.
    4. Think of one place your own app asks an LLM for names, ideas or test data.
    5. Self check: which two prompt patterns broke the convergence, and why does "be original" fail?
    Try it30 min · 5 steps
    You need: Python 3 and an OpenRouter API key, or any LLM API key you already have.

    Steps

    1. Pick one open ended question such as inventing a person with a name and age.
    2. Ask it 30 times to one model with default settings and save every answer.
    3. Count how often the top answer repeats.
    4. Repeat with a detailed description of yourself in the prompt.
    5. Repeat by asking for ten options and picking one by a random number chosen in your code, then compare the three repeat rates.

    Small angles to try

    • Compare two models from the same company against one from another company.
    • Add a random seed string to the prompt and measure the partial effect.
    • Ask the model to avoid the most common answer and see which new shared answer appears.
  4. #4Tools & open source

    Vibecoding an inference chip: agents push FPGA LLM decode to 213 tok/s

    Ankit Gupta used coding agents to build bit exact LLM inference on an AWS F2 FPGA for a model using DeepGrove's ternary weight architecture. A cloud agent in Conductor ran for several days using Claude Opus and Astra, across hundreds of experiments and about $10,000 in Claude and OpenAI tokens. Throughput rose 33x, from 6.43 to 213.13 tokens per second, 1.65x faster than a bit exact 32 thread CPU twin.

    Heat · HN, Nov 20: 175 points and 74 comments
    What people foundPer Gupta, the gains came from many compounding steps of about 1.5x each, not a few breakthroughs. Humans set the iteration process and the definition of correct, and bit exactness ruled out the numerics shortcuts that gave the original design much of its efficiency. Skipping multi hour simulations sped up feedback but let two hangs slip through that later cost 38 hours.
    Learn it15 min · 5 steps

    Key ideas

    Ternary weights
    Model weights limited to three values, usually minus one, zero and one, which makes them cheap to store and multiply.
    Bit exact
    Producing exactly the same output bits as a reference implementation, which makes correctness easy to verify automatically.
    FPGA
    A chip whose logic can be reconfigured, so custom hardware designs can be tested without fabricating silicon.

    Steps

    1. Read Ankit Gupta's post Vibecoding an inference chip from start to finish.
    2. Note the throughput table and how each comparison stayed bit exact.
    3. Write down the process rules the human set for the agents.
    4. Look at the cost of skipping simulations and what it caused later.
    5. Self check: why does a strict, automatic definition of correct matter more for long agent runs than for short ones?
    Try it30 min · 5 steps
    You need: Any coding agent you already use, Python 3 and a laptop; no FPGA needed. No API key needed if your agent runs locally.

    Steps

    1. Pick a small numeric function in your own code, such as a matrix multiply in pure Python.
    2. Write a reference implementation and a test that checks a candidate output matches it exactly.
    3. Ask your coding agent to make the function faster while the exactness test must keep passing.
    4. Run several short rounds, recording the speedup of each round.
    5. Check whether the total gain came from one big step or several moderate ones.

    Small angles to try

    • Loosen the check to approximate equality and see whether the agent takes numeric shortcuts.
    • Cap each round to a few minutes to mimic the short loop rule.
    • Compare two different agents on the same task and budget.
  5. #5Trends × tech

    Cheap synths × AI coding: hobbyists rewrite firmware of a ¥10,000 FM synth

    Hobbyists began analyzing the firmware of M-VAVE's FM-1, a 6 operator FM synth usually sold for under ¥10,000, in summer 2026, and AI coding tools sped up custom firmware in the autumn, adding other synth engines, drum machine and sampler features. In October M-VAVE answered with FM1 Open, which provides an SDK, source code and a browser based development environment.

    Heat · Hatena Bookmark technology hot entries, number 2 overall with 206 users
    What people foundGizmodo Japan notes other makers are moving the same way: AKAI hinted at opening firmware for its upcoming Sample Key and BEHRINGER plans to open source its KICK sampler, though it is unclear whether that is a response to the FM-1 community. It also flags warranty, malfunction and security questions for vendors.
    Learn it15 min · 5 steps

    Key ideas

    FM synthesis
    Making sound by using one oscillator to modulate the frequency of another; each oscillator is called an operator.
    Firmware
    The software baked into a device that controls its hardware, here the synth's sound engine and controls.
    Vendor SDK
    Official tools and source code a maker publishes so outsiders can build software for its hardware.

    Steps

    1. Read the Gizmodo Japan article, using a browser translator if needed.
    2. Look at the FM1 Open announcement on the M-VAVE forum linked from the article.
    3. Note what changed between the community hacking phase and the official SDK.
    4. Compare with the AKAI and BEHRINGER moves the article mentions.
    5. Self check: what does a vendor gain by opening firmware on a cheap device, and what risks does it take on?
    Try it30 min · 5 steps
    You need: An FM-1 you own and a computer with a browser for the official FM1 Open tools; without the device, only a computer and any coding agent. No API key needed beyond your coding agent.

    Steps

    1. Open the FM1 Open resources from M-VAVE's forum and read the official update and recovery instructions before touching the device.
    2. Back up or note how to restore the stock firmware as described by M-VAVE.
    3. Ask a coding agent to explain the structure of the published source and find where one parameter, such as an envelope range, is defined.
    4. Make one small change, build it with the official tools and load it onto your own unit.
    5. Confirm the change works, then restore the stock firmware to check recovery.

    Small angles to try

    • Without hardware, ask an agent to write a tiny 2 operator FM synth in Python that writes a WAV file.
    • Ask the agent to add a simple drum voice to that Python synth.
    • Compare how much of the change the agent got right on the first try in the SDK versus the Python toy.
  6. #6Tools & open source

    HubSpot details Aviator, the Java agent harness behind its coding agents

    HubSpot Engineering published a design writeup of Aviator, the Java harness that runs the agent loop for Breeze Assistant and other internal agents, including Sidekick Code, which merges more than 2,500 pull requests a week. Conversations live in a provider agnostic transcript that serializes to JSON, so an agent can switch models mid conversation, checkpoint, and resume on another machine. It adds deferred tools found through tool search, native SKILL.md skills with extra tool metadata, and WASM based Python and Bash sandboxes shipped inside the library.

    Heat · HN: 30 points and 3 comments; engineering blog post dated Nov 19
    What people foundPer HubSpot, Sidekick needed over 3,000 tools, so most are marked deferred and stay out of context until tool search finds them; skills add load-tools to make their tools callable on load and suggested-tools to make them searchable without loading. The writeup does not say whether Aviator itself is open source; it links only the Boomslang Python sandbox.
    Learn it15 min · 5 steps

    Key ideas

    Provider agnostic transcript
    One internal format for messages, tool calls and results that each model client translates to its vendor API, which makes model switching and resume possible.
    Deferred tools
    Tools that are registered but kept out of the initial prompt and surfaced only when a tool search step decides they are needed.
    Skill load-tools metadata
    A field in a SKILL.md file that makes the skill's own tools callable as soon as the skill is loaded, keeping them out of context until then.

    Steps

    1. Read the HubSpot Engineering post on Aviator end to end, focusing on the transcript and tool search sections.
    2. Study the PipelineAssistant.java builder example and the addDeferredChirpTool call to see how little code defines an agent.
    3. Read the review-pipeline/SKILL.md example and compare load-tools with suggested-tools.
    4. Skim the sandbox section and note why WASM was chosen over microVMs for short lived environments.
    5. Self check: why does a JSON transcript make it possible to pause for approval and resume an agent on a different machine?
    Try it30 min · 5 steps
    You need: Any agent framework or SDK you already use that supports tool calling, plus an API key for your own model provider; Aviator itself is not published in the post

    Steps

    1. Pick a small agent in your own codebase and count how many tool definitions it sends on every request.
    2. Move all but three or four core tools behind a single search tool that returns matching tool schemas by keyword.
    3. Run the same five tasks before and after, logging input tokens per request and task success.
    4. Serialize the full conversation to a JSON file after each turn, then reload it in a fresh process and continue the task.
    5. Compare token usage and whether the resumed run finished correctly.

    Small angles to try

    • Switch to a different model halfway through a reloaded transcript and see what breaks in tool call IDs.
    • Bundle two tools with a SKILL.md style file and load them only when that skill is chosen.
  7. #7Tools & open source

    OpenComputer: Apache 2.0 open source alternative to Devin from Digger

    Digger launched OpenComputer on Show HN as an open source alternative to Devin, licensed Apache 2.0. Per the founder, each team gets a dedicated VM where sessions run in git worktrees inside rootless Podman sandboxes, and session files are backed up to a repo after every turn so work can resume on another VM. Users pick Claude Code or Codex per thread, and it works from Slack, with a web UI and CLI as well.

    Heat · Show HN: 116 points and 36 comments; GitHub repo at 574 stars and 68 forks
    What people foundThe founder claims a first commit lands in 24 seconds versus 53 to 72 seconds for the alternatives benchmarked, and that past about 640 session hours a month one always on 4 vCPU VM is cheaper than per session E2B sandboxes; the thread does not show the underlying numbers. The current README describes a TypeScript CLI for deploying agents as code rather than the self hosting architecture, so check the docs before planning a rollout.
    Learn it15 min · 5 steps

    Key ideas

    Git worktree
    A second working directory attached to the same repository, letting several agent sessions edit separate branches without cloning again.
    Rootless Podman
    A container runtime that runs containers as an ordinary user, so a breakout does not land as root on the host VM.
    Per turn backup
    Saving session files to a repository after every agent turn so a session can be picked up on a fresh machine.

    Steps

    1. Read the Show HN thread first, especially the founder's comments on VMs, Podman and Slack threads.
    2. Open the GitHub README and note the project layout and deploy commands it actually documents.
    3. Run git worktree --help locally and read how worktrees share one object store.
    4. Write down which parts of the design are verified in the README and which come only from thread comments.
    5. Self check: why does one shared VM per team get cheaper than per session sandboxes only above a certain usage level?
    Try it30 min · 5 steps
    You need: Node.js with npm, an OpenComputer account for login, Git and Podman for the local angle; the README CLI targets the hosted service at app.opencomputer.dev by default

    Steps

    1. Scaffold a project with npx @opencomputer/cli init my-agent, then cd my-agent and npm install.
    2. Read opencomputer/project.ts and opencomputer/agents/hello-world/agent.ts to see how an agent is defined.
    3. Log in with npx --package @opencomputer/cli opencomputer login and deploy with npm run deploy -- --watch.
    4. Send a test prompt using the session command shown in the README and check the session in the dashboard.
    5. Time how long the first response takes and note it next to the founder's 24 second claim.

    Small angles to try

    • Locally, create two git worktrees of your own repo and run a rootless Podman container in each to mimic the isolation model.
    • Estimate your team's monthly agent session hours and compare against the 640 hour break even claim.
  8. #8Tools & open source

    hy4-flash-concise: a rank one weight edit cuts thinking tokens 37 to 55%

    AutoTrust AI Lab released a modified tencent/Hy4-flash that applies a rank one, gradient free edit to nine shared expert down projection matrices, with no fine tuning data. Thinking tokens drop 37 to 55% across benchmarks, while GPQA Diamond goes from 91.2 to 88.6, LiveCodeBench v6 from 84.6 to 78.3 and IFBench from 76.7 to 66.0. The repo also ships a milder alpha 0.05 variant, a v2 with the instruction following component removed, and a 167 KB LoRA for GGUF files.

    Heat · Hugging Face: 174 likes and 307 downloads last month
    What people foundThe card reports that a norm matched random edit gave no accuracy change and about 8% more tokens, so the savings come from the chosen direction, not from noise. It also calls the code and instruction following losses at alpha 0.1 statistically significant, so treat it as a per workload tradeoff; the alpha 0.05 variant keeps GPQA and LiveCodeBench within noise for 21 to 37% savings.
    Learn it15 min · 5 steps

    Key ideas

    Rank one edit
    Adding the outer product of two vectors to a weight matrix, a tiny targeted change that pushes activations along one direction.
    Shared experts
    In a mixture of experts model, expert layers that every token passes through, so editing them affects all inputs.
    Steering direction
    A vector in the residual stream, here taken from the last 48 thinking tokens before the end of thinking, that correlates with a behavior you want to strengthen.

    Steps

    1. Read the hy4-flash-concise model card on Hugging Face, starting with the method and benchmark table.
    2. Note which layers and tensors were edited and how large the relative change is per layer.
    3. Compare the root, alpha 0.05 and v2 variants and their token savings versus accuracy loss.
    4. Read the limitations section about single runs and thinking mode only.
    5. Self check: why does a random edit of the same norm serve as a good control for this result?
    Try it30 min · 5 steps
    You need: A large GPU server such as one H200 for the 145B model, or llama.cpp with the stock Hy4-flash GGUF plus the card's LoRA on a big memory machine; No API key needed

    Steps

    1. Pick 20 prompts from your own workload that use thinking mode and save them to a file.
    2. Serve the base tencent/Hy4-flash with the vLLM command from the model card and record thinking tokens and answers.
    3. Serve autotrust/hy4-flash-concise with vllm serve autotrust/hy4-flash-concise --served-model-name hy4-flash plus the remaining flags listed on the card.
    4. Run the same prompts with the same temperature and max token settings and log thinking tokens per answer.
    5. Grade answers on your own task and compute token savings against any accuracy change.

    Small angles to try

    • Repeat with the alpha-0.05/ variant to see if the milder edit keeps your code tasks intact.
    • Apply the gguf-lora/ adapter to a Q4_K_M GGUF in llama.cpp and compare savings on a smaller box.
  9. #9Tools & open source

    ClawDOS: a Claude coding agent that runs on an 8088 IBM PC XT

    ClawDOS is an agent harness of about 13,000 lines of C and C++ for FreeDOS on an IBM PC XT with a 4.77 MHz 8088 and 640K of RAM. Its 18 tools let Claude edit files, compile with Turbo C, run DOS programs and capture the CGA screen as a PNG. The PC speaks plain HTTP to a tunnel on another machine that handles TLS to the Anthropic API and can hold the API key so it never sits on the PC's disk.

    Heat · HN: 102 points and 28 comments about 7 hours after posting
    What people foundAgent traffic does not have to grow with context: after the first request a tool result uploads in about 500 bytes. A primes below 100 program took 64 seconds from Enter to answer, 26 of them spent compiling, linking and running on the 8088.
    Learn it15 min · 5 steps

    Key ideas

    Agent harness
    The loop around a model that sends messages, parses tool calls, runs the tools and feeds results back.
    TLS bridge
    A small relay on a modern machine that accepts plain connections and forwards them encrypted, so an old client can reach an HTTPS API.
    Incremental upload
    Sending only new content after the first request instead of resending the whole conversation from the client.

    Steps

    1. Read the ClawDOS project page on ricapar.net, especially the sections on the tunnel and tool results.
    2. Open the GitHub repo and skim how the 18 tools are declared.
    3. Look at tunnel/tunnel.py to see how the key can live on the bridge instead of the PC.
    4. Trace one tool call from model reply to CGA screenshot returned with the result.
    5. Self check: what does the bridge protect, and what would leak if the PC stored the API key itself?
    Try it30 min · 5 steps
    You need: A Mac or Windows PC with Python 3; your own Turbo C floppy images if you want the compiler; No API key needed for the mock API, an Anthropic API key for the live run

    Steps

    1. Clone the ClawDOS repo from GitHub and run python3 scripts/setup-tools.py to fetch the compilers, FreeDOS, mTCP and emulators.
    2. Build the disk image with python3 scripts/build.py.
    3. Start the offline mock with python3 tunnel/mockapi.py, then boot the emulator with python3 scripts/run86box.py.
    4. At the C:\> prompt run CLAWDOS 10.0.2.2:18023 and send !help to see the tools.
    5. For a live run, put your own key in .env, start python3 tunnel/tunnel.py and ask for a small program.

    Small angles to try

    • Watch the bridge traffic size per turn and confirm the roughly 500 byte tool results.
    • Move the API key from .env to the tunnel only and confirm the DOS side never sees it.
  10. #10Tools & open source

    Pandex: EU and European law and top court rulings for agents over MCP

    Pandex serves legislation and highest court decisions from the EU, seven European countries and the Council of Europe through a REST API and a remote MCP server. It offers keyword, semantic and hybrid search in any language, past versions of each article with their effective dates, linked citations, and Markdown or JSON output. Listed clients include Claude, Cursor, GitHub Copilot, Windsurf, Zed and Gemini.

    Heat · HN: 36 points and 6 comments on the thread when checked
    What people foundFree during beta at 1,000 requests a day with a key, or 50 a day without one, then €1 per 1,000 requests. Its institution register, dated Nov 17, counts 33 of 41 institutions as complete across 2.8M documents, with Spain, Italy and several other countries still upcoming.
    Learn it15 min · 5 steps

    Key ideas

    Remote MCP server
    A Model Context Protocol endpoint reachable over HTTP that an AI client can call for tools without installing anything locally.
    Point in time law
    Retrieving the text of a legal article as it stood on a given date, not just the current version.
    Hybrid search
    Combining keyword matching with embedding based semantic matching to rank passages.

    Steps

    1. Read the Pandex homepage for coverage, pricing and the jurisdiction list.
    2. Open the pandex-mcp GitHub README and note the six tools it exposes.
    3. Skim the API docs at api.pandex.io to see request and response shapes.
    4. Compare which countries are complete versus upcoming before relying on it.
    5. Self check: why is a citation graph useful to a compliance agent that must justify an answer?
    Try it30 min · 5 steps
    You need: Claude Code or another MCP client; a free Pandex key from api.pandex.io is optional, 50 requests a day work without one

    Steps

    1. Add the server with claude mcp add --transport http pandex https://api.pandex.io/mcp.
    2. Ask the agent to call list_sources and confirm which jurisdictions are available.
    3. Ask an English question about a French or German rule and check that search returns the original passage.
    4. Use get_changes or get_outline on one EU act to see its structure and past versions.
    5. Verify one returned citation against the official source yourself.

    Small angles to try

    • Pass a key with an Authorization header of Bearer px_... and compare limits.
    • Install the plugin with /plugin marketplace add pandex-io/pandex-mcp to try the bundled legal research skill.
  11. #11Engineering & CS

    Epic rebuilds Unreal Engine 6 for AI coding: no Blueprints, Verse only

    IEEE Spectrum reports that Unreal Engine 6 will remove Blueprints visual scripting, move all code to Verse, a text language, and replace the actor framework with Scene Graph, an entity component style system built on Verse, largely because LLMs handle text far better than visual graphs. An internal Epic effort called "Python All The Things" aims to make everything in the editor scriptable, more assets will be stored as text, and a command line tool will let agents work with the remaining binary files without loading the full editor. Today LLMs reach Unreal mainly through an MCP server, and no UE6 release date is given.

    Heat · HN, 58 points and 60 comments
    What people foundEpic COO Daniel Vogel says Epic is "pivoting hard towards velocity" because a static engine can be copied. On HN, one game developer said Unreal's official MCP tools are "simply almost useless" and that their team built its own bridge that exports Blueprints to text for agents.
    Learn it15 min · 5 steps

    Key ideas

    Visual scripting
    Programming by wiring nodes in a graph editor, which is easy for humans to see but hard for a text model to read or diff.
    Entity component system
    A design where game objects are plain IDs and behavior comes from data components processed by systems, instead of deep class hierarchies.
    Agent friendly formats
    Storing project data as readable text with scriptable APIs so an AI agent can inspect and edit it without driving a GUI.

    Steps

    1. Read the IEEE Spectrum article first, focusing on why Blueprints are being dropped.
    2. Skim the HN thread for developers describing how they connect agents to Unreal today.
    3. List the binary or GUI only formats in one tool you use daily.
    4. Compare that list with Epic's plan: text assets, a scriptable editor and an API for AI tools.
    5. Self check: why does a text asset format help an agent more than a better visual editor would?
    Try it30 min · 5 steps
    You need: Any coding agent you already use, one project of your own with a GUI or binary config, git. No API key needed beyond your agent.

    Steps

    1. Pick a small project of your own where some settings live in a binary or GUI only format.
    2. Find or write an export of that data to a readable text form such as JSON or YAML, and commit it to git.
    3. Ask your coding agent to make one specific change twice: once with only the GUI description, once with the text file.
    4. Diff the text result in git and check whether the change is correct and minimal.
    5. Note which version needed fewer retries and less human correction.

    Small angles to try

    • Try the same exercise with a Godot scene file, which is already stored as text.
    • Add a tiny script entry point so the agent can apply the change without opening the GUI.
    • Measure how many tokens the agent spends in each version.
  12. #12Trends × tech

    Always running agents × the ¥3,000 plan: ChatGPT dots hits Plus

    OpenAI has started rolling out dots, its always running agent that works toward goals a user sets on cloud or local computers, to some ChatGPT Plus subscribers and to all Business Standard users. Since its September debut it had been limited to Pro, Business Premium and Enterprise. ITmedia AI+ notes that Plus costs ¥3,000 a month in Japan, while Pro starts at ¥16,800.

    Heat · No. 2 in the ITmedia AI+ access ranking
    What people foundOpenAI Japan says Japan ranks second in the world for weekly active dots users, so a large share of everyday Japanese subscribers may soon run an autonomous agent on their own machines.
    Learn it15 min · 5 steps

    Key ideas

    Always running agent
    An agent that keeps working toward a goal in the background over hours or days instead of answering one prompt at a time.
    Local computer use
    An agent that operates apps and files on your own machine, which brings more power and more risk than a cloud sandbox.
    Tier rollout
    Vendors often ship costly features to premium plans first and widen access once cost and safety look manageable.

    Steps

    1. Read the ITmedia AI+ article first for the rollout details and prices.
    2. Look up OpenAI's own dots announcement from its September DevDay to see what the agent can do.
    3. Write down what an agent with access to your computer could read or change.
    4. Compare a cloud computer setup with a local one for safety.
    5. Self check: what are two limits you would set before letting an agent run unattended on your laptop?
    Try it30 min · 5 steps
    You need: A ChatGPT Plus or Business Standard account where dots has been enabled; rollout is partial, so it may not appear yet. No API key needed.

    Steps

    1. Check in ChatGPT whether dots is available on your account.
    2. If it is, choose the cloud computer option first rather than your own machine.
    3. Give it a small, harmless goal using only public or dummy data, such as collecting three public release notes into one document.
    4. Watch what actions it takes and how often it asks for confirmation.
    5. Stop it and review what it produced and what it touched.

    Small angles to try

    • Repeat the same goal on a spare local machine or a fresh user account with no personal files.
    • Give a vague goal and a precise goal and compare the results.
    • Track how long it runs before it asks you for input.
  13. #13Research

    New since Nov 21: Lean and Mathlib certify the AI produced RH proof

    What is new: the Nov 21 item covered an unverified Lean proof of the Riemann Hypothesis, and the Lean and Mathlib communities have since issued a joint statement dated Nov 21, endorsed by the Lean FRO and the Mathlib Initiative, saying both the statement, Mathlib's RiemannHypothesis, and Levent Alpöge's proof of about 17 million lines are correct. They checked an inert export of the proof with Lean's kernel, the formally verified checkers con-leche and con-ron, and several independent checkers in other languages. Scott Aaronson writes that Alpöge got Anthropic models to produce the proof, but no model is named.

    Heat · HN "Lean verification of the Riemann Hypothesis", 1010 points and 831 comments; Aaronson's post and the original claim also drew large threads
    What people foundTrust here comes from independent checkers, not from anyone reading 17 million lines: the checks ran on an inert export so malicious code in the sources could not affect them. Aaronson expects human understanding of the ideas to take years, and the statement does not list which axioms the proof uses. A verification overview page from MIT said on Nov 22 that some default and paranoid kernel replays were still running.
    Learn it15 min · 5 steps

    Key ideas

    Proof kernel
    A small trusted program that checks every step of a formal proof, so you only need to trust the kernel, not the proof author.
    Independent checkers
    Separate implementations of the checking logic, written in different languages, so a bug in one is unlikely to be shared by all.
    Statement versus proof
    A formal proof is only meaningful if the theorem statement matches the real conjecture, which is why the community checked both.

    Steps

    1. Read the Lean community statement first.
    2. Read the verification overview page linked from it, which lists the export files, checkers and their memory needs.
    3. Look up Mathlib's RiemannHypothesis entry in the Mathlib docs to see how short the statement is compared with the proof.
    4. Read the Xena blog post on the four criteria for a checked proof.
    5. Self check: why did the checks run on an exported file instead of building the original Lean sources?
    Try it30 min · 5 steps
    You need: A laptop with Lean installed via the official get started guide, git, a few GB of disk. The full proof check needs about 100 GB RAM, so skip it. No API key needed.

    Steps

    1. Install Lean and its toolchain manager by following the leanprover community get started guide.
    2. Create a new project that depends on Mathlib, following the Mathlib wiki page on using it as a dependency.
    3. Run lake exe cache get in the project to download prebuilt Mathlib files instead of compiling them.
    4. Open a Lean file that imports Mathlib and use #check RiemannHypothesis to see the exact statement that was certified.
    5. Follow the definitions it uses, such as the zeta function, in your editor and write one sentence on what each means.

    Small angles to try

    • Read the con-leche README to see how a formally verified checker is built.
    • Compare the size of the 47 MB challenge export with the 7.7 GB compressed solution listed on the verification page.
    • State a false claim in Lean and watch the kernel reject a bogus proof of it.
  14. #14Engineering & CS

    Frostbite: agent swarms design an interaction net CPU against Lean specs

    Architect Labs says its AI agents discovered, designed and verified Frostbite, a tiled general purpose CPU with a new instruction set built around interaction nets, carrying the design to a final GDS layout on a 7 nm process. The ISA, RTL and verification trace back to an in house spec language that lowers to more than 800k lines of Lean. Across four searches and a final ablation round, the agent swarm tried 58 ideas and kept 37.

    Heat · HN, 670 points and 359 comments
    What people foundThe company claims 4.59x performance per watt as a geomean over 25 workloads, but only 3.83x on the 15 held out ones, against a single core of an unnamed in order CPU. Power numbers are estimates made before silicon, the baseline cannot be checked, and the RTL is not yet released, so treat the method as the lesson, not the numbers.
    Learn it15 min · 5 steps

    Key ideas

    Interaction nets
    A model of computation where a program is a graph and work happens by locally rewriting pairs of connected nodes, which exposes parallelism without locks.
    Spec as source of truth
    Every design artifact is derived from or checked against one formal specification, so many agents can propose changes that are verified automatically.
    Held out workloads
    Benchmarks not used while tuning the design, which give a fairer estimate than the ones the search optimized for.

    Steps

    1. Read the Architect Labs Frostbite post first, especially the results and caveats sections.
    2. Note which numbers come from the search set and which from the held out set.
    3. Skim the HN thread for hardware engineers' objections to the baseline and power estimates.
    4. Look up a short introduction to interaction nets or interaction combinators.
    5. Self check: why is the 3.83x figure more trustworthy than the 6.02x search set figure?
    Try it30 min · 5 steps
    You need: Python 3 on your own machine, no extra packages. No API key needed.

    Steps

    1. Write a tiny interaction net reducer in Python with two node types and one rewrite rule.
    2. Encode a small computation, such as adding two unary numbers, as a graph.
    3. Run the reducer and count how many rewrites could happen in parallel at each step.
    4. Write a short formal spec for the result, for example as Python assertions, and check every reduction against it.
    5. Ask a coding agent to propose an optimization and keep it only if the spec checks still pass.

    Small angles to try

    • Run several agent proposals in a loop and log which ones survive the checks, like the 58 tried and 37 kept.
    • Replace the Python assertions with a property based test.
    • Split benchmarks into a tuning set and a held out set and compare gains on each.
  15. #15Models & launches

    New since Nov 21: Inkling 2 Mini GGUFs from 7.8GB with per quant KL scores

    New since the Nov 21 launch item: Unsloth released GGUF builds of Thinking Machines' looped Inkling 2 Mini, 26.2B total and 3.4B active parameters, ranging from a 7.76GB UD-IQ1_S to a 22.9GB UD-Q8_K_XL reference. The card lists each quant's KL divergence against that reference: UD-Q4_K_M at 16.6GB keeps the same top token 97.9% of the time, UD-IQ3_XXS at 11.7GB keeps it 94.7%, and UD-IQ1_S keeps it 89.4%. Unsloth notes that support for looped models in local runtimes is new and speed varies by runtime and hardware.

    Heat · 238,152 downloads last month and 668 likes on the Unsloth GGUF card on Hugging Face
    What people foundThe Unsloth card says minimum reasoning effort does not fully turn reasoning off and that the model sometimes got stuck in long reasoning loops, so it recommends limits on output tokens and agent turns. For llama.cpp and other runtimes, use the GGUFs in the Mainline_Support folder.
    Learn it15 min · 5 steps

    Key ideas

    KL divergence
    A measure of how far a quantized model's next token probabilities drift from the reference model's, where lower is closer.
    Looped transformer
    A model that runs the same block of layers several times with shared weights, here the middle 12 layers three times, so compute per token exceeds what the active parameters suggest.
    Same top token rate
    How often the quantized model picks the same most likely next token as the reference, an easy to read quality proxy.

    Steps

    1. Read the Unsloth GGUF card first, especially the quant table and the limitations section.
    2. Match the quant sizes to your GPU or unified memory.
    3. Compare KL divergence and same top token rates across UD-IQ1_S, UD-IQ3_XXS and UD-Q4_K_M.
    4. Skim the HN 5.4 GB thread for a commenter's claim that a smaller custom build had worse KL divergence than UD-IQ1_S.
    5. Self check: why does a looped model need more compute per token than its 3.4B active parameters imply?
    Try it30 min · 5 steps
    You need: llama.cpp built recently, or Ollama; about 17GB of GPU or unified memory for UD-Q4_K_M, or about 12GB for UD-IQ3_XXS. No API key needed.

    Steps

    1. Update llama.cpp or Ollama to a recent version, since looped model support is new.
    2. Start a server with llama serve -hf unsloth/Inkling-2-Mini-GGUF:UD-Q4_K_M as shown on the card, or run ollama run hf.co/unsloth/Inkling-2-Mini-GGUF:UD-Q4_K_M.
    3. Set a maximum output token limit in your client before sending prompts, per the card's warning about reasoning loops.
    4. Send the same five coding prompts and record tokens per second and answers.
    5. Swap to the UD-IQ3_XXS quant and repeat, then compare quality against the 97.9% and 94.7% top token figures.

    Small angles to try

    • Try the lowest reasoning effort and check whether reasoning still appears.
    • Run a short agent loop with a turn cap and see whether it ever stalls.
    • Compare speed in two runtimes on the same hardware.
  16. #16Tools & open source

    OpenAI's Performance Factory: Codex agents that argue over regressions

    OpenAI describes Performance Factory, an internal system in which a performance alert opens a task, a cloud Codex agent using a shared perf-forensics skill investigates, and a separate Codex session tries to disprove that diagnosis before an agent opens a fix PR for an engineer to review. After deploy, an agent checks that latency returned to baseline and reopens the case if not. Over just over three months it tracked more than 1,700 investigations and root caused over 600, and in a manual review of 100 root cause suggestions 70% were graded accurate.

    Heat · OpenAI engineering blog, Nov 19; HN story at 8 points and 1 comment
    What people foundThe OpenAI authors added the adversarial second session because agents tended to stop at the first plausible explanation; that, plus backtesting skill or model changes against past incidents with answer revealing details stripped, is the part worth copying. The 30% of suggestions that were not fully right is why an engineer still decides on the merge.
    Learn it15 min · 5 steps

    Key ideas

    Adversarial review agent
    A second agent session whose only job is to find evidence against the first agent's diagnosis before anyone acts on it.
    Event subscriptions
    A waiting task is woken by events such as a PR review comment, a failed CI check or a finished deployment, instead of polling.
    Incident backtest eval
    Replaying past incidents with a fresh investigator to score timing, affected requests and root cause separately before shipping a new skill or model.

    Steps

    1. Read the OpenAI post, How OpenAI's Performance Factory keeps ChatGPT fast, focusing on the six stage Regression Workflow.
    2. Write down where the humans sit in the loop: PR review and merge decisions, plus judgment calls like adding a cache that could serve stale data.
    3. Read the section on evals and note the four things they score separately in a backtest.
    4. Compare the flow with your own on call runbook and mark which steps are already scripted.
    5. Self check: why does a separate adversarial session catch errors that a longer single investigation would not?
    Try it30 min · 5 steps
    You need: Any coding agent you already use, such as Codex CLI or Claude Code, a repo you own, a local benchmark script; uses your existing agent subscription or API key

    Steps

    1. Pick a small service or function in your own repo and add a deliberate slowdown, such as an unnecessary sleep or a nested loop over a large list, in a new commit.
    2. Write a short benchmark script that prints timings, and record the baseline from the commit before the slowdown.
    3. Ask agent session one to find when the slowdown started and why, giving it the benchmark output and git history only.
    4. Open a fresh agent session, paste only the first diagnosis, and ask it to try to disprove it using the code and benchmark.
    5. Let an agent propose a fix, review the diff yourself, then rerun the benchmark to confirm a return to baseline.

    Small angles to try

    • Plant two changes, one real cause and one red herring, and see whether the adversarial session catches a wrong first answer.
    • Strip the commit messages first, as the post's backtests strip answer revealing details, and compare accuracy.
    • Have a third session with no context grade the handoff summary for clarity.
  17. #17Models & launches

    Prime Intellect: intruder served an abliterated DeepSeek V4.1 Flash

    Prime Intellect's advisory PI-SA-2026-001, published Nov 19, says an unauthorized party replaced a deployment behind the deepseek/deepseek-v4.1-flash endpoint with publicly available abliterated weights of the same model from Nov 8 01:24 UTC to Nov 10 06:35 UTC. Tokenizer, chat template and serving configuration were unchanged and GPQA Diamond and tau-bench scores were unaffected, while refusals dropped from 98 of 100 to 1 on JailbreakBench, from 304 of 313 to 2 on StrongREJECT and from 198 of 240 to none on HarmBench.

    Heat · HN: top story at 9 points and 1 comment, the advisory itself at 2 points and 4 comments; low attention since Nov 19
    What people foundPrime Intellect says it found no evidence that prompts or completions were recorded or left the serving cluster, contacted affected customers, and asks those who relied on refusals to review outputs from the window; the root cause is not stated and the investigation is ongoing. The broader lesson: a model id and capability evals do not prove which weights are answering, so a small refusal canary set is worth running against any hosted model you depend on.
    Learn it15 min · 5 steps

    Key ideas

    Abliteration
    Editing a model's weights to remove the internal direction that produces refusals, which keeps most capabilities while the model stops saying no.
    Model substitution
    Serving different weights behind the same model name, which callers cannot see from the API response alone.
    Behavioural canary
    A fixed small prompt set whose expected answers, such as refusals, are checked on a schedule to notice when a model's behaviour shifts.

    Steps

    1. Read the Prime Intellect advisory PI-SA-2026-001 in full, noting what was and was not changed.
    2. Note why GPQA Diamond and tau-bench missed the swap while refusal benchmarks caught it.
    3. Skim the maccus.fr write-up for a second summary of the timeline.
    4. List the hosted models your products call and whether anything checks their behaviour over time.
    5. Self check: which kind of test would have detected this swap within an hour, a capability eval or a refusal canary, and why?
    Try it30 min · 5 steps
    You need: A machine where you run an open weight model locally, any runtime you already use, Python 3; No API key needed

    Steps

    1. Pick a model you downloaded yourself and record a SHA256 hash of each weight file with sha256sum, saved to a text file next to the model.
    2. Write 10 to 20 mild requests the model is expected to decline, such as asking for a private person's home address, plus 10 normal requests, as your canary set; keep it free of genuinely dangerous content.
    3. Run the canary set against your local model at temperature 0 and save each answer with a simple label: refused or answered.
    4. Write a small Python script that reruns the set and alerts if the refusal count changes by more than one or two.
    5. Re-hash the weight files and confirm the hashes match before trusting the run.

    Small angles to try

    • Run the same canary set against a hosted model you pay for, using only your own account, and track the refusal count daily.
    • Compare two quantizations of the same local model to see how much refusal counts drift without any tampering.
    • Add a few fixed factual prompts with exact expected answers as a cheap fingerprint alongside refusals.
  18. #18Models & launches

    Why Qwen3.8-27B overthinks in coding agents, and harness fixes

    Pekka Enberg finds that Qwen3.8-27B often spots the bug and the fix, then keeps reasoning from memory about code it has not re-read instead of acting. On SWE-bench Verified Mini, 50 Django and Sphinx issues with one run each, his dwim harness resolved 64% with 6,270 median thinking tokens and 55 s median time, against 52%, 22,610 tokens and 169 s for OpenCode 1.19.6. In 8 of OpenCode's 14 no patch runs the model announced a next step without calling a tool, and opencode run treated that as done.

    Heat · HN: 2 points and 2 comments
    What people foundEnberg's settings: cap thinking at 2,048 tokens and close the thought with a push to use a tool, reasoning effort low, temperature 0.6, top-p 0.95, a system prompt telling the model to read or run code rather than recall it, a nudge when it announces a step with no tool call, refusal of repeated tool calls, and a reminder after 20 tool calls with no file change. The eval ran through Vercel AI Gateway.
    Learn it15 min · 5 steps

    Key ideas

    Overthinking
    A reasoning model spending many tokens second guessing or recalling instead of acting, which research by Cuadron et al. links to lower SWE-bench success.
    Thinking cap
    A hard limit on reasoning tokens, after which the harness ends the thought and steers the model toward a tool call.
    Agent harness
    The loop around a model that sends prompts, runs tool calls and decides when a run is finished.

    Steps

    1. Read Enberg's post on penberg.org, starting with the hedges like I recall that mark memory based reasoning.
    2. Study the results table and note which numbers moved most: thinking tokens and patch rate.
    3. Read the list of mitigations and sort them into prompt changes, sampling settings and harness rules.
    4. Skim the dwim repo on GitHub to see how the harness is packaged.
    5. Self check: why would a harness that treats a no tool call reply as completion lower the patch rate?
    Try it30 min · 5 steps
    You need: Qwen3.8-27B or another local reasoning model served by a runtime you already use, enough GPU memory for it, a small repo with a known failing test; No API key needed

    Steps

    1. Pick a repo you own and break one function so a single unit test fails.
    2. Run your current coding agent on the task with default settings and record thinking tokens, tool calls and whether it produced a patch.
    3. Change sampling to temperature 0.6 and top-p 0.95 and set reasoning effort low if your runtime supports it.
    4. Add a system prompt line telling the model to read or run code instead of recalling it, and add a rule in your harness that replies with no tool call get a short continue message.
    5. Rerun the same task three times and compare thinking tokens and success with the baseline.

    Small angles to try

    • Add a 2,048 token thinking cap if your runtime can stop reasoning at a limit, and compare.
    • Count hedges like I think or I recall in the reasoning before and after the prompt change.
    • Try dwim itself inside a container, since its README warns it can run commands without asking.
  19. #19Research

    RL post-training in diffusion transformers is mostly a constant shift

    Tuna Han Salih Meral and coauthors fit a fixed set of steering vectors, added to the block outputs of a frozen base model and identical for every prompt, token and seed, to match public RL tuned checkpoints with no reward in the objective. These vectors recover 90.0 to 96.3% of the reward gains of six RL tuned image models and 89.8% and 111.9% for two video models. On SD3.5-M they use 0.29M parameters against 18.8M for the RL LoRA, about 65 times fewer.

    Heat · HF Papers: 17 upvotes
    What people foundThe authors report that vectors initialized at zero and trained with online RL alone beat weight based RL on SD3.5-M for OCR text rendering and PickScore, which they read as RL steering the generator toward outputs it could already produce. No code repository is listed yet, only a project page.
    Learn it15 min · 5 steps

    Key ideas

    Activation steering
    Adding a learned vector to a layer's output at inference time to change behaviour without editing the weights.
    Velocity prediction
    In flow based diffusion models like SD3.5, the network predicts the direction to move a noisy sample, and the vectors are fit to match the RL model's predictions.
    Input independent adapter
    An adapter whose change is the same for every prompt, unlike a LoRA whose effect depends on the input.

    Steps

    1. Read the arXiv abstract for 2611.26627, RL Post-Training in Diffusion Transformers Is Activation Steering.
    2. Open the project page at rl-is-steering.github.io for figures comparing base, RL and steered outputs.
    3. Find the table with the six image models and note which reward each RL checkpoint targeted.
    4. Compare the 0.29M versus 18.8M parameter counts and think about what that means for storing many adapters.
    5. Self check: if the shift is the same for every prompt, what does that suggest the RL tuning actually learned?
    Try it30 min · 5 steps
    You need: Python, PyTorch and diffusers, a GPU with enough memory for a small diffusion transformer, model weights you are licensed to download; No API key needed

    Steps

    1. Load a small diffusion transformer with diffusers and pick one transformer block to hook.
    2. Register a forward hook that adds a constant vector to that block's output, starting with a small random vector.
    3. Generate images for 5 fixed prompts and seeds with and without the hook and save them side by side.
    4. Scale the vector up and down and note how much a single constant shift changes style across all prompts.
    5. If a public RL tuned LoRA exists for the same base, compare its outputs with base outputs for the same seeds to see whether the change looks prompt independent.

    Small angles to try

    • Average the difference in block outputs between base and LoRA models over a few prompts and add that mean as the vector.
    • Hook several blocks instead of one and compare.
    • Measure storage and load time for a vector file versus a LoRA file.
  20. #20Trends × tech

    Deepfakes × provenance: TikTok lets anyone check its AI made media

    On Nov 20 TikTok added a check to its Transparency Center where anyone, without an account, can upload an image or video to see whether it was generated or edited with TikTok's own AI tools, using Content Credentials and its invisible VeraDura watermark. It also began a global rollout of opt in likeness detection, which alerts verified creators and public figures, including politicians and government accounts, to possible AI content using their likeness so they can report it.

    Heat · Covered by Impress Watch on Nov 21; no HN or ranking signal found
    What people foundTikTok says it has labeled more than 5 billion AI generated videos so far. The check only recognizes content from TikTok's own AI features, so a negative result says nothing about media from other generators.
    Learn it15 min · 5 steps

    Key ideas

    Content Credentials
    Signed metadata based on the C2PA standard that records how a file was created and edited.
    Invisible watermark
    A signal hidden in pixels that survives some edits and lets the maker detect its own output even after metadata is stripped.
    Likeness detection
    Scanning for content that appears to use a registered person's face so that person can be alerted.

    Steps

    1. Read the Impress Watch article of Nov 21, using a browser translator if needed.
    2. Read TikTok's newsroom post on its AI generated content updates.
    3. Note the two detection layers, credentials and the VeraDura watermark, and why metadata alone is easy to strip.
    4. Look up the C2PA site's overview of Content Credentials.
    5. Self check: why can a provider's checker confirm its own output but not prove a file is free of AI?
    Try it30 min · 5 steps
    You need: A browser, a TikTok account only if you want to create a test file with its AI tools, your own photos; No API key needed

    Steps

    1. Take a photo you shot yourself and upload it to TikTok's AI generated content check to see the result for clearly real media.
    2. Create an image with a TikTok AI effect on your own account, save it, and upload it to the check.
    3. Screenshot or re-encode that same saved file and upload again to see whether the watermark still registers.
    4. Upload an image you made with a different AI generator and confirm the check does not claim to detect it.
    5. Write down which cases it caught and which it could not, as a scope note for anyone citing it.

    Small angles to try

    • Crop or resize the TikTok AI image in steps and find where detection stops.
    • Inspect the saved file's metadata with a Content Credentials viewer to see what is signed.
    • Compare with another platform's provenance checker on the same files.

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.