Wednesday, November 11, 2026
-
AlphaProof Code: Gemini Carbon agents prove Signal's crypto in Lean
Google DeepMind introduced AlphaProof Code, an agentic framework in which human experts pick the security properties to prove and agents powered by Gemini Carbon write the proofs in Lean, which Lean then checks mechanically. The team says it verified the core cryptographic protections of a compiled Signal binary, built from unmodified libsignal, in four weeks, with human review focused on about one percent of the code. The specifications, proofs and a technical paper are published in an open repository.
Heat · HN front page, about 625 points and 182 comments on Nov 10What people foundDeepMind reports that when two previously fixed Signal bugs were put back into an isolated copy of the code, the system produced machine checked proofs that both versions were insecure. The proof size is reported inconsistently: the blog body says over six million lines of Lean, the artifact site says about 6.5 million, and the blog summary says over three million. What is published is the verification artifacts, not the agent framework itself.Learn it15 min · 5 steps
Key ideas
- Lean
- A programming language and proof assistant whose kernel checks every step of a proof, so an accepted proof cannot contain a hidden logical gap.
- Trusted specification
- The small part of a verification effort that humans must read and trust, here about 26,000 lines of security statements and AArch64 machine semantics, while millions of proof lines are checked by the machine.
- Machine code verification
- Proving properties about the compiled binary rather than the source code, so compiler bugs cannot silently break the guarantee.
Steps
- Read the DeepMind blog post Introducing AlphaProof Code for the overall workflow of humans writing goals and agents writing proofs.
- Open the artifact site google-deepmind.github.io/code-verification and look at how statements, definitions and trusted semantics are split into three trust tiers.
- Skim the sections of the technical paper on the reintroduced bugs and on the human review budget.
- Compare this approach with ordinary fuzzing or unit tests: note what a proof covers that a test suite cannot.
- Self check: why does verifying the compiled AArch64 binary give a stronger guarantee than verifying the Rust source?
Try it30 min · 5 steps
You need: A laptop with git and a browser; installing the Lean toolchain is optional and follows the repository's own instructions. No API key needed.Steps
- Clone the google-deepmind/code-verification repository from GitHub to your own machine.
- Find the trusted specification files, such as the AArch64 semantics folder, and count their lines with a simple line count tool to see how small the trusted base is compared with the proofs.
- Open one Tier 1 theorem statement on the artifact site and write down in plain English what security property it claims.
- If you want to check proofs locally, follow the repository README for the required Lean version and build command, and start with a single small module rather than the whole development.
- Read the paper section on the gatekeeper that compares proofs against a held out copy of the specification, and note how it stops agents from quietly weakening a goal.
Small angles to try
- Pick a small pure function in your own codebase and try writing its specification in Lean with a coding agent's help.
- Ask a coding agent to explain one Lean proof file from the repo line by line and check whether its explanation matches the statement.
- List which properties of your own service would need a trusted model of the environment before any proof would mean something.
-
Modern Web Guidance: Chrome and Edge steer coding agents to native APIs
GoogleChrome/modern-web-guidance is a preview pack of agent skills, backed by the Chrome and Microsoft Edge teams, that covers 103 web platform features and 131 developer use cases such as forms, performance, accessibility, passkeys and built in AI. The agent searches the guides with an offline TensorFlow.js model and pulls code patterns, gotchas and fallbacks without any API key. It installs into Claude Code, Copilot CLI, Antigravity, Grok and other agents with one command or a plugin.
Heat · Show HN with about 362 points and 105 comments on Nov 10; 1.8k GitHub stars and 71 forksWhat people foundThe repo's own evals, an Aug 24 snapshot, show Claude Code with opus-5 rising from 57% to 92% on its task set once the guidance is installed, with similar gains for Antigravity and Codex CLI. Author Paul Irish noted on HN that models know features like dialog by name yet still fall back to a div plus JavaScript. Anonymous telemetry is on by default, so setDISABLE_TELEMETRY=1if you want it off.Learn it15 min · 4 steps
Key ideas
- Agent skill
- A folder of instructions and reference material that a coding agent loads only when a task matches, instead of keeping it in every prompt.
- Baseline web features
- Browser APIs such as dialog, popover and view transitions that now work across major browsers and replace older JavaScript workarounds.
- Offline retrieval
- The skill ranks its guides with a small local TensorFlow.js model, so searches need no network service or key.
Steps
- Read the README of GoogleChrome/modern-web-guidance, especially the install section and the eval table.
- Skim the Show HN thread for the discussion of why models default to older JavaScript patterns.
- Open two or three guides in the repo, for example on dialogs or forms, and note the fallback advice each gives.
- Self check: what kind of frontend bug would this skill prevent that a linter would not catch?
Try it30 min · 5 steps
You need: Node.js with npx, and Claude Code or another supported coding agent with its usual subscription; the guidance itself needs no API key. Optionallyexport DISABLE_TELEMETRY=1first.Steps
- In a throwaway frontend project, ask your agent to build a modal confirm dialog with an animated backdrop and save the result on a branch.
- Install the skills with
npx modern-web-guidance@latest install, or in Claude Code run/plugin marketplace add GoogleChrome/modern-web-guidancethen/plugin install modern-web-guidance@googlechromeand/reload-plugins. - Try the CLI directly with
npx modern-web-guidance@latest search "animate a dialog modal backdrop"to see which guide it returns. - Give the agent the same modal task again on a fresh branch and diff the two results, checking for a native dialog element and fewer custom scripts.
- Test both versions with keyboard only navigation and the Escape key to see which handles focus correctly.
Small angles to try
- Repeat with a form validation task and compare how much custom JavaScript each version writes.
- Run
npx modern-web-guidance@latest install --chooseand install only the accessibility related packs. - Compare results between two different agents on the same task with the guidance installed.
-
Gemini 4 Carbon opens to all paid API users at Argon prices to Nov 30
Google made Gemini 4 Carbon, its strongest model, available to paying developers through the Gemini API in AI Studio and Gemini for business, and is rolling it out to Google AI Ultra subscribers in Antigravity, the Gemini app and AI Mode in Search. In October it reached only selected users. Google positions Carbon for harder, long running tasks where it spends more tokens to explore and verify, and calls Gemini 4 Argon the ideal choice for most software engineering and knowledge work.
Heat · HN front page, 284 points and 155 comments on Nov 10What people foundThe introductory price matches Argon at $2 per million input tokens and $10 per million output tokens through November 30, 2026, then rises to $4 and $20. Google reports first place on CursorBench 4.0, Perplexity WANDR and Zapier AutomationBench at more than 2x lower cost per task than the next best external model, and admits prompt injection robustness still needs work. Artificial Analysis had already ranked Carbon first on its Intelligence Index on Oct 28.Learn it15 min · 4 steps
Key ideas
- Cost per task
- Total spend to finish a benchmark task, including all reasoning tokens, which matters more than the per token price for models that think longer.
- Introductory pricing
- A temporary price that lets teams evaluate a model cheaply before the list price doubles on a fixed date.
- Prompt injection
- An attack where text inside a document or web page tries to override the model's instructions, a key risk for agents that read untrusted content.
Steps
- Read the Google blog post Gemini 4 Carbon is now available for availability, prices and benchmark claims.
- Read the Artificial Analysis article on Carbon's Intelligence Index score for an independent comparison.
- Note which of Google's numbers are vendor reported and which come from third parties.
- Self check: for your workload, would a model that uses more tokens but finishes in fewer attempts cost more or less overall?
Try it30 min · 5 steps
You need: A Google AI Studio account with paid Gemini API billing enabled and an API key; Python or Node with the official Gemini SDK, following Google's quickstart.Steps
- Pick three hard tasks from your own work, such as a tricky refactor plan or a multi step data question, and write down what a correct answer looks like.
- In AI Studio, select Gemini 4 Carbon and run each task, recording output quality and the token counts shown.
- Run the same three tasks on Gemini 4 Argon with identical prompts.
- Compute cost per task for both models at the current $2 and $10 price and again at the post Nov 30 price of $4 and $20.
- Decide which tasks justify Carbon after the price rise and note it before the introductory window closes.
Small angles to try
- Add a document containing a hidden instruction to one task and see whether either model follows it.
- Compare Carbon against the model your team uses today on the same three tasks.
- Measure wall clock latency, not only tokens, for an interactive use case.
-
VulnCheck counts 442 Anthropic credited CVEs, only 2 exploited
VulnCheck's Patrick Garrity reviewed seven months of vulnerability disclosures from Anthropic's Project Glasswing and published an open GitHub tracker of Anthropic credited CVEs, built from CVE records, GitHub advisories, Linux kernel commits and Anthropic's own ledger. He counts 442 attributable CVEs, about 0.5% of the 93,450 CVEs published this year. Only 2 of them are in VulnCheck KEV as exploited in the wild.
Heat · HN front page, about 396 points and 187 comments on Nov 10What people foundGarrity's numbers point to severity inflation: in his September analysis Claude rated 91.5% of ledger findings critical or high, against 51.3% by maintainers. curl's review of 34 published reports found 19 were not vulnerabilities and 6 were low severity, with 9 still pending, which he counts as a 55.9% false positive rate so far. For triage, exploitation evidence is a better guide than the severity an AI scanner assigns.Learn it15 min · 4 steps
Key ideas
- CVE
- A public identifier for a specific vulnerability, assigned so vendors and tools can refer to the same bug.
- KEV list
- A catalog of vulnerabilities with evidence of exploitation in the wild, used to decide what to patch first.
- CVSS severity
- A score from 0 to 10 describing how bad a vulnerability could be, which different reporters often rate differently.
Steps
- Read VulnCheck's post Glasswing November update for the counts and the severity comparison.
- Open the patrickmgarrity/Anthropic-Credited-CVEs repository and look at the columns in its table, including CVSS, Ledger and vcKEV.
- Pick two entries and open their CVE records to see who rated the severity and how.
- Self check: if an AI tool reports a critical bug in your dependency, what two pieces of evidence would you look for before treating it as urgent?
Try it30 min · 5 steps
You need: git and Python 3 with PyYAML on your own machine. No API key needed.Steps
- Clone the patrickmgarrity/Anthropic-Credited-CVEs repository.
- Load
cves.yamlin a short Python script and print the available fields for a few entries. - Count entries by vendor or product and list the ones marked as in VulnCheck KEV.
- Check whether any product in your own dependency list appears, and compare its CVSS score with the vendor's own advisory.
- Note any difference between the repo's current counts and the 442 in the blog post, and read the README to understand what each category counts.
Small angles to try
- Plot CVE count per month to see whether disclosures are speeding up.
- Group entries by language or ecosystem to see where AI scanning finds the most bugs.
- Draft a triage rule for your team that weighs exploitation evidence above reported severity.
-
Hacking your own TV × coding agents: REA brings DIY reverse engineering
ITmedia NEWS reports a growing trend of people using coding agents to modify closed software, including smart TV firmware, to strip ads or add features. The story centers on REA, short for Reverse Engineer Anything, an open source MCP server and CLI that works with Claude Code, Codex, Cursor, Gemini CLI and Grok Build. In one example a user had Claude Code find a parent's TV over Wi-Fi, remove 25 Xiaomi packages and install a new launcher; another turned a discontinued Lululemon Mirror into a smart mirror.
Heat · Number 5 in the ITmedia AI+ access ranking on Nov 11; ITmedia says REA passed 420,000 GitHub stars as of Nov 5What people found404 Media's Jason Koebler, quoted by ITmedia, warns that AI copied software often has bugs its users cannot understand or fix, that vulnerable modded firmware on home devices could expose whole networks, and that attackers will try to slip malware into the process. For app makers the lesson is that anything enforced only on the client is now within easy reach of end users.Learn it15 min · 4 steps
Key ideas
- Reverse engineering
- Working out how a program behaves from its compiled form or its runtime behavior when no source code is available.
- MCP server
- A tool server that a coding agent connects to over the Model Context Protocol, here giving the agent decompilers and analyzers to call.
- Static analysis
- Inspecting files without running them, which REA uses for JavaScript and .NET targets and which is safer than running unknown code.
Steps
- Read the ITmedia NEWS article for the examples and Koebler's warnings.
- Read the REA README on GitHub, especially the authorized use and official sources sections.
- List the target types REA supports and mark which ones exist in software you ship.
- Self check: which checks in your own app run only on the client and would be easy for a user with an agent to bypass?
Try it30 min · 5 steps
You need: Node.js 22 or later with npm, your own Electron or JavaScript app or a build you are licensed to inspect, and optionally Claude Code or another supported agent. The CLI analysis itself needs no API key.Steps
- Get REA only from the morluto/rea repository or the rea-agents npm package, as the README advises, and work inside a container or spare VM.
- Build or extract one of your own JavaScript or Electron apps to a local folder.
- Run
npx -y rea-agents@latest analyze-javascript-application /absolute/path/to/app --jsonand save the output. - Search the output for API keys, feature flags, license checks or endpoints that you assumed were hidden.
- Move any secret or check you find to the server side and note it as a fix for your backlog.
Small angles to try
- Run
npx rea-agents setupfor your agent, review the configuration changes it proposes, then ask the agent to explain your app's startup flow. - Try the same analysis on an older build of your app to see what has changed between releases.
- Write a short threat model for a device you own, listing what could go wrong if its firmware were modified.
-
Claude Sheets and Whiteboards enter beta; Dashboards becomes Claude Data
Anthropic launched Claude Sheets, a spreadsheet Claude builds and edits with you while logging every change, and Claude Whiteboards, a shared board where Claude groups ideas, assigns owners and dates, and drafts action items. Claude Dashboards was renamed Claude Data and is now generally available, with certified metric definitions, data stories and live sharing. All three run on paid plans across web, desktop and mobile.
Heat · HN front page, 213 points and 151 commentsWhat people foundSheets is intentionally basic and exports to .xlsx or CSV when full Excel features are needed, and Claude Data only works once a warehouse or CRM connector is attached. Inside Data, certified queries and live sharing are still beta. On Enterprise, Sheets and Whiteboards start off and Data switches on by default on November 19, so admins should review Organization settings > Artifacts before then; on Team plans all three are already on.Learn it15 min · 5 steps
Key ideas
- Certified metric definition
- A query for a business number such as revenue that a data owner has approved, so everyone who asks Claude gets the same definition.
- Data connector
- An integration that lets Claude read from a warehouse, CRM or analytics tool, and Claude Data needs one before it can answer anything.
- Tracked edits
- A log of each change Claude makes to a sheet, so a person can see and review what moved.
Steps
- Read the Claude article on Sheets, Whiteboards and Data first, noting which parts are beta and which are generally available.
- List the partner tools named for each product: Airtable, Asana, monday.com and Smartsheet for Sheets; Lucid, Miro and Vani by Zoho for Whiteboards; Amplitude, Mixpanel, Omni, PostHog and Sigma for Data.
- Compare the default settings for Team and Enterprise plans and find the admin setting that controls them.
- Skim the HN thread for how engineers compare Sheets with Excel and Google Sheets.
- Self check: if your Enterprise org does nothing, which of the three products is on for users on November 20, and what does it still need before it shows any numbers?
Try it30 min · 5 steps
You need: A paid Claude plan on web or desktop, a small CSV of your own data, and for Claude Data a warehouse or CRM connector you are allowed to use. No API key needed.Steps
- Ask Claude to build a sheet from your own CSV with a summary tab, a few formulas and a drop down column for status.
- Ask for two edits in a row, then open the change log and confirm each edit is recorded and understandable.
- Export the sheet to .xlsx, open it in Excel or LibreOffice, and check that formulas and formatting survived.
- Paste rough meeting notes into a Whiteboard and ask Claude to group them by theme with owners and dates, then turn the board into a doc.
- If you have a connector, ask Claude Data the same metric question twice in different words and check whether the numbers match.
Small angles to try
- Give Sheets a messy CSV with mixed date formats and see how it cleans them.
- Compare a Claude Data answer with the same query run by hand in your warehouse.
- As an admin, write down the Enterprise defaults your org wants before November 19.
-
Opus 5.5 agents model 4,071 CPython functions in Lean, find 418 bugs
David Andrews and Chao Zhang are rewriting CPython 3.15.2 functions in Lean with Opus 5.5 agents, testing each copy against real Python on at least 50,000 inputs, proving properties, and having a second agent that did not write the code try to break it. Since October 29 they have accepted 4,071 of 26,004 functions, or 15.7%, in 613,318 lines of Lean. The work produced 418 bug reports, about 55 of them serious enough to crash the interpreter or corrupt memory from ordinary Python code.
Heat · HN, 131 points and 55 commentsWhat people foundThe authors found that early proofs were correct but said nothing useful: a claim like "if it returns, the answer is at least 0" also holds for a function that always crashes. Reviewers now ask of every proof whether a broken version of the function could pass it too, a cheap check that also applies to agent written unit tests.Learn it15 min · 5 steps
Key ideas
- Differential testing
- Running two implementations on the same inputs and flagging any output that differs, here the Lean model against real CPython.
- Hollow proof
- A machine checked proof that is true but so weak that a wrong implementation would satisfy it as well.
- Lean
- A programming language and proof assistant whose checker verifies that each proof step is valid.
Steps
- Read the Formalizing CPython post by Andrews and Zhang first, focusing on the section about weak proofs.
- Open the GitHub repo and read AGENTS.md and coverage/REVIEW_PROMPT.md to see how the writer and reviewer agents are instructed.
- Browse bugs/FINDINGS.md and pick one serious report to see what Python code triggers it.
- Look at coverage/review to see how functions are marked FAITHFUL or HOLLOW.
- Self check: write one property for a sort function that a function returning an empty list would also pass, then strengthen it so it would not.
Try it30 min · 5 steps
You need: Python 3 for the small exercise; for the full repo, the Lean toolchain installed by elan, a CPython 3.15.2 build on PATH as python3, and per the README 64 GB of RAM or more. No API key needed.Steps
- Clone github.com/Broyojo/python-formalization and read the README requirements before building anything.
- Run one of the bug scripts from the bugs folder only inside a disposable container with your own CPython build, to see a reported crash reproduce.
- On a machine with enough memory, run
cd lean && lake build && lake env lean Audit.leanto check the registry theorems. - Run
python3 difftest/rangeslice_diff.py --cases 50000to see the differential test compare Lean and CPython. - Apply the broken version check to your own code: take one of your test files, introduce a deliberate bug in the function, and count which tests still pass.
Small angles to try
- Ask a coding agent to write tests for a function, then mutate the function and see which tests are hollow.
- Run
python3 scripts/check_coverage.pyand compare accepted counts with the post. - Read one HOLLOW review verdict and rewrite the property so it would catch a crash.
-
Meituan opens LongCat-2.5 weights: 1.6T MoE, 48B active, MIT license
Meituan published the weights of LongCat-2.5 on Hugging Face under the MIT license on November 9, one week after introducing the model. It is a natively multimodal mixture of experts model with about 48B of 1.6T parameters active per token, aimed at long running coding and agent work, and its hosted API accepts images and video. Meituan reports 88.4 on Terminal Bench v2.1, 64.6 on DeepSWE v1.1 and 91.9 on BrowseComp.
Heat · Hugging Face model page, 80 likes; VentureBeat coverage; no HN story foundWhat people foundVentureBeat points out that the Hugging Face metadata says 1.8T while Meituan says 1.6T, so size any deployment from the actual files. It also notes that DeepSeek-V4.1-Flash still scores higher on Terminal Bench v2.1 and DeepSWE, while the hosted LongCat-2.5 API costs $0.30 per million input tokens and $1.20 per million output tokens at a limited time rate.Learn it15 min · 5 steps
Key ideas
- Mixture of experts
- A model with many expert subnetworks where only a few run for each token, so active parameters are far fewer than total parameters.
- Active parameters
- The weights actually used per token, here about 48B, which drive compute cost per token.
- Thinking mode switch
- A chat template option that turns visible reasoning on for better results or off to save tokens.
Steps
- Read the LongCat-2.5 model card on Hugging Face first, including the note that unmarked scores are in house and indicative only.
- Read the VentureBeat article for pricing and how the scores compare with DeepSeek-V4.1-Flash and Claude Opus 5.
- Check the Files tab on Hugging Face to see the weight formats and total size.
- Estimate memory: multiply 1.6T parameters by two bytes for BF16 and compare with the GPUs you have.
- Self check: why can a model with 1.6T parameters be cheap per token, and why is it still hard to self host?
Try it30 min · 5 steps
You need: Python 3 with the openai package, a LongCat platform account and API key for the hosted model, and a few of your own screenshots. Self hosting the full model is not practical on ordinary hardware.Steps
- Create a key on Meituan's LongCat platform and look up the exact model id in its API docs, since the model card does not name one.
- Point the OpenAI compatible client at the LongCat endpoint and send a short coding prompt.
- Send the same prompt with
enable_thinkingset to True and then False insidechat_template_kwargs, and compare quality and token counts. - Send a screenshot of one of your own web pages and ask for matching HTML and CSS, then render the result locally.
- Log input and output tokens for each call and compute cost at $0.30 and $1.20 per million.
Small angles to try
- Run the same screenshot task on a model you already use and compare the output side by side.
- Give it a small repo bug from your own project and see whether its fix passes your tests.
- Try a short video URL with the video interface and check what it describes.
-
Harness Leaderboard: same model, nine coding agent harnesses compared
Joël Niklaus published a Hugging Face Space that ranks coding agent harnesses while holding the model, provider and reasoning effort fixed. The initial run covered nine harnesses, including Claude Code, Codex, Kimi Code, Hermes Agent, OpenCode and mini-swe-agent, on Terminal-Bench 2.1 and DeepSWE with three attempts per task, 28,849 trials in total. Each harness gets scores for accuracy, cost and reliability across attempts.
Heat · Hugging Face Space, 267 likes; an HN submission got little attentionWhat people foundAccording to remio's November 9 write up, mini-swe-agent led with a 51.4% average solve rate across GLM-5.3-Flash, DeepSeek-V4.1-Flash and Flint, OpenClaw was lowest at 27.3%, and four other harnesses were statistically tied with the leader. The best harness changed by model: Hermes Agent led on DeepSeek-V4.1-Flash and Kimi Code on Flint. The run records are published but, as remio notes, not independently reproduced yet.Learn it15 min · 5 steps
Key ideas
- Harness
- The agent program around a model that supplies the prompt, tools, loop and stopping rules.
- Solved at least once versus every time
- For mini-swe-agent, 68.6% of tasks were solved in at least one of three attempts but only 33.0% in all three, which shows how noisy single runs are.
- Statistical tie
- Scores so close that the difference could come from run to run noise rather than a real gap.
Steps
- Read the remio write up first for the setup and headline numbers.
- Open the Harness Leaderboard Space, pick one model and reasoning effort, and compare the accuracy, cost and reliability columns.
- Switch models and note how the ranking of harnesses changes.
- Read the mini-swe-agent README to see how small a competitive harness can be.
- Self check: if a harness change raises your solve rate by two points on one run, what would you need before calling it an improvement?
Try it30 min · 5 steps
You need: Python 3 with pip, an API key for a model provider you already use, and a small repo of your own with a failing test.Steps
- Install the minimal harness with
pip install mini-swe-agentand start it with theminicommand. - Configure it to use your model following the mini-swe-agent configuration docs.
- Give it one task in your own repo, such as fixing a failing test, and record whether it succeeds and what it costs.
- Run the same task three times and record how often it passes.
- Run the same task three times with a different harness you already use on the same model, and compare pass counts and cost.
Small angles to try
- Change only the reasoning effort and see whether harness rankings hold.
- Pick five tasks instead of one and check whether differences survive three attempts each.
- Compare token usage per task between the two harnesses.
-
Fireworks AI breach exposes some Notion AI chats; Notion drops vendor
Notion says its inference vendor Fireworks AI had a security incident, and that unattributed Notion AI chat transcripts used for its Insights feature were in the affected data, touching fewer than 1% of workspaces. Notion disconnected from Fireworks and deleted its data there by November 3; Fireworks reported possible access by attackers on November 6 and confirmed the dataset on November 8. Notion has disabled Insights and no longer serves open weight models through Fireworks.
Heat · HN front page, 161 points and 63 commentsWhat people foundNotion's advice is to treat the exposed chats as compromised and rotate any passwords, API keys or other credentials anyone pasted into Notion AI during the period. Workspace owners who were notified can review the data under sidebar, then ?, then Security incident review, on desktop or web. The wider lesson for engineers: prompts can pass through inference vendors that users never see, so secrets do not belong in AI chats.Learn it15 min · 5 steps
Key ideas
- Inference provider
- A company that runs models on its own servers for another product, so user prompts pass through its systems.
- Subprocessor
- A third party vendor that handles customer data on a company's behalf and is usually listed in its privacy documents.
- Credential rotation
- Replacing a password or key with a new one and revoking the old one so leaked copies stop working.
Steps
- Read Notion's help page on the incident first and write down the timeline from November 3 to November 8.
- Note exactly what was in the data and what Notion says was not, such as author labels and tool call results.
- Find the subprocessor list for one AI tool your team uses and see which inference vendors it names.
- Skim the HN thread for how others assess vendor risk with AI features.
- Self check: if a teammate pasted a database password into an AI chat last month, what two things should happen today?
Try it30 min · 5 steps
You need: Access to your own workspace or repo and your own secret scanning tool or a regex script. No API key needed.Steps
- If you own a Notion workspace, check whether Notion contacted you, and if so open the Security incident review page on desktop or web.
- Export your own AI chat history from a tool that allows it, and scan it locally for strings that look like keys or passwords.
- Rotate any credential the scan finds and confirm the old value no longer works on your own systems.
- List every AI feature your team uses and record which vendors process the prompts, using each product's own documentation.
- Draft a one line team rule on what may not be pasted into AI chats, and a contact to tell if it happens.
Small angles to try
- Add a pre send check in an internal chat tool that warns when text matches a key pattern.
- Compare data retention terms for two AI vendors you use.
- Run a tabletop drill: a vendor tells you on a Friday that prompts leaked; who does what?
-
On Being an Engineer in 2026: tacit knowledge as the human edge
In a Nov 8 essay, Shahar Glazner argues that if engineers added nothing beyond access to the same agents, the output gap between strong and average engineers would have closed, and it has not. He locates the remaining leverage in tacit knowledge: asking questions until the real problem is clear, judging which problems deserve a sophisticated answer, and asking whether a design will still make sense years from now. He ties all of this to lived experience, including past mistakes, which agents do not carry.
Heat · HN 183 points and 304 comments, a high comment ratio that signals heavy debateWhat people foundGlazner's practical point is that agents produce answers without having to live with them, so problem framing, difficulty calibration and long term consequences are the parts of the job worth keeping in human hands. His summary line: leverage comes from "everything we've experienced", not only from what engineers know.Learn it15 min · 5 steps
Key ideas
- Tacit knowledge
- Know how that a person uses reliably but cannot fully put into words, from Michael Polanyi's line that we can know more than we can tell.
- Proof by contradiction
- Glazner assumes humans add nothing, shows that this predicts a shrinking gap between engineers, and notes that the gap has not shrunk.
- Difficulty calibration
- Judging how much solution a problem actually needs, so it is neither overbuilt nor oversimplified.
Steps
- Read Glazner's essay on shahar.blog first, noting the argument structure before the examples.
- List the five places he says engineers keep leverage: problem definition, difficulty calibration, long term consequences, intuition and experience.
- Skim the HN thread and collect the two strongest objections to his argument.
- Map each leverage point to a step in your own agent workflow where you currently hand control to the agent.
- Self check: can you explain why a persistent gap between strong and average engineers is evidence that humans still add value?
Try it30 min · 5 steps
You need: Any coding agent you already use and one small task from your own backlog; No API key needed beyond your existing agent setup.Steps
- Pick a small, real ticket from your own project and copy its original wording.
- Hand the ticket text as is to your coding agent and save the plan or diff it produces.
- Separately, spend ten minutes writing down clarifying questions and the problem you think is really behind the ticket.
- Give the agent your reframed problem statement and save the second result.
- Compare both results on correctness, size of change and how well each would hold up in two years, and note which differences came from your framing.
Small angles to try
- Repeat with a ticket you think is trivial to test difficulty calibration.
- Ask a teammate to frame the same ticket and compare the three agent outputs.
- Ask the agent to list its own assumptions before coding and check how many match your questions.
-
Anime characters × image generators: IP guardrails tested in 14 models
ITmedia NEWS on Nov 9 covered a technical report by researchers affiliated with Sony AI and others that ran 1,809 prompts covering 201 IPs, from famous people and anime characters to superheroes, game characters and logos, through 14 image models. All 14 produced recognizable IP in at least 10% of cases and nearly half exceeded 40%, while the three open weight models, SD3 Medium, FLUX.1-dev and PixArt-Sigma, refused 0% of prompts. The paper itself was posted to arXiv on July 1, 2026 and reflects models as of March 2026, so the coverage is new but the research is not.
Heat · ITmedia NEWS access ranking #5, seen Nov 11What people foundCommercial refusal rates ranged from about 1% for Stability AI models to about 50% for Amazon Titan Image G2, yet indirect prompts that describe a character without naming it still produced recognizable IP about 27 to 28% of the time on average. Logos were blocked only 1 to 2% of the time except by DALL·E 3 at about 24%. Blocking by name alone does not hold up.Learn it15 min · 5 steps
Key ideas
- IP guardrail
- A filter in or around an image model that refuses or alters requests likely to reproduce protected characters, people or logos.
- Indirect prompt
- A request that describes a character's look without using its name, which slips past simple name blocklists.
- Refusal rate versus output rate
- How often a model declines a request is a different number from how often its outputs are actually recognizable as the IP.
Steps
- Read the ITmedia NEWS article first for the headline numbers and the model list.
- Open the arXiv abstract for 2607.02582 and note the test date and the split between three self hosted and eleven commercial models.
- Read the paper's method section on direct versus indirect prompts and the five IP categories.
- Compare the logo results with the superhero results and think about why providers treat them differently.
- Self check: why does an open weight model with 0% refusals put the whole filtering burden on the product that wraps it?
Try it30 min · 5 steps
You need: Python 3 on your own machine; no image model required; No API key needed.Steps
- Write a list of ten fictional characters you invent yourself, each with a name and a short visual description.
- For each, write one direct prompt that uses the name and two indirect prompts that only describe the look.
- Write a simple Python filter that blocks prompts containing any of the names on your list.
- Run all prompts through the filter and count how many direct and indirect prompts it blocks.
- Add a second rule set based on distinctive visual traits and measure how the indirect block rate and false positives change.
Small angles to try
- Add harmless lookalike prompts to measure how often the trait rules block legitimate requests.
- Swap the keyword rules for an embedding similarity check against your descriptions and compare.
- Translate the prompts into a second language and see whether the filter still catches them.
-
STE80 Humanizer: an agent skill for plain technical English
STE80 Humanizer is an MIT licensed agent skill that first strips 26 common AI writing tells, then applies 15 structure rules borrowed from ASD-STE100 Simplified Technical English. It ships with a dependency free Python linter, scripts/ste_check.py, and installs through the skills.sh CLI or as a Claude Code plugin.
Heat · Show HN 108 points and 41 comments on Nov 9; 12 GitHub stars and 3 forksWhat people foundThe author calls the README tests small, "a hint, not proof", and reports that the skill's edge was fidelity: it kept every fact and flagged a contradiction in the source. The README states that getting past AI detectors is not a goal; the aim is text people read easily.Learn it15 min · 5 steps
Key ideas
- ASD-STE100
- A controlled English standard from aerospace maintenance writing that limits vocabulary and sentence structure so manuals are hard to misread.
- Agent skill
- A packaged folder of instructions and scripts that an agent such as Claude Code, Codex or Cursor loads when a task matches it.
- Writing linter
- A script that flags style patterns in text the way a code linter flags patterns in code, as heuristics rather than verdicts.
Steps
- Read the ste80-humanizer README on GitHub first, focusing on the two passes and the install section.
- Skim the list of 26 tells and the 15 S rules to see which ones your own docs break.
- Read the Show HN thread for objections about whether a base model already does this.
- Look at scripts/ste_check.py to see how the heuristics are implemented.
- Self check: why does the author treat fidelity, not style, as the skill's main benefit?
Try it30 min · 5 steps
You need: Python 3 and Node.js with npx; Claude Code, Codex or Cursor for the rewrite step; No API key needed for the linter alone.Steps
- Clone https://github.com/Dodaios/ste80-humanizer into a scratch folder.
- Run the linter on one of your own files with
python scripts/ste_check.py README.md, pointing it at your file path, and save the output. - Run it again with
python scripts/ste_check.py --strict docs/runbook.mdon a longer doc of yours and compare the counts. - Install the skill into a test project with
npx skills add Dodaios/ste80-humanizer, or in Claude Code with/plugin marketplace add Dodaios/ste80-humanizerthen/plugin install ste80-humanizer@ste80-humanizer. - Ask your agent to rewrite the same doc with the skill, rerun the linter, and diff the two versions to check that no fact was lost.
Small angles to try
- Pipe a PR description through stdin with
cat draft.txt | python scripts/ste_check.py -before posting it. - Compare the skill against a plain prompt that only names ASD-STE100, as the author suggests.
- Add the linter as a non blocking CI step on your docs folder.
-
ReproBridge: refined artifacts lift agent ML reproduction to 92.6%
Google researchers define a refined reproducible artifact, made of cleaned code, environment setup, experiment launchers and a reproduction guide that records why each setting and repair was chosen, plus an agent workflow that builds one. On ReproBridge-Bench, 1,029 tasks from 387 experiments in 36 papers, mean reproduction success across four coding agents rose from 76.4% to 92.6% and downstream API spend fell 19.7% on average. The paper was posted Nov 5 and reached Hugging Face Daily Papers on Nov 10.
Heat · Hugging Face Daily Papers, Nov 10, about 30 upvotes and #6 that dayWhat people foundThe spread between models shrank from 21.6 to 3.9 points, with all four above 90%, so artifact quality mattered more than which model ran it. Removing code or environment setup hurt most in the ablation. Code and data are still under internal review and not yet public.Learn it15 min · 5 steps
Key ideas
- Refined reproducible artifact
- A repo package with fixed code, a working environment, launch scripts per experiment and a written guide to choices and pitfalls.
- Reproduction guide
- A document that records each ambiguity between paper and code, the chosen resolution, the reason and which tasks it affects.
- Ablation
- Removing one component at a time to see how much each contributes to the final result.
Steps
- Read the ReproBridge project page first for the four components and the worked examples.
- Open the Hugging Face paper page for the benchmark numbers and the ablation summary.
- Study the examples where a data loader bug or a wrong statistic changed results, and note what the guide recorded.
- Compare the 21.6 to 3.9 point spread with how much effort your team spends on model choice versus repo setup.
- Self check: which of the four components would a coding agent struggle most to recreate on its own, and why?
Try it30 min · 5 steps
You need: Docker on your own machine, one of your own repos with a runnable experiment or test suite, and any coding agent; No API key needed beyond your agent setup.Steps
- Pick one of your own repos and start a fresh container with no cached dependencies.
- Ask your coding agent to reproduce one result or test run from the README alone, and record time, failures and token use.
- Write the four components: fix the code paths it stumbled on, pin the environment in a Dockerfile, add a launch script per experiment, and write a short guide with known pitfalls.
- Add a single verification script, similar to the verify.sh entry point described on the project page, that checks the package runs.
- Rerun the agent in a fresh container and compare success, time and token use with the first run.
Small angles to try
- Remove one component at a time to run your own small ablation.
- Run the same task with two different agents before and after refining to see whether the gap narrows.
- Ask the agent to write the reproduction guide itself and check what it gets wrong.
-
Sage-Taiyi: Shanghai AI Lab's metacognitive AI scientist
Shanghai AI Laboratory's Sage-Taiyi is an agent architecture that monitors and revises its own views on evidence, assumptions and open questions, then uses those judgments to pick research targets and reusable reasoning methods. On Taiyi-Bench, 265 ideation tasks drawn from 50 papers across ten disciplines, it scores 54.0 overall versus 47.9 for AI Scientist-v2. In reaction condition optimization, its proposals raised a cobalt catalyzed carbonylation from trace yield to 84%.
Heat · Hugging Face Daily Papers, Nov 10, about 52 upvotes and #3 that day; research interest only, no HN traction foundWhat people foundIt ranked first on all eight Taiyi-Bench metrics, but the benchmark is the authors' own and the lab results are hard for engineers to check. The GitHub repo is public, though it currently holds a README and docs rather than a runnable package.Learn it15 min · 5 steps
Key ideas
- Metacognition in agents
- The agent keeps an explicit record of what it believes and how sure it is, and revises that record as evidence arrives.
- Historical rediscovery
- An evaluation where the agent gets the context before a known paper and is scored on whether it proposes the paper's idea.
- Open ended ideation
- Scoring research proposals for novelty and feasibility when there is no single correct answer.
Steps
- Read the abstract on the Hugging Face paper page first.
- Open the GitHub README and docs folder to see how the architecture's parts are described.
- Read the paper's Taiyi-Bench section and note how tasks are built from the 50 source papers.
- Compare the design with a plain plan and execute agent loop and list what state Sage-Taiyi keeps that the loop does not.
- Self check: why should a benchmark built by the same authors be read with extra caution?
Try it30 min · 5 steps
You need: Python 3 and access to any LLM you already use, local or hosted; an API key only if your chosen model is hosted.Steps
- Pick an open technical question from your own work, such as why a test is flaky.
- Run a plain agent loop that asks the model for the next step five times and save the transcript.
- Build a second loop that keeps a small JSON belief state with evidence, assumptions, open questions and a confidence for each.
- After each step, have the model update that state and choose the next step from the least certain assumption.
- Compare the two transcripts on how quickly each narrows down the cause and how often it repeats work.
Small angles to try
- Seed the belief state with a wrong assumption and see whether the loop revises it.
- Cap the belief state size and measure the effect on focus.
- Have a second model critique the belief state between steps.
-
Alibaba opens a Qwen4-Max preview with a 1M token context window
Alibaba opened a preview of Qwen4-Max, the flagship of its next generation Qwen family, on November 11, 2026. It accepts image and video input and handles up to one million tokens of context. Developers reach it through Alibaba's Token Plan subscription, and early use is also open in the Qwen app, Qoder, QwenWork and QwenStudio.
Heat · Reported by TechNode on Nov 11; a Hacker News post had 35 points and 2 comments while still youngWhat people foundTechNode's report gives no benchmarks, prices, API model id or open weight status, so treat Qwen4-Max as an early preview to evaluate, not a production dependency, and keep a stable fallback model in place.Learn it15 min · 5 steps
Key ideas
- Context window
- The maximum amount of text and media, counted in tokens, that a model can read in one request.
- Multimodal input
- A model that takes images or video alongside text and reasons over all of them together.
- Preview release
- Early access to a model whose behavior, limits and pricing may still change before general availability.
Steps
- Read the TechNode report on the Qwen4-Max preview to get the confirmed facts: context size, input types and access channels.
- List what the report leaves out, such as benchmarks, pricing and weights, and note that these are the questions to settle before adopting it.
- Estimate how many tokens your own largest document or codebase would take, to see whether a one million token window changes anything for you.
- Compare the access route, a Token Plan subscription and Qwen apps, with how your team buys other model APIs today.
- Self check: which three facts would you need before moving a production workload from your current model to Qwen4-Max?
Try it30 min · 5 steps
You need: A Qwen account with Token Plan access or the Qwen app, a few of your own documents or images, and a notebook or spreadsheet for results; the plan is a paid subscriptionSteps
- Pick five tasks you already run on your current model, for example a long document summary, a question over a screenshot and a code review.
- Open Qwen4-Max in the Qwen app or through your Token Plan access, following the access instructions in Alibaba's developer documentation.
- Run the same five tasks with identical prompts on Qwen4-Max and on your current model, using only your own data.
- For one task, paste a long document of your own and ask a question whose answer sits near the end, to check long context recall.
- Record answer quality, latency and any errors for both models side by side, and note which model you would trust for each task.
Small angles to try
- Feed it a short screen recording of your own app and ask it to describe the user flow.
- Repeat the long context recall question with the answer placed at the start, middle and end of the document.
- Check the same prompts again in a week to see whether preview behavior has shifted.
-
Val Town is winding down and will open source its code on Feb 1, 2027
Steve Krouse announced that Val Town is shutting down: new signups and upgrades ended on Nov 10, 2026, read only mode starts Dec 10, all other services end Jan 10, 2027, and the code is to be open sourced on Feb 1, 2027. SQLite and blob storage are not included in read only mode. Billing is paused, existing subscriptions keep working for free, and annual prepaid plans get partial refunds.
Heat · Hacker News, 374 points and 94 comments on Nov 10What people foundThe practical deadline is Dec 10, since SQLite and blob data are not covered by read only mode. Val Town publishes migration guides for Cloudflare, Vercel, Netlify and Render, mapping std/sqlite to D1 and std/blob to R2 on Cloudflare, and the announcement says today's LLMs are great at this kind of migration.Learn it15 min · 5 steps
Key ideas
- Val
- A small TypeScript program hosted on Val Town that can serve HTTP, run on a schedule or handle email.
- Read only mode
- A phase where existing code still runs but can no longer be edited, and here SQLite and blob storage are excluded.
- Platform migration
- Moving code, secrets, data, scheduled jobs and domains from one host to another without breaking callers.
Steps
- Read the Val Town post Winding down on blog.val.town and write the four dates on your calendar.
- Open the migration overview at docs.val.town/migration and pick one target platform from Cloudflare, Vercel, Netlify or Render.
- Read that platform's pages for code, SQLite, blobs and crons to see how each Val Town feature maps over.
- List every val you own and mark which ones use SQLite, blobs, crons, email or custom domains.
- Self check: which of your vals would lose data if you did nothing until Dec 10, and why?
Try it30 min · 5 steps
You need: Deno installed, your own Val Town account, a GitHub account, and optionally a free account on one target platform; no paid API key neededSteps
- Install the Val Town CLI with
deno install -grAf jsr:@valtown/vt, then runvtto log in. - Run
vt cloneon one of your own vals to copy its code to your machine, and commit it to a private GitHub repository as the Store code on GitHub guide suggests. - Follow your target platform's Migrate SQLite guide on docs.val.town to export your own val's SQLite data and load it into the new database.
- Follow the matching Migrate blobs guide to copy your blobs to the new storage service.
- Ask an LLM to port the val's HTTP handler to the target platform, deploy it, and compare its responses with the original val before Dec 10.
Small angles to try
- Port a cron val and confirm the new scheduler fires at the same times.
- Use the Redirect val.run URLs guide to keep an old public URL working.
- Port the same val to two platforms and compare the amount of code you had to change.
-
Modelplane publishes an open field guide to inference engineering
Modelplane, an open source project from Upbound, published version 0.7 of a free guide for platform engineers moving into LLM inference. It covers inference basics, a 12 part production section ending in a 15 item launch checklist, the tooling stack by layer, a case study and career advice. Numbers, prices and tool versions are stated as of October 2026.
Heat · Hacker News, 87 points and 8 comments on Nov 10What people foundTwo rules of thumb from the guide: Llama 3 70B at FP16 needs about 320 KB of KV cache per token, so one 128K token conversation needs about 40 GB; and a GPU costing $2.90 per hour that sustains 1,200 tokens per second works out to about $0.67 per million tokens. In the guide's case study, switching from vLLM to SGLang on the same two 8 GPU nodes was the largest single gain measured.Learn it15 min · 5 steps
Key ideas
- KV cache
- Stored attention keys and values for every token already processed, which grows with context length and often limits how many requests fit on a GPU.
- Cost per million tokens
- GPU price per hour divided by tokens served per hour, scaled to one million tokens.
- Inference engine
- The server software, such as vLLM or SGLang, that batches requests and runs the model on GPUs.
Steps
- Read the Inference 101 section of the Modelplane inference guide first.
- Work through the KV cache example yourself: 2 for keys and values, times 80 layers, times 8 KV heads, times 128 dimensions, times 2 bytes.
- Read the production section's launch checklist and mark which items your team already covers.
- Skim The stack section to place vLLM, SGLang, KServe and the gateway tools into layers.
- Self check: if you double context length for the same model, what happens to KV cache memory and to the number of concurrent users per GPU?
Try it30 min · 5 steps
You need: Python 3 for the math; optionally a machine with an NVIDIA GPU and vLLM installed for the serving part. No API key neededSteps
- Write a short Python function that computes KV cache bytes per token from layers, KV heads, head dimension and bytes per value, and check it gives about 320 KB for Llama 3 70B at FP16.
- Extend it to print memory for 8K, 32K and 128K token conversations and compare with the guide's 40 GB figure.
- Add the guide's formula, GPU cost per hour divided by tokens per second times 3600, times one million, and confirm $2.90 at 1,200 tokens per second gives about $0.67.
- If you have a GPU, serve a small open weight model with vLLM and vary
--max-model-lenand--max-num-seqsto see how they trade context length against concurrency. - Score your own setup against the 15 item launch checklist and list the three missing items you would fix first.
Small angles to try
- Recompute the KV cache numbers for an 8 bit KV cache and see how many more users fit.
- Lower
--gpu-memory-utilizationa little and note how the available KV cache shrinks. - Plug in your cloud provider's real GPU price and your measured throughput to get your own cost per million tokens.
-
Smartwatches × AI agents: Meta Muse lands on Apple Watch, tops Japan
On Nov 10, Meta added Apple Watch and Wear OS support to Muse, its personal AI agent, so users can give instructions by voice or text from the watch and check on progress. In the Apple Watch app, users tap Muse's avatar to give an instruction, and Impress Watch's tester saw replies shown as text on the watch. The same day, Muse from Meta was the number 1 free iPhone app in Apple's Japan chart and number 2 in the US chart.
Heat · App Store top free: number 1 in Japan, ahead of ChatGPT at 2, Gemini at 6 and Claude at 12; number 2 in the US; Apple feeds updated Nov 10 UTCWhat people foundThe new part is the watch client and the chart position: an agent on the wrist works through short instructions and text status updates, not long chat transcripts. Impress Watch tested it on an Apple Watch in Japan but does not state regional availability or watch OS requirements; Muse itself started in Japan around Oct 23, 2026.Learn it15 min · 5 steps
Key ideas
- Personal AI agent
- An assistant that carries out multi step tasks for a user over time instead of only answering one message.
- Asynchronous status updates
- Short progress reports the agent sends while it works, so the user can glance and move on.
- App Store top free chart
- Apple's ranking of free apps by recent downloads in each country, published as public RSS feeds.
Steps
- Read the Impress Watch article on Muse's Apple Watch and Wear OS support first.
- Open Apple's public top free feeds for Japan and the US and find where Muse, ChatGPT, Gemini and Claude sit.
- Think through what a watch screen changes: input is a tap and a voice line, output is a few lines of text.
- Compare that with how your own product reports long running work to users today.
- Self check: what would a good one line progress update look like for a task your agent runs for ten minutes?
Try it30 min · 5 steps
You need: A terminal with curl and Python 3; optionally your own iPhone and Apple Watch with Muse installed. No API key neededSteps
- Fetch the Japan feed with
curl -s https://rss.marketingtools.apple.com/api/v2/jp/apps/top-free/50/apps.jsonand save it to a file. - Write a small Python script that loads the JSON and prints the rank of every app whose name mentions Muse, ChatGPT, Gemini or Claude.
- Run it again on the US feed and print both countries side by side.
- Schedule the script once a day on your own machine for a week to see whether Muse's position holds after the launch spike.
- If you own an Apple Watch, give Muse a small task of your own from the watch and note how its progress and reply appear.
Small angles to try
- Add other country codes to the feed URL pattern and compare AI assistant ranks across markets.
- Draft the watch sized status messages your own agent would send for one real task.
- Track the top paid chart as well to see whether any AI apps appear there.
-
LingBot-Touch: one tactile model for three kinds of robot touch sensors
The paper Learning Heterogeneous Tactile Representation for General Dexterous Manipulation introduces LingBot-Touch, a tactile foundation model that learns one shared representation across piezoresistive, magnetic and visuotactile sensors. It outputs plug and play tactile tokens that the authors fed into Diffusion Policy, pi0.5 and LingBot-VLA, and they report better dexterous manipulation in simulation and on real robots across several hardware platforms. Robbyant released an inference package with Tiny and Small encoder checkpoints under the Apache 2.0 license.
Heat · Number 1 on Hugging Face Daily Papers for Nov 10, with 92 upvotesWhat people foundThe idea is sensor agnostic touch: a new tactile sensor can feed an existing policy as tokens without redesigning the policy stack. The paper page gives no benchmark numbers, and the README recommends attention based querying over mean or max pooling when reading the tokens downstream.Learn it15 min · 5 steps
Key ideas
- Tactile sensor
- A sensor on a robot finger or palm that measures contact, pressure or surface deformation.
- Tactile tokens
- Vectors that encode touch readings so a policy model can consume them like image or text tokens.
- JEPA
- A self supervised training setup that learns by predicting the representation of hidden parts of the input instead of raw values.
Steps
- Read the abstract on the Hugging Face paper page for Learning Heterogeneous Tactile Representation for General Dexterous Manipulation.
- Open the LingBot-Touch GitHub README and note what is released: encoder code, two checkpoints and sample data.
- Look at the output format: a latent tensor plus time, finger and position ids for every token.
- Read the paper's section on how tokens feed Diffusion Policy and the VLA models.
- Self check: why would a shared token format make it cheaper to swap a magnetic sensor for a visuotactile one?
Try it30 min · 5 steps
You need: Linux with conda, Python 3.12 and PyTorch 2.11; a CPU is enough, an NVIDIA GPU is optional; a Hugging Face or ModelScope account with access to the model repository. No API key neededSteps
- Clone the repository and create the environment with
conda create -n lingbot-touch python=3.12.13 pip=26.0.1 -yandconda activate lingbot-touch. - Install PyTorch with
python -m pip install "torch==2.11.0" --index-url https://download.pytorch.org/whl/cu130, then runpython -m pip install .andpython -m pip checkfrom the repository root. - Download the LingBot-Touch-Tiny checkpoint into
checkpoints/lingbot-touch-tiny/so it holdsconfig.jsonandencoder.pt. - Run
infer.pyon one bundled Sharpa sample with--input-format,--bundle,--input,--outputand--device cpu, following the README example. - Load the output with
torch.loadand print the shape oflatentalong withtime_id,finger_idandpos_xyz.
Small angles to try
- Run the XHand sample and compare token counts with the Sharpa sample.
- Swap in the Small checkpoint and compare inference time on CPU.
- Compare mean pooled features with a simple attention readout on the sample data.