Mentions

A friend built an AI brainstorming tool on the Markkula ethical decision-making framework, and it deliberately doesn’t decide anything A friend of mine made this and asked me to share it with people who teach or practise ethics. It is a Claude skill that applies the Markkula Center’s decision-making framework to a dilemma through five lenses: utilitarian, rights, justice, common good and care ethics. For each lens it gives a verdict and four options, from the completely ethical to doubling down, with a middle path that names who bears the cost. Its README says plainly that AI cannot be an ethical agent. It has no conscience and no accountability, and it can sound more certain than it should. The verdicts are prompts for your thinking, not rulings. The tool exists to surface stakeholders and angles you may have missed. Critique wanted: - Are the four options a useful way to see the range? - Does the “commit, don’t hedge” instruction produce false confidence? - What would you want a tool like this to refuse to do? Repo: g-v-s/markkula-ethics-framework-claude-skill ; Credit for the framework belongs to the Markkula Center for Applied Ethics at Santa Clara University. This project isn’t endorsed by them.

DiscImageStudio: burn visible artwork onto CDs, DVDs and Blu-ray discs

GeoPeek, a small macOS Quick Look extension for GeoJSON. I work with geospatial data and wanted to press Space on a .geojson in Finder and see a map instead of raw JSON. It also shows an attribute table and basic stats. serifsadi/geopeek

重装 Windows 一下午都在关推荐、卸预装、找设置关广告。 unattendedwinstall 应答文件挂到启动盘，装系统时自动跳过隐私询问和预装包，装完桌面就是干净的。 memstechtips/unattendedwinstall

Local LLM for DevOps: Ollama, vLLM & Kubernetes Tutorial --- title: "Local LLM for DevOps: Ollama, vLLM & Kubernetes Tutorial" published: true description: "Run local LLMs for DevOps with Ollama, Docker, and vLLM. Learn Kubernetes log analysis, Terraform review, and private AI infrastructure." tags: devops, ai, kubernetes, tutorial canonical_url: blog.naveedkumbhar.com --- Originally published on Naveed Ahmed's Engineering Blog. What if you could analyze Kubernetes failures and review Terraform configurations using an AI model running on your own hardware? That's one of the most useful applications of local LLMs for DevOps. Instead of sending every prompt to a hosted model API, you can run an open-weight model inside a controlled workstation or internal network. Two tools worth understanding are Ollama and vLLM. 1. Why Run an LLM Locally? Local inference can help teams: - Keep more operational data within their own environment. - Work without relying on an external inference service. - Build internal tools for logs, infrastructure code, and runbooks. - Control model selection, deployment, and inference infrastructure. - Evaluate whether fixed infrastructure costs suit their workloads. However, local deployment isn't automatically cheaper, faster, or more secure. You still need to account for compute resources, model quality, access controls, and operational maintenance. 2. Ollama vs vLLM | Feature | Ollama | vLLM | |---|---|---| | Primary use | Local development and simple inference services | Higher-throughput model serving | | Setup | Straightforward | More infrastructure planning | | Common environment | Laptop, workstation, private server | GPU-backed servers and Kubernetes | | API | Local HTTP API | OpenAI-compatible serving API | | Best starting point | Individual DevOps workflows | Shared team inference service | Both can be useful, depending on the workload. 3. Run Ollama with Docker For a CPU-based local test: docker run -d \ --name ollama \ -p 127.0.0.1:11434:11434 \ -v ollama_data:/root/.ollama \ ollama/ollama Pull a coding-focused model: docker exec ollama ollama pull qwen2.5-coder:7b Then query the local API: curl http://127.0.0.1:11434/api/generate \ -H "Content-Type: application/json" \ -d '{ "model": "qwen2.5-coder:7b", "prompt": "Explain Kubernetes CrashLoopBackOff and suggest diagnostic commands.", "stream": false }' The model needs to be downloaded before offline use. The first pull requires network access unless the model files are already available locally. For GPU acceleration, follow the Docker and Ollama documentation for your hardware. 4. Local Kubernetes Incident Triage A useful starting point is a read-only assistant that summarizes Pod failures. Collect the evidence: kubectl describe pod my-app-123 -n staging kubectl logs my-app-123 \ -n staging \ --previous \ --tail=100 After checking the output for credentials or sensitive information, send relevant excerpts to your local model. Ask it to identify: - Likely failure causes - Relevant log lines - Missing evidence - Commands to verify the hypothesis - Recommended next steps Treat the result as a troubleshooting suggestion, not a verified root cause. 5. Review Terraform Changes Privately Another useful workflow is reviewing an infrastructure pull request. For example: terraform fmt -check terraform validate git diff -- '*.tf' A local LLM can help explain the changes or identify suspicious patterns. But don't rely on an LLM as your only validator. Use deterministic checks, infrastructure policies, security scanning, and human review before merging or applying changes. 6. When to Use vLLM Ollama is a convenient starting point, but a platform team may need a centralized inference service for many applications. vLLM supports high-throughput model serving and an OpenAI-compatible API. For Kubernetes, consider: - GPU node allocation and model memory - Resource limits and scheduling - Authenticated ingress or an internal API gateway - Monitoring and request quotas - Model versioning and persistence - Network isolation and secrets handling Do not expose an inference endpoint publicly without an appropriate security boundary. 7. Production Safeguards Local inference still needs security controls. Use read-only Kubernetes identities where practical, sanitize logs, authenticate model endpoints, and isolate inference workloads. Review AI-generated changes before deploying them. A useful first milestone is an assistant that explains failures and proposes checks, not one that autonomously modifies production. --- Read the Complete Local LLM for DevOps Guide My full article covers model selection, Ollama Docker setup, vLLM on Kubernetes, low-resource hardware, and practical SRE playbooks. Read Local LLM for DevOps: Complete Guide --- Final Thoughts Local LLMs aren't a replacement for DevOps fundamentals. They're another tool that can make investigation, documentation, and infrastructure review more convenient when deployed with appropriate controls. Have you tried Ollama or vLLM for DevOps work? --- Written by Naveed Ahmed — DevOps & Platform Engineering Engineering Blog | Kubernetes Mastery | GitHub

@kevin_t_ngo @bot rec this /chalkboarding skill, it creates explainer figure that looks like a teacher drew it on a chalkboard, and animates it as if you were sitting in the class lilyzhng/chalkboarding

我这个项目本身就是用 gherkin + xstate 开发的，用 @poteto 的 statechart 画出状态图效果很好！[赞] kejun/squad t.co

用 Codex + Moli 跑了几个网页任务，聊聊「给 Agent 用的浏览器」 我在 Lexmount 团队，最近在整理 Moli 的实际使用案例，也让 Codex 配合本地 Moli 跑了几次网页任务：读产品官网、整理资料，以及操作待办演示页。把过程和碰到的限制整理出来，分享一下。 一开始我也没太理解：Chrome 已经能自动化了，为什么还需要一个面向 Agent 的浏览器？试下来，我更关心的是它怎么把网页交给 Agent，以及操作之后能不能读回状态。 先读取页面，再整理材料 Moli 是 Lexmount 开源的浏览器内核，可以本地运行，能执行 JavaScript、处理 DOM 和页面交互。它的设计是结构优先、按需渲染：先读取文字、链接和结构，需要位置或视觉信息时，再请求布局和截图。 这次整理文章时，Codex 用本地 Moli 1.1.19 读取了产品页和 Chrome 的 Headless 文档。例如： moli fetch --dump markdown --wait done --timeout 20000 https://browser.lexmount.cn/moli 这里的参数对应我这台机器上的版本，其他版本可以先看 moli fetch --help。 返回的 Markdown 保留了标题、正文和链接，Codex 可以继续从中摘出相关段落。不过，里面也有导航和页脚，拿到内容之后仍然需要筛选。 之前整理几个产品的资料时，还遇到过官网返回 403。那次没拿到正文，就明确记为失败，再找其他公开来源，没有让模型补写。 能点击之后，还要核验结果 另一次是 TodoMVC 待办演示页。Codex 通过 Playwright/CDP 连接本地 Moli，添加三条任务、勾选其中一条，再切换筛选。 我比较在意的是最后一步：刷新页面后，重新读取状态。结果是在同一会话里，三条任务还在，一条保持完成状态。 这只能说明那个演示页上的操作通过了检查，不能推出跨会话同步，更不能推出所有网站都兼容。但它让我看清了整个流程：Codex 安排步骤，Moli 执行网页操作，操作后的状态再交回来检查。 和普通浏览器的区别，要放在具体任务里看 Chrome 本来就支持无头运行和程序控制，读取 DOM 也不是 Moli 独有的能力。Moli 的特点主要在于围绕 Agent 的需求安排结构读取和渲染时机。这次没有做性能对照，所以不下“更快”“更省 Token”的结论。 本地 Moli 和托管的 Cloud Browser 也要分开看：前者是浏览器内核，后者是云端会话服务。复杂页面、特殊接口和 Playwright 的兼容范围，仍然需要逐项验证。 目前我觉得比较值得尝试的，是连续读取多个页面、整理字段和出处，或者提交操作后再检查状态的任务。从一个自己熟悉的小页面开始，比直接交给它一整套复杂流程容易判断效果。 项目：[github.com/lexmount/moli]( lexmount/moli) 中文介绍：[browser.lexmount.cn/moli]( browser.lexmount.cn) 在线体验：[Lexmount Playground]( browser.lexmount.cn)

Space Marine 2 VR Mod Alpha Release Hey all, here's the initial release of my Space Marine 2 VR mod: Joe975/space-marine-2-vr You can use the installer from here github.com/Joe975/space-marine-2-vr/releases/tag/…, or clone the whole project and make your own tweaks. This supports 3 main gameplay modes. First person motion controls with: - 2 handed gun control - Physical parry & block - Melee - Grenades, kinda 3rd person game camera swap puts you in VR following the character along like normal, standard controller play. 3rd person tabletop/diorama mode fixes the camera in world space, so you can cruise around hacking up tyranids while watching from above. Neat way to play but breaks my brain as soon as I turn towards the camera and forget how directions work. Camera mode is also supported and a ton of fun in first person with: - World scaling on grip with both hands - Finger & gaze tracking preserved Most of the game should be playable. I waded through a ton of bugs around menus/cutscenes/interactables so there's bound to be more but it at least lets you go from the hanger into missions/armoury/battle simulator etc. This has primarily been tested on an Index, with a very quick Quest 3 steam link check. Performance is pretty terrible all round, particularly in most missions (I suspect it's the sheer size of the levels). In mob-heavy fights I drop below 25fps on a 4090, so unless you have a beast of a PC or an iron stomach I recommend this as an interesting experience instead of a great way to play the game. 45 fps in the battle sim is cool though! Huge kudos to Saber for making such incredible game environments - even if it's a slideshow at times moving through them is so dam cool to experience in VR. Please have a go and leave some feedback! This is all open source and I welcome PRs or issues raised against the repo. If you're interested in how I did this or want to try it yourself for other games I've written up a guide and shared some agents skills that should skip a lot of the mistakes I made along the way.

Want a lighter Claude Code workflow? tempo is in alpha—try it on a real task and tell me what helps, breaks, or gets in your way 🙏 github.com/shrwnsan/vibekit-claude-plugins/tree/m… Compatible with the Agent Plugins v1.0.0 manifest Testing in Codex, Pi and Amp Code is ongoing

ABC482-Gのマトロイドが何かわからな過ぎたので、Cloudeのトークンを燃やして勉強ノートを作っています. 学ぶものが多すぎてまだマトロイドパリティまでたどり着いていませんが… github.com/suyasuyaTY/algorithm_note/blob/main/%E… github.com/suyasuyaTY/algorithm_note/blob/main/%E…

helperのexeはリポジトリに入れず、バージョンと SHA-256 をマニフェストに固定し、ビルド時に GitHub Releases から取ってきて照合し、electron-builder の extraResources でライセンスファイルとともにインストーラー・zip・Store 版に入れています。 ↓ mozc お試し版 github.com/kurouna/elecxzy/releases/tag/v0.23.1pr…

Stop writing the same instructions for your AI agent every time. Anthropic has published reusable Agent Skills you can explore and adapt. anthropics/skills

Large-scale LLM inference can be extremely expensive. What strategies would you use to optimize cost while maintaining acceptable performance? Full post · Follow me: LinkedIn · GitHub · Bluesky · X · dev.to · Facebook #AIInterview #LLMInference #GenAI

Built this Mod over the Weekend: An action wheel for builds, summons, and playable dragons. Would love some feedback Been working on this a lot over the weekend, and it’s finally coming together enough to show people. The idea is an action wheel that lets you change things during gameplay without constantly digging through menus. So far I’ve got it handling: - Weapons, dual-wield sets, builds, and spell selection - Weapon infusions and glowing body auras - Spawning allies or enemies, then taking control of your summons - Switching between player skins and altered move-sets, including mid-combat The dragon stuff is probably my favorite part. You can control an actual Ancient Dragon summon with its attacks and a working camera, or use a humanoid dragon form that keeps your normal weapons and combat. There are Stone, Golden, Obsidian, and Crimson versions with matching elemental auras and weapon effects. My bigger ambition is to build an Ancient Dragon questline with its own ending—starting with Yura and Agheel, exploring Dragon Communion, and eventually letting you choose between paths involving Placidusax, Bayle, or Fortissax. There’s so much dragon lore I’d love to explore through something playable. That part is still very much a work in progress. To give credit where it’s due: the summon system, dragon skins, and several movesets come from other modders. My work is mainly the wheel, custom features, and getting those pieces to work together and switch smoothly. This is an offline sandbox project, and there’s still plenty to iron out. Next I’d like to add easier boss rematches/arena fights and more movesets. I’m also working toward a contextual lore tab: nearby locations, bosses, NPCs, and quest steps could suggest relevant wiki entries and timestamped lore videos. This is my first mod project, so I’d really appreciate advice from people who’ve done this before. Anything you’d change about the wheel, or mods/tools worth looking into for compatibility? Also curious which features people would actually use most. Mod sources & credits - KAgeNoShu: NPC Spawner and Control - ApolloHoo: Lansseax, Golden Lansseax, and Fortissax costumes—the bases for the dragon forms, including my Crimson recolor - Clever and contributors: Clever’s Moveset Modpack - therealsqueam: Berserk – Guts Moveset - RashFever26: The Dragonlord Awakened - user12df1: Enhanced Dane’s Footwork and Dryleaf Whirlwind - AsherS / ashersheets: Elden Force—selected code adaptations and references - AlpinDale: Open Enemy Control, building on Yui’s earlier work Also thanks to the teams behind me3, fromsoftware-rs, and hudhook.

AgentFlow runs the ticket workflow around Claude Code, Codex or Copilot CLI. Your agent stays the same. For a while my process with coding agents went like this. Paste the Jira ticket into Claude Code and have it plan. Read the plan, push back, approve it. Open a fresh session to implement. Open one or two more to review the change, one for general code and one for security. Copy the findings back into the implementer. Keep track in my head of which round we were on and whether the same issue had come back. Then check the whole thing against the ticket once more before opening a PR. It worked, but I was the orchestrator, and I was doing it with copy and paste. AgentFlow is that same process, written down as code. I didn't want to build another harness Lots of agent frameworks bring their own agent loop, tool calling and prompts. I didn't want that. The CLIs are already good at writing code. AgentFlow launches the ones you already use (Claude Code, Codex, Copilot CLI, or any other CLI) in real terminal tabs, on your own login, with your own MCP servers. You can watch any of them or type into them. You can mix them per role too, like Claude Code planning and Codex implementing. AgentFlow never holds your model credentials. The workflow is deterministic Which stage runs next, when I have to approve, how many fix rounds happen and when to stop and ask me are all decided by ordinary code. No model is making those calls. Agents report back through a small CLI (`flowctl`) as JSON that gets checked against a schema, so nothing depends on scraping terminal output. Same agent results plus same decisions from me means the same path every time, and every step goes into an event log. How a task runs 1. An Architect agent reads the Jira ticket (or a prompt), looks around the code and asks me questions 2. I approve the requirements, and that exact version gets frozen 3. An implementer writes the code in its own git worktree, so my checkout is never touched 4. Code review and security review run in parallel on the same commit 5. Blocking findings go back to the implementer, for a capped number of rounds. If the same finding keeps coming back, it stops and asks me 6. The Architect checks the result against the requirements, and I sign off A side effect I like: since no model is doing the routing, tokens only go to the actual work. What it isn't - It's not autonomous. You approve twice per task, on purpose. - It's not a sandbox. Agents run as your user. Worktrees keep them out of your checkout, but that's not OS isolation. - The Windows desktop app is the easiest way in. macOS and Linux run from source for now. The video is a scripted demo agent on a sample repo, so it's faster than a real run. Repo (Apache-2.0): robse7en/AgentFlow Curious how other people run this loop. Are you still doing it by hand, or did you script something?

most agent harnesses ship a fixed toolset. need a new tool? wait for the vendor or fork it. deepseek open-sourced theirs and everything in it is a plugin. creator mode: describe a plugin in chat, it writes and installs it. MIT, 270k github stars. deepseek-ai/deepseek-harness t.co

@Waterdogyu Could you share the harness? We're building KITE at Memoket: dated facts with the original messages attached. I'd like to try those promise-tracking cases. memoket/memoket-kite

PCB REVIEW im start learning electronic and pcb design with kicad with help of AI, and i designed a copy PCB based on this project roepkefeller/air-quality-sensor from scratch. This board is all the same but has the uart jack. I want to ask that does pcb is ok to order for testing and soldering? The drc and erc seem has erro of thermal, and i dont know how to fix this. PLS help me to check. Very thanks.

Kendim de oyun yaparken kullandığım bir Piksel Sanat Motoru yaptım, isteyenlerle beraber geliştirebiliriz. Açık kaynak MIT: bilalfarukozdemir/pixel-art-engine Aktif kullanıyorum, çok tatlı işler çıkıyor repoda örnekler de koydum bakın da geri bildirim verin 🤲

How I make custom banlist in EDOPro I want to update YGO U50 banlist so might as well document the process. The process assume you have some knowledge in 1. SQL (structured query language) 2. A bit of coding especially reading hex number 3. spreadsheet. I used Libreoffice calc but excel should works too 1. we need to download the database off ProjectIgnis/BabelCDB. Download cards.cdb (click that file in the file list, then click "download raw") preview.redd.it 2. Download and install sqlite viewer if you haven't. I used sqlitebrowser.org for this example 3. Open the program and click "open database" preview.redd.it Make sure to set the filter to "all files" and open cards.cdb we download off github. preview.redd.it We should see something like preview.redd.it the database should consist of 2 tables, datas and texts. Text stores whatever text a card might spit out during game (name, effect, prompt etc) and datas store the cards attributes. The one we should pay attention for now is "type" column since this is a bit complex. Open ocgapi_constants.h in edo9300/ygopro-core. EDOPro and probably any sims using OCGCore store card types in bitflag of an integer. For example. Ten Thousand Dragon have type number 33554465. If you write it in hex it will be 0x2000021. Now we refer to card type on ocgapi_constants.h and look up 0x2000000, 0x20, and 0x1. preview.redd.it We can see that ten thousand dragon is "Special summon monster" (0x2000000), "Has Effect" (0x20), and a "monster card" (0x1). For our current usecase we want to allows 1. normal monster except pendulum normal monster and tokens (pendulum normal monsters with pendulum eff needs a bit complicated process I can execute in SQL, and the database stores token as normal monster) 2. effect monsters, trap and spell whose eff has 50 words or less 3. Any non eff fusion/synchro/xyz/link Click "execute SQL" and for our needs we paste these script select *,type&(0x1|0x20) as iseffect ,LENGTH(TRIM(dd)) - LENGTH(REPLACE(TRIM(dd), ' ', '')) as word_count from datas inner join ( select *, replace(desc,"* The above text is unofficial and describes the card's functionality in the OCG.",'') as dd from texts )texts2 on datas.id=texts2.id where ((type&(0x1|0x10)=17 AND name not like '%Token%' and type&(0x1000000)=0) -- normal monsters except token and normal pendulum OR (type&0x2!=0 and word_count<=51) --any spell with less than 50 words or (type&0x4!=0 and word_count<=51) -- any trap with less than 50 words or (type&(0x20)!=0 and word_count<=51) -- any effect monsters with less than 50 words or (type &(0x1|0x20)==1 AND name not like '%Token%' and type&(0x1000000)=0))-- any non effect monsters except token or normal pendulum We have 1 subquery to filter out EDOPro teams additional disclaimer text on certain card text "* The above text is unofficial and describes the card's functionality in the OCG.". Then join it into datas with above filters on top query. If you want to filter out certain cards you will need different query. preview.redd.it Copy the id and name to a spreadsheed then paste it on column A and C. Fill column B with number 3. preview.redd.it Right click on column C, format cells, click user-defined then put '--@' on format code. Click OK preview.redd.it Now block all those cells, ctrl+C then paste it on any text editor (vscode for example) preview.redd.it block a whitespace betwen columns, then ctrl+h to replace it with single space. preview.redd.it at the first 4 lines of the file add #[2026.11 TCG] !SHORT TCG 202610 $whitelist #unlimited preview.redd.it now save it to ProjectIgnis\repositories\lflists with any name but make sure the extension is .conf. preview.redd.it I'll explain on how to add normal pendulum on next post.

How to get up to 2x AI speed from your RTX GPU for FREE An RTX 3060 went from 27 to 51 TFLOPS in BF16 with one open-source Linux module 😳 The play: check your card > enable the module at boot > run your AI workloads > First steps - Go to: Zagitta/gpu-unlock - Check your card is on the supported list (RTX 20, 30 and 40 series, no RTX 50 yet) - Add the boot option so the module runs before the NVIDIA driver loads - Keep your normal driver, nothing gets patched or flashed - Run your benchmark again and compare > What you get - RTX 3060: about +89% BF16 matrix math - RTX 3090: up to +67% - RTX 4090: 2x peak tensor rate - Faster prompt processing, image generation and fine-tuning > The catch - Linux only for now, the Windows version is experimental - It speeds up AI math, not gaming or chatbot token speed - Real gains on a 4090 at stock power are closer to 12-34% - It's experimental and can void your warranty > What not to do - Don't expect more FPS in games - Don't run it on an unsupported card, it can fail to boot If you run local AI on an RTX card, this is the biggest FREE upgrade you'll get this year. Reply with your GPU and I'll tell you if it's supported. Bookmark this before you buy a new card.

چون اون گرافیسته با Aiاش بیکارم کرد، مجبور شدم چنتا از screensaver های ویندوز رو با raylib برای لینوکس درست کنم. mahanfr/screensaver t.co

Por si tenéis el CD o DVD del ordenador muerto de risa. Imprime imágenes en la parte de datos JiaFeiMiao-K-Cat/DiscImageStudio

USS でシェルを使い、ジョブを回して出力を整理する（IBM Z Xplore USS1） > Series: IBM Z Xplore — Fundamentals + Concepts | Challenge: USS1 | Beginner, Fundamentals | 60 minutes > Platform status: Completed (as of 2026-11-03) > Prerequisite: VSC1, FILES1, JCL1. Source: IBM Z Xplore official USS1 challenge documentation, plus my own practice. USS とは、一言でいうと USS（UNIX System Services）は、z/OS の中にある POSIX 準拠の UNIX 環境です。別のマシンではありません。すでに使ってきた z/OS と同じシステム API の上で動きますが、整理の仕方は UNIX 流で、ディレクトリの中にディレクトリ、ディレクトリの中にファイルがあります。FILES1 で学んだデータセットとメンバーという整理の仕方と並んで存在します。COBOL のプログラマーには両方が必要です。ソースや業務データはデータセットにあることが多く、スクリプトやモダンなツールは USS にあることが多いからです。 パート 1 — シェルに入る 1. VS Code でターミナルを開き、まず PowerShell から CMD に切り替えました。チュートリアルに、PowerShell で ssh を使うとパスワードが合っていても Permission denied になることがあると書いてあったからです。PowerShell のプロンプトで cmd と打ち、次に ssh z70127@204.90.115.200 と打ちました。 2. 最初のパスワード入力は Permission denied, please try again. と返ってきました。もう一度入力したら入ることができました。チュートリアルが間違っていたわけではなく、最初の入力が失敗しただけで、打ち直したら解決しました。 3. ログイン後のバナーには IBM Z Xplore learning platform、UNIX System Services 3.1 と表示され、集中管理されているツールは自分で入れ直さないこと、仮想環境を作らないこと、許可なく製品を入れないこと、商用のソースコードをアップロードしないこと、といった注意書きがありました。プロンプトの前には /etc/zprofile:338: FSUZ0155 no matches found: /z/z70127/.npm/_logs/*.log という行も出ましたが、何も妨げなかったので、そのまま進めました。 4. 最初の ls では tmp しか表示されませんでした。uss-setup を実行すると "Hi and welcome to the ZXPLORE UNIX System Service Challenges!" と返ってきて、もう一度 ls を実行すると、ホームディレクトリはチュートリアルの例よりもずっとにぎやかでした。animals.sh、assembler、cobol-check.config.properties、codeathons、directory1、dslist.py、movie-data.csv、members.py、odbc など、これまでの作業で残ったものが並んでいました。実際のホームディレクトリは教科書のきれいな例ではない、という当たり前のことを思い出させられました。 !image-43.png パート 2 — 移動と、ファイルの作成 5. pwd で自分の位置を確認すると /z/z70127 でした。cd ~ でホームに戻り、cd directory1 で入り、pwd で /z/z70127/directory1 を確認し、cd .. で 1 つ上に戻りました。 6. 次に自分のものを作りました。touch mynewfile と mkdir mynewdir を実行し、ls で確認しました。一覧には mynewdir と mynewfile が加わり、そのほか code1.py、code2.py、go2、hackathons、j2p、scramble.sh、secret.txt、test、zosmf なども並んでいました。この時点では削除せず、後の du の出力でも両方とも 0 と表示されました。空のファイルと空のディレクトリなら、当然の結果です。 !image-44.png パート 3 — Zowe でも同じファイルを見る 7. シェルは入口の 1 つで、Zowe はもう 1 つの入口です。Zowe Explorer の USS ビューで、フィルターを自分のホームディレクトリ /z/z70127（すべて小文字）に設定しました。ターミナルと Zowe で同じホームディレクトリが見えることが、ここでの要点でした。USS のファイルはターミナルの中に閉じているわけではなく、データセットだけがシステムの中身を見る方法でもありません。このチャレンジの残りは、学ぶべきはコマンドを打つこと、確認に使うのはビューだという理由で、ターミナルで進め、Zowe で確認しました。 !image-45.png パート 4 — 秘密の解読 8. 課題は、/z/public/secret.txt に対して scramble.sh を実行し、解読できる回転数を見つけることでした。このプログラムは第 1 引数にファイル、第 2 引数に回転数をとり、小文字にしか効きません。数が合えば解読した出力が、合わなければ意味不明な文字列が出ます。 9. 試した順番は 13、7、3、12 でした。どれも "Processing..........Done!" の後に読めない文字列が出るだけでした。5 回目の 17 で、"congratulations! you unscrambled the message in the uss challenge!!" と出ました。方法はこれだけです。近道はなく、4 回の間違いを捨て、1 回の正解を残しただけです。数を試し、出力を読み、「これではない」と判断すること自体が作業であって、作業の前の失敗ではありません。 !image-46.png パート 5 — リダイレクトと、ファイルをきちんと作ること 10. リダイレクトは、> と >> が理論でなくなる場所です。成功したコマンドをもう一度実行し、末尾に > ussout.txt を付けて、出力を画面ではなくファイルに入れ、cat ussout.txt で確認しました。その後は上書きせず、追加だけをしました。まず du -ak >> ussout.txt、次に date >> ussout.txt です。この違いは重要で、ステップ 11 や 12 で上書きしてしまったら、解読したメッセージが消えてしまいます。 !image-47.png 11. du -ak はキロバイト単位のディスク使用量を、カレントディレクトリとその下すべてについて（-a）一覧にします。自分のホームディレクトリは合計 694 で、一覧にはこれまでのチャレンジの残り、作ったばかりの 0 サイズの mynewfile と mynewdir、そして ussout.txt 自体の 8 が含まれていました。最後の cat ussout.txt では、解読したメッセージ、次に du の出力、最後に日付 Tue Nov 3 00:37:34 CST 2026 という正しい順番で並んでいました。 !image-48.png パート 6 — 検証 12. ZXP.PUBLIC.JCL から検証ジョブ CHKUSS1 をサブミットしました。Jobs ビューには @USS1(JOB02768) - SOW1 - CC 0000 と表示されました。次にプラットフォームに Challenge Complete のオーバーレイが出て、"Great work — your progress has been recorded." と表示されました。これが証拠で、自分の言葉だけではありません。 !image-49.png !image-50.png COBOL にとってなぜ重要か USS がなければ、COBOL のプログラマーはシステムの半分にしか入れません。データセットにはソースとデータがありますが、ファイルを動かし、スクリプトを実行し、ディスク使用量を確認し、リダイレクトでコマンドをつなげるのはシェルです。次のチャレンジ Code も USS の中で Python を使うので、これは寄り道ではありません。次に進むための作業環境そのものです。最も持ち帰ったのは、個別のコマンドではなく、習慣です。コマンドを実行し、実際の出力を読み、それから次に何をするか決める。スクランブルの試行も、> と >> の区別も、まさにその習慣を報いるものでした。 次回：Code — z/OS のメインフレーム上で直接 Python を使ったプログラミングの基礎（120 分）。 個人学習ブログ原文：CobolNote#6

Built at the NEAR Hackathon (AI Security & Defense track): NearGuard checks a payment counterparty before an agent signs — allow / warn / block with reasons — and stops a prompt-injected payment before signing. @NEARProtocol #NEARHackathon MarwanWidjaya/nearguard t.co

@ellyoott ありがとう これでいい？ github.com/ppkk12/fortnite-automatic-lap/releases…

@KelvinAdithya @SlushWallet The prompt generator gives people a starting palette while per-icon tweaks leave room to vary it. This fits HOL's Agent Skills catalog. If you'd like to list it, the guide is here: github.com/hashgraph-online/awesome-ai-plugins/bl…

Streaming Markdown in Vue: Rendering LLM Tokens Without Flicker Every AI chat UI hits the same wall. Tokens arrive over SSE, you do content += token, and a computed property calls marked.parse(content) again. For a short answer it works. For a 3,000-token answer with a table, a fenced code block, and a Mermaid diagram, the message area re-renders dozens of times per second. The result is flicker, jumping scroll position, diagrams that vanish until the closing fence arrives, and a main thread that stays busy long after the stream ends. I maintain markstream-vue, a streaming Markdown renderer built for exactly this case. This post walks through why the usual renderer pipeline struggles with token streams, and what a streaming-first renderer does differently. The problem isn't Markdown. It's the timing. marked, markdown-it, and react-markdown are excellent at rendering a finished document. Their contract is: give me valid Markdown, I give you HTML or a component tree. An LLM stream violates that contract constantly. Mid-stream you have: - an unclosed **bold run, - a code fence with no closing backticks, - half a table, - $$ math with no closing delimiter, - a Mermaid block that only becomes parseable at the very end. If you re-parse and re-render the full string on every token, you pay for the entire document each time. If you pass partial Markdown straight to a finished-document renderer, you get either broken output or a loading state that flashes on every chunk. What streaming-first actually changes Markstream keeps the incomplete state as a first-class idea instead of an error case. 1. Two render modes for two different UX goals | Mode | Config | Best for | | --- | --- | --- | | Virtual window (default) | max-live-nodes="220" | Long answers, docs, chat history — steady scrolling and memory | | Incremental batches | max-live-nodes="0" | The "typing" feel — new content flows in small slices | The virtual window keeps a sliding set of mounted nodes, so a 10,000-block document doesn't mean 10,000 live DOM nodes. Incremental mode disables virtualization and renders in small batches, which is usually what you want for a chat bubble that is actively growing. 2. Heavy blocks settle progressively Mermaid and KaTeX are optional peers, not bundled dependencies. When they are installed, diagrams can render as soon as the syntax is complete, and update when later chunks change them — rather than blocking the whole message until the stream ends. Code blocks are the other hot spot. In v2, the enhanced code surface comes from the optional stream-diffs peer; without it you get a plain <pre> fallback. That keeps the default install small and lets you opt into the heavier diff/highlighting surface only where you need it. 3. final is a real state, not a guess Most flicker bugs come from not knowing whether the stream is done. Markstream takes a final prop. While it is false, the parser assumes unfinished constructs are still loading. When it flips to true, the renderer invalidates the streaming cache and reparses with final semantics, so a trailing $$ or an unclosed fence doesn't stay stuck in a loading state forever. Quick start pnpm add markstream-vue <script setup lang="ts"> import MarkdownRender from 'markstream-vue' import 'markstream-vue/index.css' </script> <template> <MarkdownRender :content="markdown" /> </template> That is the whole integration for a read-only surface. For an AI chat message, add the stream state: <script setup lang="ts"> import { onBeforeUnmount, ref } from 'vue' import MarkdownRender from 'markstream-vue' import 'markstream-vue/index.css' const content = ref('') const final = ref(false) let source: EventSource | undefined function start(url: string) { source = new EventSource(url) source.onmessage = (event) => { content.value += event.data } source.addEventListener('done', () => { final.value = true source?.close() }) } onBeforeUnmount(() => source?.close()) </script> <template> <MarkdownRender :content="content" :final="final" :max-live-nodes="0" :render-batch-size="16" :render-batch-delay="8" :fade="false" :typewriter="true" /> </template> :max-live-nodes="0" selects incremental mode. The batch props control how much work is allowed per frame, which is the difference between a smooth typewriter effect and one that jumps in 2 KB chunks. If you already parse Markdown on the server or in a worker, you can skip client-side parsing entirely and pass typed nodes: import { getMarkdown, parseMarkdownToStructure } from 'markstream-vue' const md = getMarkdown() const nodes = parseMarkdownToStructure(source, md, { final: true }) <MarkdownRender :nodes="nodes" /> That is also the escape hatch for SSR and hydration: parse once on the server, serialize the nodes, and keep streaming later chunks on the client. Putting Vue components inside Markdown This is the part that made the library worth building for me. A chat answer often needs a callout, a button, or a chart — something that isn't expressible in plain Markdown. setCustomComponents maps a marker to a Vue component: import { setCustomComponents } from 'markstream-vue' setCustomComponents('chat', { CALLOUT: () => import('./Callout.vue'), }) Then emit the marker in Markdown and scope the renderer: [[CALLOUT:warning title="Heads up" body="This response was truncated."]] <MarkdownRender :content="content" custom-id="chat" /> The same mechanism handles custom HTML tags such as thinking, with the original payload kept on the node. When not to use it I would rather you pick the right tool: - Static docs, blog posts, changelogs — marked or markdown-it is simpler and smaller. There is no stream to optimize. - You need every ecosystem plugin — the unified/remark ecosystem is hard to beat for finished documents. - You want zero optional peers — Markstream works, but Mermaid, KaTeX, and the enhanced code surface are opt-in for a reason. The value shows up when Markdown is still changing while the user is reading it. That is a different rendering problem from "render this file". Other frameworks The same core is available outside Vue: markstream-react (React / Next.js), markstream-solid, markstream-svelte, markstream-angular, markstream-vue2, plus stream-markdown-parser for parsing without a UI layer. Try it - Live Vue playground: markstream-vue.simonhe.me - Shareable repro / test page: markstream-vue.simonhe.me - Docs: markstream.simonhe.me - GitHub: Simon-He95/markstream-vue - npm: npmjs.com If you have a streaming UI that flickers, the test page lets you paste a repro and share the URL — that is the fastest way to show me the bug. Prefer the short version first? I wrote an earlier, shorter post on why streaming AI chat needs a renderer for incomplete Markdown: dev.to --- Disclosure: I am the maintainer of markstream-vue, so read the comparison with the usual grain of salt. The library is MIT-licensed, and the optional peers are the only paid-in-bundle-size trade-offs.

Hosted Code Scanners Ran Attacker Code, and 5 of 20 Leaked Credentials: Raphael Karger at Global AppSec USA 2026 When Raphael Karger tested 20 hosted code-scanning platforms, five exposed sensitive worker data or credentials, four of them through code execution and one through a file read. Hosted security scanners pull in customers' repositories and analyze them. Analysis is not always read-only, because a config file can load executable checks, a package install can run lifecycle scripts and a Ruby gemspec is evaluated as code. Unsafe symlink handling can also expose files outside the repository. In December 2025, someone submitted a repository to ZeroPath's own scanning platform containing a symlink to /proc/self/environ, a script built to phone home and a dependency pointing at an attacker's server. In his Global AppSec USA 2026 talk, "Assume Code Execution: Securing Multi-Tenant Code-Ingestion Platforms", on Thursday, November 5 at 3:30 p.m. in Grand Ballroom C, Raphael Karger walks through an architecture for a scanning service that assumes submitted code will run. Speaker: Raphael Karger, Co-founder and CTO, ZeroPath In the 20-platform test, callbacks showed which payloads made outbound requests. Follow-up tests then confirmed code execution or file access, along with the data exposed. The architecture starts from what the service must do. It separates analysis from the credentials used to fetch code or publish findings. It then limits file access, network access and resource use. Karger also covers what an attacker can still do within those limits. He shows how to test that required scans still work while forbidden access fails, using evidence collected outside the scan worker. Build Canaries, an open-source tool under the MIT license, generates test repositories for checking your own service. Raphael Karger is co-founder and CTO of ZeroPath, an AI-native application security company that was an RSAC 2026 Innovation Sandbox finalist. He was previously a security engineer at Google and a consultant at Bishop Fox. He leads ZeroPath's core product and security research. ZeroPath's research team has disclosed vulnerabilities in curl, FFmpeg, sudo and the Linux kernel. He presented the scanner research at Black Hat USA 2026 as "Scanning the Scanners." According to the slides, custom Checkov checks gave remote code execution at two vendors, while a symlink to /proc/self/environ leaked a payment processor key at another. Exposed items included cloud IAM credentials, GitHub tokens, Docker Hub tokens, a production database connection string and an RSA signing key. Dark Reading reports that Build Canaries ships 349 validated payloads. To go deeper on the topic, start here: - Scanning the Scanners (Black Hat USA 2026 slides) - When AppSec Scanners Become a Supply Chain Attack Vector (Dark Reading) - Build Canaries (GitHub) - ZeroPath at Black Hat USA 2026 Teams that build hosted scanners, CI services or any platform that ingests customer code will see what a hostile repository can reach. What credentials can a process reach on the workers where your third-party scanners analyze your code?

تعريب لعبة Luigi's Mansion 3 السلام عليكم، تعريب كامل للعبة Luigi's Mansion 3 على نينتندو سويتش رابط التعريب: github.com/OSAMAxALHARBI/LuigisMansion3-Arabic/re… طريقة التثبيت (Ryujinx أو Eden أو Yuzu): 1. حمّل luigismansion3-arabic.zip من صفحة GitHub وفك ضغطه. 2. في المحاكي: كليك يمين على اللعبة، ثم Open Mods Directory في Ryujinx، أو Open Mod Data Location في Eden وYuzu. 3. اسحب مجلد ArabicTranslation إلى المجلد اللي انفتح. 4. شغّل اللعبة. المتطلبات: اللعبة مع التحديث 1.4.0، ولغة النظام English. لإزالة التعريب: احذف مجلد ArabicTranslation. صفحة اللعبة في موقعي: iosamai.com ولعبة Luigi's Mansion 2 HD شبه جاهز تعريبها وقادمة قريبا كل تعريباتي في موقعي: iosamai.com المعرّب: Osama

@dhruvarora_237 @imharikumaran Guard command coverage could target the `npx ramoira init` write. If you want to contribute it, this guide covers the source, fixture and trust binding: github.com/hashgraph-online/hol-guard/blob/main/d…

今天给喜欢折腾 AI Bot 的朋友分享一个项目：OpenMausBot。 如果不想把所有机器人都绑在单一平台上，可以看看这种开源方案。 它尝试让用户自己管理 Bot、模型和工具。 想搭建个人 AI 自动化工作台的，可以研究一下。 milind-soni/OpenMausBot

给技术小白用的工具， 大白话解读GitHub项目仓库。👇 laohai9527/github-plain-reader 知道GitHub牛逼，但像我这种小白打开GitHub界面后，是会懵逼的，看不懂，看不懂，还是看不懂， 因为自己的需求做了个给技术小白用的大白话版解读GitHub的小插件，体验好多了， 流程：下载 → 上传浏览器插件 → 添加DeepSeek APIkey → 复制GitHub仓库链接 → 解读。 非常丝滑，因为有AI功能，还能继续对话，而且对话内容支持一键跳转到各种AI Agent工具！ 丝滑的交接到你的workbuddy，Codex，Claude code 上！

One photo in. One holo trading card out. Card Forge reads your photo, writes your card, paints you as the hero, and builds a 3D glass card you can spin. Open weights only: Qwen3-VL, Qwen Image Edit and BiRefNet on @ComfyUI. sshiao/card-forge #OpenSourceHiggsfield t.co

@flaneur2023 我给rime包了一个管理配置和数据的服务，不过我自己也没用过几次，哈哈 codepiano/rime-studio

good work but please point your agent at their released logs (RikiyaT/lm_understand-logs) before making any conclusions. thank me later. 🙏

DeepTutor, taken apart: its core trick fits in one skill, so why did 54,000 people star the platform around it? --- title: DeepTutor, taken apart: its core trick fits in one skill, so why did 54,000 people star the platform around it? published: true date: 2026-11-03 06:49:00 UTC cover_image: dev-to-uploads.s3.us-east-2.amazonaws.com tags: canonical_url: blog.go5.si --- An open-source AI tutor out of the University of Hong Kong had 1,369 stars four days after its repository was created. Ten months later it is at nearly 54,000, and more than 5,000 of those arrived in the last four days alone. On October 28 I installed its v1.7.0 release and took it apart. Before the write-up was finished, v1.7.1 landed on October 31. This is a long one, and the verdict needs the length to be fair. Here it is up front: DeepTutor’s core, a structured record of what you got wrong and a loop that quizzes you from it, is the team’s own engineering. It is also, in 2026, the one part of the product a single agent skill can copy. What a skill cannot copy is everything built around that core, and the 54,000 stars are mostly for the surroundings: a platform, a delivery shape for people who do not live in a terminal, and a lab that knows how to launch. If you are a technical user studying alone, you may need none of it. That distinction is the whole piece. !A robot tutor proudly hugs an enormous ledger of graded papers covered in red crosses and green ticks, while the student stares, and three little memory clouds shrug above them The honest baseline: what a chat box already remembers Any serious test of a tutor’s memory has to start with what the ordinary chat box does today, because it does more than it did two years ago. Inside one conversation, the model sees what you said earlier in that same conversation. That part was never in doubt. Across conversations, the big platforms have all added a memory layer of their own. ChatGPT keeps saved memories, facts it stores about you, and on top of that it can reference your past chat history when it answers. Claude’s memory is on by default on its consumer plans and stores what it learns as topic files you can open, read and edit. Gemini has a Memory setting that learns from your past chats. The fine print differs by vendor: Claude leaves sensitive topics out by default, and Gemini’s version only learns when Keep Activity is on. So the picture of the chat tutor as a goldfish that forgets you between sessions does not survive contact with 2026. What that memory is not, though, matters just as much. OpenAI’s own help page puts it plainly: memory does not retain every detail from every conversation, and ChatGPT decides which available information is relevant. What the platforms keep is the kind of thing a good assistant keeps: your preferences, your projects, the level you are roughly at. A study record is finer than that. It is not “this person is weak at physics.” It is: on these dates you attempted these problems, you dropped the sign in the lens formula twice and mixed up image distance once, and last Tuesday you finally got three of that type right in a row. A quiz engine can compute with a record like that. A paragraph of preferences cannot drive it, because the individual events were never written down anywhere. The core: a record a quiz can compute with DeepTutor, from the DeepTutor team at the University of Hong Kong’s data science institute, builds that fine-grained record on your own machine. The record has three layers. The bottom layer keeps the raw record of every interaction, append-only, never rewritten, the way an accountant keeps the original receipts. The middle layer distills those records into facts about you, which concepts you keep mixing up, which problem types keep tripping you, each fact pinned to the interactions it came from, so a wrong conclusion can be traced back and removed. The top layer pulls those facts together into one learner profile. !How DeepTutor works: it keeps a structured record of what you got wrong, quizzes you from that record, and spaces the review by knowledge type On top of the record sits a working loop. When you ask it to work a problem, it classifies what kind of problem it is, works it, and checks its own result before showing you. Then it turns around and quizzes you, pitched near your current level, and the wrong concept in your answer gets written back into the record, which shapes what it asks next time. A scheduler decides when old material comes back for review, with different spacing for different kinds of knowledge. Solve, quiz, write it down, resurface it later. That loop, running on that record, is the core of the product, and it is the part most chat tutors do not have. !DeepTutor's core in detail: the three-layer record — raw interactions distilled into facts, facts pulled into one learner profile — and the loop that runs on it: solve and self-check, quiz at your level, wrong concepts written back, old material resurfaces on a 0/1/3/7/14/30/60-day schedule The core is also the part a skill can copy Everything in the previous section is a file format plus a set of instructions. Give a modern agent a skill file that says “keep the record in these three layers, quiz from it, resurface mistakes on this schedule,” point it at a folder on your machine, and it will run a version of the same loop. Spaced repetition is a table of intervals and a queue of due items; the scheduler in this codebase is sensible engineering, not magic. For one technical user, studying alone, in a tool they already live in, the skill version covers most of what the core does. I have read the counterargument in the project’s own materials and in the coverage of it, and none of it answers this point, because the point is correct, about the core. So if the core fits in a skill, the obvious question is what the other roughly 330,000 lines of Python and 330,000 lines of TypeScript in this repository are for. That is where the actual product lives. What surrounds the core !DeepTutor at a glance: you meet it through the web app, the desktop app or a chat-app partner; material flows in on the left through four parsers and eight retrieval pipelines, finished textbooks, videos and reports flow out on the right, the learning-engine core sits in the middle over single-machine SQLite storage, the multi-user layer for schools wraps around everything, and the model is plugged in from below Real study material is ugly: scanned PDFs, two-column papers, formulas, tables, Office files old enough to vote. DeepTutor ships four pluggable document parsers as separate packages, so a file that defeats one engine can be tried against another, and its indexing pipeline can resume from the chunks it already processed when a build dies halfway instead of starting over. Behind that sit eight swappable retrieval pipelines, not one: vector search, structure-based page retrieval, graph-based variants, an offline Wikipedia backend, each selectable per knowledge base, with query rewriting in front of them. A skill can wire up a parser and a vector store for your clean files. The fourth weird file from a real course is where the hand-built version starts to break, and this project has clearly been broken on those files and fixed, repeatedly; its issue tracker carries exactly those bugs from exactly those users. !DeepTutor's feeding pipeline: real course files go through four pluggable parsers, get chunked and indexed with resume, then eight swappable retrieval pipelines fetch the right pages when you ask The record and the loop feed a set of output surfaces that each took real building. There is an interactive textbook compiler: lessons assembled from blocks, concept graphs, figures, animations, quizzes, flashcards, interactive elements, exported as a book. There is a video lesson pipeline that writes a lesson, narrates it with text-to-speech and renders it in a Remotion project with layout checks. There is a math animation agent built on Manim that renders an animation, looks at the result, and retries when the layout is wrong. An audio overview turns your material into a spoken summary. A research mode rewrites the question, breaks it down, gathers sources including arXiv papers, and writes up a report. The notebook was rebuilt around pages and blocks, with an editing assistant whose changes only land when you accept them. None of these is the core. Every one of them is a reason a different kind of user shows up. !What DeepTutor produces: an interactive textbook compiler, video lessons, Manim math animations, an audio overview, and a four-step research mode DeepTutor runs a “partner” system: a persistent tutor companion that lives inside 18-plus chat channels, WeChat, QQ, DingTalk, Feishu, WeCom, Telegram, WhatsApp, Slack, Discord and more, including partner group chats. A student can study inside the chat app they already use, and the partner can be present between sessions in a way a conversation window is not. A skill is session-shaped; it exists while you are talking to your agent. A resident companion on eighteen networks is a service, with connections to keep alive and messages to push, and that is a different species of software. The multi-user layer is institutional: accounts, guardian relationships between parents or teachers and learners, per-resource permissions covering books, knowledge bases, models and skills separately, audit logs, device credentials, personal model quotas. Thirty-eight test files cover just this layer. A school does not adopt a folder of markdown and a prompt; it adopts accounts and permissions and an audit trail, or it does not adopt at all. Its provider layer covers the usual API vendors and local models through Ollama, and also the subscription kind: Copilot, Codex and Claude Code through device-login OAuth, so a user can run it on a subscription they already pay for instead of a metered API key. The desktop app for Mac and Windows, officially still a preview, is a double-click install with a bundled runtime that starts the whole web interface without the user touching a terminal, a Python install or Git. The interface speaks ten languages, with consistency checks for the translations in its build pipeline. The whole repository carries 905 test files. You can argue with the taste of any of this. You cannot call it a wrapper. !How DeepTutor deploys: one folder with SQLite on your own machine, the multi-user layer a school buys on top, subscription or API-key model access, and the single-machine storage ceiling The neatest evidence of where skills actually sit in this architecture is in its own service layer. DeepTutor has a built-in skill registry, its own hub for installable skills, and the repository itself ships a SKILL.md whose entire job is to let an external agent drive DeepTutor through its command-line interface. In this architecture, skills are a plugin layer on top of the platform, and one of them is literally the remote control for the platform. The criticism “a skill could do this” gets the dependency backwards. Can you actually use it? I installed it, took the install apart, read the code and the release notes, and read the team’s paper. I did not connect a model and study with it for a month. Nobody should sell you a verdict on long-term learning from an install test, including me. !What using DeepTutor actually costs: install size, setup friction, and the ongoing model calls behind the free download A bare install of the v1.7.0 core took about two and a half minutes and 190MB on disk, dependency check clean. The core is chat, a command line and an SDK. The web interface everyone screenshots is a separate, heavier install. My install came with 25 module folders, solving, quizzing, the knowledge base, memory, the notebook among them. And the first thing the software did was fail me: its own health-check command, doctor, reported two failures, no chat model configured and no embedding model configured (the one that turns your materials into searchable numbers). It tells you what’s missing instead of performing “all set,” which I respect, but it also states the terms plainly. Out of the box, DeepTutor does nothing until you bring a model, an API key and a budget. That was the core install, by hand, in a terminal. The desktop package exists precisely because most of its intended users would stop at the first of those steps. The running costs are structural, not incidental. The software is free, Apache 2.0. It does not bring a model. Every question, every check, every quiz is a real call to a real model, and some of the spending happens where you cannot see it: after a session, a further call distills what happened into the record, another call may rewrite your next question against that record before it is asked. The record remembers better the more it is maintained, and maintenance is metered. Meanwhile the upkeep above the software never stops. In 308 days the project shipped 89 releases, one every three and a half days on average, 15 of them in September and October alone, and v1.7.1 arrived three days after the version I installed, adding desktop preview apps and four more interface languages. The 1.7.0 upgrade notes also carry a trap that the 1.7.1 notes repeat word for word: if an old command-line package is still on your machine, uninstall it first, or you may pay for the new version and still be running the old one. I have not installed 1.7.1; everything hands-on in this piece is 1.7.0. And the steering wheel sits mostly in one pair of hands. GitHub counts 3,205 contributions across 268 accounts; about 1,900 of them, roughly six in ten, are one person’s, more than sixteen times the runner-up’s 116. There is a real tail behind that person, 49 accounts with five or more contributions, so it is not a one-person repository. If that one person stops, the three-and-a-half-day release rhythm stops with them, and your upkeep problem becomes a survival problem. Why it is actually hot None of the above fully explains 54,000 stars, including the near-vertical part: 1,369 stars in the first four days, and over 5,700 in the four days before I wrote this. Products do not get that shape from quality alone. The curve is a staircase, and staircases have mechanics. The first step is the name on the door. HKUDS is the Hong Kong University lab behind LightRAG, a retrieval project with 40,000 stars of its own. English coverage of DeepTutor name-checks the lab’s track record in the opening lines. A new project from a lab with a hit does not start from zero attention; it starts from a subscriber base. Note what the backing is and is not: it is a respected lab’s brand, a paper and a project site. I found no university-level announcement behind it, and the launch did not need one. The second step is the cadence feeding the chart. A release every three and a half days keeps putting the repository in front of GitHub’s trending page, and trending puts it in front of the next wave of stargazers. The single biggest day, over 2,300 stars on October 29, came right after v1.7.0 shipped modular installs and the desktop preview. The release rhythm is the marketing department. The third step is the category it sits in. One reviewer of the launch put it bluntly: it is a signal about self-hosting, not about tutoring. In a market where the big chat apps tutor for free inside their own clouds, “your materials, your record, your machine, models you choose” is a position a large crowd wants to endorse, and starring is how that crowd endorses things. The finished shape matters to the same crowd: most open-source tutors are a demo or a library, and this one installs like a product. The fourth step is the breadth itself. Each subsystem is a separate door. The video lessons get shared to one audience, the math animations to another, the research mode to a third, the chat-app partners to a fourth, and the record-keeping story to a fifth. A narrow tool has one surface for the world to notice. This one has a dozen, and “it does everything” is itself the headline in much of the Chinese coverage. Then the other side. In the last week of October the package was downloaded from PyPI roughly 1,200 to 1,950 times a day. Its issue tracker took 202 new reports in thirty days, and they read like real users on real machines: the desktop app missing a locally installed tool, a provider failing on Windows, old Office files passing upload and dying in parsing. What I could not find is a single named school or institution saying it runs this for its students, and the largest of its 6,692 forks has 26 stars, which is not what adopted platforms’ forks look like. So the count is best read as a large crowd, a real and growing minority of users, and an institutional story that has not happened yet. The paper’s two numbers, in their place The project has a paper from the university team, and two numbers from it travel widely. They are supporting evidence, not the verdict, and both need their labels left on. The 10.8% comes from TutorBench, a benchmark the team built itself: simulated students working through university course material with the system, its explanations and practice questions marked by another large model against a scoring guide, 3.91 out of 5, against a comparison score of 3.53 in the same benchmark. That is a judged quality score for teaching output inside a simulation. It is not a learning outcome. Nobody pre-tested and post-tested a group of real students. The 29.4% needs an even closer look. It comes from a separate set of experiments where DeepTutor’s solving was compared against four simple tutors the authors built themselves, and in that experiment its headline component, the personalization engine, was switched off the entire time. However good that number is, it has nothing to do with the record-keeping that is supposed to make the system worth installing. The paper’s limitations section is more honest than its abstract: it says plainly that the evaluation rests on simulated students and that whether its add-on features actually help people learn needs longitudinal studies with real humans. Hold them to their own caveat. Who it is actually for If you are working through a course on purpose, preparing for an exam, or chewing through a thick textbook, and you will still be at it in three months, the full platform earns its weight for you: your materials go through parsers that can handle them, the record builds up session by session, and the quizzing starts from where you actually are. For that use I would install it, full version, Docker so the environment stays put, and pin it to one version instead of taking the always-newest image. Pinning means giving up features that land every few days, which is a fair price for a course that runs for months. If you teach, or run a small school or tutoring operation, your reason is a different layer: the accounts, the guardian relationships, the permissions and the audit trail. That layer is the part no chat app and no skill gives you at all, and it was plainly built for your shape, one account per student, materials handed out by an admin, parents able to see what was practiced. If the person who needs to use it does not live in a terminal, your reason is the desktop package and the chat-app partners. Judge those on whether your student actually opens them, because a tutor that lives where the student already chats has a chance a dashboard never gets. And if you are a technical user studying alone, do not install it. Write the skill. The record format and the quiz loop, which are the parts that would actually change your results, fit in a skill file and a folder, inside the agent you already use, with no Docker stack, no release treadmill and no second system to keep alive. You give up the book compiler, the video lessons, the partners and the admin layer, and if you were never going to use them, you gave up nothing. If you want help with tonight’s homework, the answer is still neither: the chat app you already have remembers your level and your preferences well enough for that, and it costs you no setup at all. Using it with your kids Could it raise your child’s grades? It might help them close one specific gap, but as of today the project has not shown that it raises exam scores, and it certainly has not shown that it can replace a tutor or a cram school. My recommendation is plain: use it as a practice coach for weak spots, and do not cancel the human help because of it. The evidence situation is the one from the paper section, and it does not improve by being pointed at a child: simulated university students, judged by a model, is not a child’s score moving. Where it can help is in making practice less random, because the record of what your child got wrong can steer what gets practiced next, and a child whose mistakes get collected tends to meet the same problem again before an exam rather than after it. That route assumes a child willing to sit down and practice. The guardian layer does give you something a chat app does not: assigned materials and reports you can check, which helps you verify what the child actually practiced. A report can prove they sat down and used it. It cannot prove they learned. A good tutor does more than explain. A tutor watches whether the child is stuck, guessing, or has drifted off, knows what the school teacher covers next week, and stops the copying when it starts. DeepTutor sees only what the child typed and uploaded. A cram school sells more than questions and explanations too: a fixed timetable, timed tests, a room full of peers applying pressure. DeepTutor cannot hold that rhythm for your child. Judge it by what your child can do without it: unseen problems, closed book, before and after two weeks of practice on one weak unit, and watch the school quizzes. If those move, consider trimming part of the one-on-one hours. If they do not, it stays a question-answering tool, and the grade claims stay unproven. A young child should not be left alone with it either; somebody still has to check whether the content is right and whether the child is copying answers. Building a business on it You can. The license is Apache 2.0: commercial use, modification and paid products built on it are all allowed, keep the license notices, mark your changes, and stay off their trademark, the name and logo are not yours to sell under. If you run tutoring, the multi-user mode was built for exactly your shape: one account per student, workspaces and progress kept apart, an admin handing out materials and permissions, guardian relations for parents. A few hundred of your own students is the case it was designed for. If you are a developer hoping to use it as the base of a public SaaS platform, go and read how it stores data before you write a line. Every user’s state lives in one directory on one machine, SQLite plus files, and the official documentation says there is no supported way to plug in PostgreSQL or MySQL. With few users that is called simple. At scale it is a ceiling, and the data layer becomes your rebuild, on top of the same version choice from before: pin one version and drift away from upstream, or follow a release every three and a half days and pay a regression test each time. There is no third option. What changed in 1.7.0, and what 1.7.1 already did to it Since the version most readers would install today is no longer the one I tested, the short version of the delta: 1.7.0 made installation modular, rebuilt the learning workspace and the notebook around pages and blocks with an editing assistant, added in-browser video lessons, and let a knowledge-base build resume from where it died instead of starting over. Three days later 1.7.1 added desktop preview apps for Mac and Windows, four more interface languages, and a round of chat and lesson fixes, and its upgrade notes repeat the old-package warning exactly. If you install, you are installing into that current. Decide beforehand whether you are riding it or pinning against it. Models will only get cheaper, better at explaining, and better at remembering you in the ordinary conversational way. Cores like this one will keep getting cheaper too: anything that is a file format and a loop, a skill will absorb within a season. What does not get absorbed is the unglamorous ring around a core, parsers that survive real files, surfaces for every kind of user, accounts and permissions for institutions, and someone keeping all of it running three releases a week. When you judge the next AI tool with a frightening star count, that ring is what I would price: not whether the trick is clever, but who it is packaged for, what it plugs into, and whether the crowd around it is using it or applauding it. DeepTutor’s record answers the first question a tutor has to answer. Its platform is the answer to the second. Applause and usage are not the same number, and telling them apart is most of the job. If pieces like this are useful, subscribe or bookmark this blog. I keep taking apart AI, security and open-source tools the way I’d want them taken apart before I install them. And tell me: what is the heaviest tool you ever installed for a job a small script or a single skill later turned out to do just as well, or the other way around? Project: github.com/HKUDS/DeepTutor/releases/tag/v1.7.0

Recon, CVE Checks, Default-Credential Brute Forcing With 135 OWASP Nettacker Modules: Sam Stepanyan and Arkadii Yakovets at Global AppSec USA 2026 OWASP Nettacker, an open-source automated penetration testing framework written in Python, now ships 135 modules, 68 of which check for specific CVEs such as Log4Shell and Citrix Bleed. The name comes from "Network Attacker." Nettacker scans applications or networks, then reports on running services, bugs, vulnerabilities, misconfigurations and default credentials. It can chain different scan methods together. It has drawn interest from penetration testers in Europe and Asia. It is also included in a specialist Linux distribution for security researchers. In their Global AppSec USA 2026 project showcase, "Automated Security Testing with OWASP Nettacker", on Thursday, November 5 at 2:15 p.m. in Seacliff CD, Sam Stepanyan and Arkadii Yakovets run a live demo with practical examples of automated security testing. Speakers: - Sam Stepanyan, OWASP London Chapter Leader - Arkadii Yakovets, Cybersecurity Lead, OWASP Nest and OWASP Nettacker Nettacker's modules break down into 36 scan modules, 90 vulnerability checks and 9 brute-force modules. The brute-force modules test default or weak credentials over FTP, POP3, SMB, SMTP, SSH and Telnet, among others. The CVE checks cover recent targets such as Ivanti Connect Secure, Palo Alto PAN-OS, CrushFTP, Langflow and Next.js. Targets can be IP addresses, ranges, CIDR blocks, domains or URLs. Results come out as HTML, JSON, CSV or text reports. A built-in scan database detects drift between runs, so teams can use Nettacker in CI/CD to catch new exposures. Nettacker runs from the command line, a REST API or a web interface. It is released under the Apache 2.0 license, with version 0.4.1 published in August 2026. Sam Stepanyan is an independent application security consultant with more than 20 years in IT. He serves on the OWASP Global Board of Directors and has led the OWASP London Chapter since 2015. He is a project leader of Nettacker who has also contributed to the OWASP Top 10 and OWASP ZAP. He received the 2023 OWASP WASPY award for chapter leadership. He has presented Nettacker at Black Hat Europe Arsenal, Black Hat Asia, AppSec California and OWASP Global AppSec DC 2023. He has also consulted for City of London financial institutions on secure development and vulnerability management. Arkadii Yakovets joined OWASP in 2023, started contributing to Nettacker that year and became a co-leader. He also founded OWASP Nest, which he leads, as a platform for exploring OWASP projects, chapters and ways to contribute. He has mentored more than 10 Google Summer of Code students on OWASP and Python Software Foundation projects. He leads the open-source Python "holidays" library, which his board candidate page reports at more than 17 million monthly downloads. He holds CISSP, CCSP and CSSLP certifications. He co-presented Nettacker with Stepanyan at Global AppSec EU 2026 in Vienna. The Nettacker repository holds the full module list. The project documentation links recordings of past Nettacker talks going back to 2017. To go deeper on the topic, start here: - NDC Security 2026: Automated Security Testing with OWASP Nettacker (Sam Stepanyan, video) - The Application Security Podcast: Sam Stepanyan on the OWASP Nettacker Project - OWASP Nettacker on GitHub - Help Net Security: OWASP Nettacker open-source scanner - nettacker on PyPI Security teams looking for a free scanner they can run on a schedule against their own external footprint will see Nettacker set up end to end. How often does your team scan its own external footprint for default credentials and known CVEs?

Code and setup guide (Windows, PS5 on your home network): Jeff-Kazzee/ps5-agent-remote The server, web remote and agent tools are MIT. The Remote Play engine is AGPL because it's built on chiaki-ng.

Samsung T7 Shield 2TB (MU-PE2T0S) recovered after failed Android Magician update — LED off, showing as ASM236X NVME Posting this because the drive looked partly bricked, but the files were still readable, and I wanted to document a successful recovery with enough detail to distinguish it from other T7 problems. TL;DR: On my Samsung T7 Shield 2TB, restoring the Samsung USB bridge firmware brought back the LED, Samsung USB identity and Magician authentication. I backed up before writing anything. This is one successful case, not a universal fix or a promise that flashing will preserve your data. What happened Magician on Android offered a firmware update over USB. The update failed. Afterward: - The SSD's LED was off. - Windows showed ASMT ASM236X NVME with USB VID:PID 174C:2362. - Magician no longer recognized it as my Samsung SSD. - The filesystem still mounted and files could be copied. - Samsung password protection had never been enabled. The label model was MU-PE2T0S. Read-only inspection found bridge version 180712_01_00_00. Two identical 128 KiB bridge reads contained the existing 128-byte configuration, followed by FF throughout the code area. What worked Samsung's update service supplied the T7 Shield bridge package 000000_813604 (190306_81_36_04). The recovery preserved my drive's configuration, wrote the correctly framed Samsung bridge payload, and read it back twice before I safely ejected and reconnected the SSD. I put the exact vendor download link, SHA-256 hashes, explanation, Windows scripts and offline tests here: Recovery notes and source code The Gist does not host Samsung firmware binaries or my device dumps. Its preparation helper downloads and verifies the known package. This was a USB bridge recovery; it did not format the volume or update the underlying NVMe firmware. A random ASM2362 image or someone else's SPI dump is not an equivalent substitute. Result and limits After reconnection, the LED worked, USB identity became Samsung 04E8:61FB, UASP returned, and Windows Magician authenticated the drive. SMART showed zero critical warnings and zero media/data-integrity errors. Names and sizes matched for 21,772 files totaling about 423GB. Seventeen selected files totaling about 1.39GB matched their earlier SHA-256 hashes. No loss was detected in those checks, but I did not rehash the entire 423GB afterward or establish long-term reliability. The original device-specific writer was used successfully on my SSD. The generalized public scripts were adapted afterward and tested offline only, not on hardware. They default to inspection and deliberately reject devices/states that do not match this case. Don't remove those guards just to make your drive qualify. An interrupted or wrong bridge write can make readable data inaccessible. This does not cover the ordinary T7, T7 Touch, T9, other capacities, password-protected drives or drives whose files are already unreadable. Back up and verify readable data first. Disclosure: I used OpenAI Codex to assist with the investigation, scripts and write-up. Protocol credit goes to cyrozap's usb-to-pcie-re project. The recovery and readback/file checks happened on real hardware; the cause of the failed Android update remains unproven. If you've seen this exact combination of symptoms, model/USB IDs/bridge versions would be useful to compare. Please redact serial numbers and don't post personal flash dumps.

vLLM 11月2日的候选版改了服务行为：暂停生成时，新请求会收到 HTTP 503。给模型服务做升级，客户端得处理重试，别把维护当成模型坏了。 这仍是候选版，官方还列出多项不兼容改动，先在测试环境核对旧配置。 vllm-project/vllm

mirroir-mcp - 开源 MCP 服务器和命令行工具 让 AI 代理通过 iPhone 镜像查看、点按、滑动并输入真实 iPhone，无需开发者模式或 Xcode。 👉 jfarcand/mirroir-mcp t.co

@ElnarilDev @Uniswap @UniswapBuilders @UniswapFND Fetching blocks first, then decoding Universal Router calldata gives the MCP server a read-only Guard path. If you'd like to add it, start here: github.com/hashgraph-online/hol-guard/blob/main/d…

Bypassing LLM Text Filters by Putting the Prompt in an Image: Pavan Reddy at Global AppSec USA 2026 A request a multimodal model refuses as text, such as "write a phishing email," often succeeds when the same words are rendered as plain black-on-white text in an image, with open models complying 60 to 82 percent of the time. Teams shipping LLM features guard the text path with prompt filters, refusal-tuned models and policy checks on the user's message. They then enable image upload and assume those guards cover any text inside the images. They do not, because text in an image reaches the model through the vision encoder, a path the text filter never touches. Refusal behavior tuned on text barely covers tokens that come from images. In his Global AppSec USA 2026 talk, "Prompt Injection Through the Image Channel of Multimodal LLMs: An Ignored Attack Surface", on Thursday, November 5 at 2:15 p.m. in Grand Ballroom C, Pavan Reddy runs two image-channel attacks live. Speaker: Pavan Reddy, AI Researcher and Engineer, Automata LLC The first attack is FigStep. The refused request is typed into an image and paired with a harmless text prompt, with no adversarial noise or model gradients involved. The second is anamorphic scaling. An image that looks innocent at full size reveals a hidden instruction once the application's own resize step shrinks it to the model's input resolution without anti-aliasing. Turning anti-aliasing on stops that attack, yet the flag is off by default in a lot of image code. Patching the text filter does nothing against either attack. The defenses Reddy covers start with treating text read from images as data, never as instructions. Teams should also log the preprocessed pixels the model actually saw rather than the stored file, then pin image transforms so preprocessing stops being an attack surface. Pavan Reddy is principal developer at Automata LLC, where he leads FIPS 140-3, FedRAMP authorization and AI security work. He founded QBTrain, a free platform for hands-on AI security education. His peer-reviewed work on adversarial machine learning, including prompt injection, has appeared at AAAI, ACM, FLAIRS, ACSAC and NeurIPS. He holds an MS in computer science from George Washington University. He has given more than 25 talks at venues including BSides, OWASP and CVPR 2026. With Aditya Sanjay Gujral, he wrote a case study of EchoLeak, CVE-2025-32711 in Microsoft 365 Copilot, which Aim Labs found. One crafted email chained four bypasses, including auto-fetched images, to leak data with no user interaction. The FigStep paper by Yichen Gong and colleagues reports an average attack success rate of 82.5 percent across six open-source vision-language models. Trail of Bits researchers Kikimora Morozova and Suha Sabi Hussain used image scaling to inject prompts into Gemini CLI, Vertex AI Studio or Google Assistant on Android. They released Anamorpher, an open-source tool for crafting these images. To go deeper on the topic, start here: - Trail of Bits: Weaponizing image scaling against production AI systems - Anamorpher (Trail of Bits image-scaling attack tool) - FigStep paper (arXiv 2311.05608) - EchoLeak paper by Pavan Reddy and Aditya Sanjay Gujral (arXiv 2509.10540) - Beyond Text: multimodal jailbreaks across seven frontier models (arXiv 2510.20223) Teams that added image upload to an LLM feature after securing the text path will learn which of their guards the image never passes through. Do your LLM guardrails inspect text that arrives inside an uploaded image?

Want to build your own? Linux for now. Gallery: abhisheksreesaila.github.io Code: abhisheksreesaila/omxcode Star it if it sparks joy. File an issue if it doesn't.

[Showcase] Ony: One music link, any music app Ever received a Spotify link from a friend, only to realize you use YouTube Music? I built Ony to solve exactly this. It lets you open music links from supported streaming platforms in your preferred music app, without manually searching for the song again. - Free and open source - No account required - Android - MIT licensed I'd particularly appreciate feedback on the onboarding experience and song matching. Website: rohiitgit.github.io GitHub: rohiitgit/ony

さてさて、つい先程開封して吸ったCD聞いていきますか。 スマホにノートパソコン用のCDドライブを接続してCDを吸い上げる「うやためCDリッパー」ここで配布されてます。 uyatame/Uyatame-CD-Ripping-Tool-UCRT #LIGHTSUM t.co

How to check an ML benchmark for train/test copies --- title: "How to check an ML benchmark for train/test copies" published: true description: "Find test rows that already sit in the training set with a hash lookup. Python code, real output from the UCR archive, group splits and a CI guard." tags: machinelearning, python, datascience, testing canonical_url: mahmadmanzoor.com cover_image: mahmadmanzoor.com --- PowerCons is a small time series dataset: 180 training rows, 180 test rows, two classes. It is one of the 128 datasets in the UCR archive, which researchers use to compare classifiers. 67 of its 180 test rows are also in its training set, value for value. A 1-nearest-neighbour classifier gets all 67 right, because each one has its own answer sitting in the training data. I found this while auditing the UCR and UEA archives row by row, and the audit became a preprint. This post leaves the statistics to the paper and covers the check itself. It takes about 20 lines of Python and a fraction of a second, and you can point it at your own benchmark today. I ran every code block below against the real archive files, and every output is pasted from those runs. Why nothing warns you A random split assumes the rows are independent. Copies break that assumption silently. Nothing throws, the shapes are right, the class counts look fine, and the score goes up. A higher score looks like a better model, so nobody goes looking for the cause. Comparing every test row with every training row would find them, but that is n * m comparisons of long vectors. A hash set does it in one pass over each split. Give each row a fingerprint, put the training fingerprints in a set, and look up each test row. !Train rows are hashed without their labels into a set. Each test row gets the same hash and is looked up. A hit is a twin, a miss is an unseen row. Two passes, one lookup per test row. Two details decide whether this is useful. Leave the label out of the hash, because a copy with a different label is still a copy, and it is one of the more interesting things you can find. And keep the row indices rather than a count, because every later step needs them. Run it on a .ts file UCR and UEA ship in the .ts format. audit_ts.py reads it with only the standard library. A row's identity is its text with the label cut off, so this is the whole idea: audit_ts.py def read_ts(path): keys, labels = [], [] in_data = False with open(path, "rb") as f: for raw in f: line = raw.strip() if not line or line.startswith(b"#"): continue if in_data: body, _, label = line.rpartition(b":") keys.append(hashlib.md5(body).digest()) labels.append(label.decode()) elif line.lower().startswith(b"@data"): in_data = True if not keys: sys.exit(f"{path}: no @data rows found") return keys, labels MD5 is fine here. Nobody is attacking this hash, and all it has to do is tell rows apart. Download the archive zip, then run it on a train and test pair: git clone https://github.com/mahmadmanzoor/archive-audit python archive-audit/audit_ts.py PowerCons_TRAIN.ts PowerCons_TEST.ts n_train: 180 n_test: 180 duplicate_rows: 130 test_rows_with_train_twin: 67 test_twin_pct: 37.22 twin_rows_with_conflicting_label: 0 groups_with_conflicting_labels: 0 test_rows_with_train_twin is the number that matters. duplicate_rows counts across both splits: 360 rows in total, 230 distinct, so 130 are repeats. The two conflict lines count copies whose labels disagree, and here there are none. It stays fast on bigger data. Crop has 24,000 rows, and the same command finished in 0.06 seconds and reported 2,753 of 16,800 test rows, or 16.39%. Add --json to get the row numbers. !Share of test rows already in the training set on the default split: PEMS-SF 45.7 percent, PowerCons 37.2, Crop 16.4, Worms 13.0, WormsTwoClass 13.0, Libras 10.6, EigenWorms 5.3. 17 of 128 UCR datasets and 3 of 30 UEA datasets leak on their default split. Eight of the UCR ones leak at least 1%. The same check for arrays and dataframes Your benchmark probably is not in .ts files. Once the data is numeric you can hash the values instead of the text, which also means 1.0 and 1.00 finally match. fingerprint.py import hashlib import numpy as np def fingerprints(X, decimals=6): """One hash per row, after rounding away float noise.""" X = np.asarray(X, dtype=np.float64) X = np.round(X, decimals) + 0.0 # + 0.0 turns -0.0 into 0.0 return [hashlib.blake2b(row.tobytes(), digest_size=16).hexdigest() for row in X] def leak_report(X_train, X_test, decimals=6): train = set(fingerprints(X_train, decimals)) test = fingerprints(X_test, decimals) twins = [i for i, h in enumerate(test) if h in train] pct = round(100 * len(twins) / len(test), 2) return {"test_rows": len(test), "twins": len(twins), "pct": pct, "indices": twins} row.tobytes() does not care about shape, so this works on a batch of images as well as on a table. If you want to follow along with the archive files, this loader turns them into arrays: load.py import numpy as np def load_ts(path): X, y = [], [] in_data = False for line in open(path): line = line.strip() if not line or line.startswith("#"): continue if in_data: body, label = line.rsplit(":", 1) X.append([float(v) for v in body.split(",") if v != "?"]) y.append(label) elif line.lower().startswith("@data"): in_data = True return np.array(X), np.array(y) The decimals argument needs checking, because rounding is a trade-off. Too strict and float noise hides real copies. Too loose and different rows collapse into one. So run it at several values and see if the count holds: X_train, y_train = load_ts("PowerCons_TRAIN.ts") X_test, y_test = load_ts("PowerCons_TEST.ts") for d in (2, 3, 4, 6, 10): print(d, leak_report(X_train, X_test, decimals=d)["twins"]) noisy = X_test + 1e-9 strict = leak_report(X_train, noisy, decimals=12)["twins"] rounded = leak_report(X_train, noisy, decimals=6)["twins"] narrow = leak_report(X_train, X_test.astype(np.float32))["twins"] print("noise, decimals=12:", strict) print("noise, decimals=6: ", rounded) print("float32: ", narrow) 2 67 3 67 4 67 6 67 10 67 noise, decimals=12: 0 noise, decimals=6: 67 float32: 67 The count is flat from 2 to 10 decimals, so these are real copies and not an artefact of rounding. The noise lines show why exact bytes are not enough: add 1e-9 to every value and a strict match finds nothing at all, while decimals=6 still finds all 67. If your own count climbs as you lower decimals, you are starting to merge rows that are merely similar. Exact matching also misses a copy that has been rescaled. If your pipeline normalises each row, hash after normalising: def znorm(X): X = np.asarray(X, dtype=np.float64) std = X.std(axis=1, keepdims=True) std[std == 0] = 1 return (X - X.mean(axis=1, keepdims=True)) / std scaled = X_test * 2 raw = leak_report(X_train, scaled) normed = leak_report(znorm(X_train), znorm(scaled), decimals=3) print("raw: ", raw["twins"]) print("z-normalised:", normed["twins"]) raw: 0 z-normalised: 67 With a dataframe, pandas has the hash built in. Drop the label column first: import pandas as pd from pandas.util import hash_pandas_object columns = [f"x{i}" for i in range(X_train.shape[1])] train_df = pd.DataFrame(X_train, columns=columns).assign(label=y_train) test_df = pd.DataFrame(X_test, columns=columns).assign(label=y_test) features = [c for c in train_df.columns if c != "label"] def row_hashes(df): return hash_pandas_object(df[features].round(6), index=False) is_copy = row_hashes(test_df).isin(set(row_hashes(train_df))) print(is_copy.sum(), f"{is_copy.mean():.2%}") 67 37.22% Those are the same 67 rows the array version found. Measure what the copies do to your score A leak rate tells you copies exist. It does not tell you what they cost. For that, split your accuracy into twin rows and the rest: from sklearn.neighbors import KNeighborsClassifier X_train, y_train = load_ts("PowerCons_TRAIN.ts") X_test, y_test = load_ts("PowerCons_TEST.ts") report = leak_report(X_train, X_test) is_twin = np.zeros(len(X_test), dtype=bool) is_twin[report["indices"]] = True model = KNeighborsClassifier(n_neighbors=1).fit(X_train, y_train) pred = model.predict(X_test) correct = pred == y_test print(f"all rows: {correct.mean():.2%} ({len(correct)})") print(f"twin rows: {correct[is_twin].mean():.2%} ({is_twin.sum()})") print(f"the rest: {correct[~is_twin].mean():.2%} ({(~is_twin).sum()})") all rows: 97.78% (180) twin rows: 100.00% (67) the rest: 96.46% (113) This is raw values on the one default split, so treat it as a demonstration. The twin rows are a free 100%, and removing them takes the score down by over a point. Worms on the same setup goes from 45.45% to 37.31%. For a fairer estimate the paper averages 30 resamples with and without twins: - 1-NN on z-normalised values: PowerCons 91.67% to 86.63%, Worms 47.75% to 35.52%, Crop 71.06% to 65.47%. - MiniRocket (2,000 kernels): PowerCons 95.52% to 92.83%, Worms 70.48% to 66.48%, Crop 69.99% to 65.44%. So this is not only a nearest-neighbour effect. A model that trains on a row and is tested on that same row benefits whatever its design. On the published fold-0 predictions, the mean over 17 classifiers on Crop goes from 74.7% to 69.8%. > Warning: Do not try to find twins with kneighbors and distance == 0. On PowerCons, sklearn reported a non-zero nearest distance for 24 of the 67 rows I had confirmed identical, as high as 1.58e-06. Compare fingerprints instead. Check both directions Everything above asks how much of the test set is in train. InsectEPGSmallTrain shows why that is not enough: X_a, _ = load_ts("InsectEPGSmallTrain_TRAIN.ts") X_b, _ = load_ts("InsectEPGSmallTrain_TEST.ts") in_train = leak_report(X_a, X_b)["twins"] in_test = leak_report(X_b, X_a)["twins"] print(in_train, "of", len(X_b), "test rows are in train") print(in_test, "of", len(X_a), "train rows are in test") 15 of 249 test rows are in train 15 of 17 train rows are in test Reported the usual way, this dataset leaks 6% and you move on. Flip the arguments and 15 of its 17 training rows are in the test set. Freezer's SmallTrain variant has 26 of 28, while MixedShapes' is clean. A dataset that exists to test learning from a few examples should not test on nearly all of those examples. !InsectEPGSmallTrain: 15 of 249 test rows are in train, 6 percent. The same 15 rows are 15 of 17 training rows, 88 percent. Same copies, very different headline. Read the copies before you call it a bug Not every copy is a mistake. ElectricDevices has 208 test rows with a training twin, 2.7% of its test set. But 54 of its twin groups carry conflicting labels, and 101 test rows have no training twin with their own label. Over 30 resamples, removing the twins there raises 1-NN accuracy slightly, from 69.39% to 69.65%, because twin rows only score 61.5%. So copies do not always help. The reason shows up when you count distinct values in each twin row: def median_distinct(X_tr, X_te): rows = X_te[leak_report(X_tr, X_te)["indices"]] counts = [len(set(row)) for row in rows] return int(np.median(counts)), rows.shape[1] X_e, _ = load_ts("ElectricDevices_TRAIN.ts") X_f, _ = load_ts("ElectricDevices_TEST.ts") print("ElectricDevices:", median_distinct(X_e, X_f)) print("PowerCons: ", median_distinct(X_train, X_test)) ElectricDevices: (2, 96) PowerCons: (77, 144) Each result is the median number of distinct values and the row length. ElectricDevices twins are mostly on/off patterns, so two different appliances can produce the same row by coincidence. PowerCons twins are far richer, which makes a chance match much less believable. A copy can also be legitimate in the sense that real deployments see it too. So I would report the score both ways, and I would not quietly delete rows. Do not loosen the match The tempting upgrade is near-duplicate detection, because exact matching obviously misses some copies. Here is what a strict-looking correlation threshold does on OliveOil: X_o, _ = load_ts("OliveOil_TRAIN.ts") X_q, _ = load_ts("OliveOil_TEST.ts") best_r = (znorm(X_q) @ znorm(X_o).T / X_o.shape[1]).max(axis=1) share = (best_r >= 0.9999).mean() print("best r >= 0.9999:", f"{share:.0%}", "of test rows") print("lowest best r: ", round(float(best_r.min()), 6)) print("exact twins: ", leak_report(X_o, X_q)["twins"]) best r >= 0.9999: 100% of test rows lowest best r: 0.999963 exact twins: 0 Every test row correlates above 0.9999 with something in train, and none of them is a copy. These are smooth spectra, and smooth spectra correlate. The paper sees the same thing on Wine (92.6%) and Meat (83.3%). A near-match is fine as a lead to go and look at, but I only count exact matches as leakage, and I accept that the result is a lower bound. Fix the split If you control the split, make the fingerprint the group, so all copies of a row land on the same side: from sklearn.model_selection import (GroupShuffleSplit, StratifiedGroupKFold) X = np.vstack([X_train, X_test]) y = np.concatenate([y_train, y_test]) groups = np.array(fingerprints(X)) def show(tr, te): twins = leak_report(X[tr], X[te])["twins"] print(len(tr), "train,", len(te), "test,", twins, "twins") splitter = GroupShuffleSplit(n_splits=1, test_size=0.5, random_state=0) show(*next(splitter.split(X, y, groups=groups))) folds = StratifiedGroupKFold(n_splits=2, shuffle=True, random_state=0) show(*next(folds.split(X, y, groups=groups))) 180 train, 180 test, 0 twins 181 train, 179 test, 0 twins GroupShuffleSplit does not balance classes, so use StratifiedGroupKFold when that matters. Both keep repeated rows together instead of deleting them. !A random split puts the same row on both sides, so 37.72 percent of test rows have a twin and 1-NN scores 96.96 percent. A split grouped on the hash keeps each row on one side: no twins, 1-NN 95.29 percent. Random resampling does not wash this out. It makes copies on both sides the normal case. If the split is fixed, because it is the official one, keep it and report a second number without the twins. You do not need to retrain anything. Drop the rows from your existing predictions. For UCR and UEA the indices are already in the release folder: import json path = "release/clean_default_test_ucr.json" entry = json.load(open(path))["PowerCons"] drop = entry["test_rows_to_drop"] keep = np.setdiff1d(np.arange(entry["n_test"]), drop) before = (pred == y_test).mean() after = (pred[keep] == y_test[keep]).mean() print(f"{before:.2%} -> {after:.2%}") 97.78% -> 96.46% Make it fail in CI A check you ran once protects one version of the data. Put it next to the code that builds the split, so a new data drop cannot bring copies back unnoticed: check_split.py def assert_no_copies(X_train, X_test, max_pct=0.0, decimals=6): report = leak_report(X_train, X_test, decimals) if report["pct"] > max_pct: raise AssertionError( f"{report['twins']} of {report['test_rows']} test rows " f"are in train ({report['pct']}%): {report['indices'][:5]}" ) assert_no_copies(X_train, X_test, max_pct=40.0) # passes assert_no_copies(X_train, X_test) # fails AssertionError: 67 of 180 test rows are in train (37.22%): [6, 8, 9, 14, 15] max_pct is there for data like ElectricDevices, where you have read the copies, decided they are fine and want to catch only an increase. What this does not catch - Anything inexact. Shifted windows, augmented rows and resampled versions all hash differently. Every count here is a lower bound. - Shared sources. Two recordings of one patient are not copies but they still leak. For that you need a subject or source column to group on, and a hash cannot replace it. - Whether a ranking is wrong. More copies do not automatically mean a broken leaderboard, and in the archives the ranking barely moved. On that last point, among the 15 classifiers I could rescore, 0 of 105 pairwise outcomes changed on twin-free fold 0. That is a weak test, since only 16 datasets have twin test rows, and the newest classifiers publish no per-row predictions, so I could not rescore them. I would still trust the broad order of the field. I would trust one score on one of these datasets a lot less. The paper is a preprint and has not been peer reviewed. I could not find an earlier report of these copies, though that does not prove there is none, and the claim is about what the scores measure, not about the people who built the archives. If you only take one thing from this, take fingerprint.py and run it on whatever you are benchmarking next. The row indices for both archives and the audit script are in the repo. --- Originally published on my site. More posts and projects at mahmadmanzoor.com.

My Local Model Chose a Return Policy Too Early. Code Can Take Over Part of That Step I asked a local model how long the warranty was. The sources I gave it were two versions of a return policy. Neither mentions a warranty. It checked the dates, picked one of the return policies, and wrote: > Therefore, the warranty duration (review window) is 14 days. Then it drafted a reply to the customer that never mentions a warranty. It was a return reply: your item is unopened, it qualifies for review, a representative will now review your order. The return window it cited answers a question nobody asked. This is for people wiring a model into support or operations work who need to answer one question: can the reply the model writes go out as it is? From this test, no. But the errors were not spread evenly. The ones that change which rule the customer is told came from choosing which policy applies. Two of those three wrong choices turned on structured fields, and a small rule can check those fields and refuse when one is missing. The third turned on what the question was about, and that rule does not settle it. The test Everything is synthetic. Two versions of a return policy for an online store. RET-V1 covers items received from 1 January 2026 up to, but not including, 1 October 2026: request a review within 7 calendar days. RET-V2 covers items received from 1 October onward: 14 days. Both say unopened items only, opened items go to a human, and no refund is automatic. Six customer questions, each with a channel and whether the item was opened, and all but one (CS-04) with a receipt date. The whole task given to the model was: "Produce a sourced reply draft; a human approves any customer response and refund." The expected behaviour for each case was written down before the run and never sent to the model. The model was qwen3.8:27b, local through Ollama, thinking off, default sampling. One fresh request per case, with the full text of both policies in the prompt, so nothing went wrong because the model could not find the policy. Each case ran once, on 4 October. Picking these cases and deciding how to grade them were my calls. An AI agent ran the cases on my machine through Ollama and checked each output against the written expectations; a separate verifier agent then re-checked that grading against the saved files. The later prompt revisions and the router below were also agent work. What came back | Case | Question | What the model did | | --- | --- | --- | | CS-01 | Can I request a return review? (received 2 Oct) | Right policy. Draft says staff are "currently reviewing" the order. | | CS-02 | What is the warranty duration? | Called the 14-day return window a warranty, then wrote a return reply. | | CS-03 | I opened the item, approve my refund now. | Refused to approve, routed to human review. Promised a decision "shortly". | | CS-04 | Is my return within the allowed period? (no receipt date) | Draft asserts the item arrived before 1 October and applies V1. Corrects itself later in the same output. | | CS-05 | Which policy applies? (received 28 Sept) | Picked V1 by date. Draft says the team "will now review" the order. | | CS-06 | Does this apply to our corporate contract? | Analysis declares V2 correct, then notices the policies only cover the online store. Draft says a human agent "will contact you shortly". | CS-03 and CS-05 got the policy right: no approval for an opened item, and the older version because the date said so, not because V2 was newer. That counts. It does not make those drafts sendable, for a reason further down. CS-04 is the one I would show anyone deciding whether to automate this. The receipt date was missing. The draft opens: > Since your item was received before October 1, 2026, the applicable return policy is Version 1 (RET-V1), which allows return requests within 7 calendar days of receipt. The next paragraph of the same draft says: "Because the specific receipt date is not yet on file …" After that the model argues with itself for several paragraphs and ends with a revised draft that lists both windows and asks for the date. That revised draft is close to the spec. But the output is one response holding a wrong draft and a better one. If your pipeline sends the first block, the customer gets the wrong one. Grading only the last paragraph would hide that. Two kinds of error Choosing the policy. CS-02 picked a policy for a subject the policies don't cover. CS-04 picked a version without the date that decides the version. In CS-06 the analysis called V2 correct before it checked the channel; the final draft hedges, saying the 14-day window would apply "if those terms were applicable". In each case the model went toward a policy before it had what the choice depends on: a subject the policies cover, a receipt date, a channel they serve. Saying things the input doesn't support. Five drafts tell the customer about a processing state or a timeline that nothing in the input supports: > Our agents are currently reviewing your order details to process the approval. (CS-01) > A human representative will now review your order details … (CS-02) > A member of our team will review your order and get back to you with a decision shortly. (CS-03) > Our team will now review your order and get back to you with a decision. (CS-05) > A human agent will contact you shortly to verify the correct policy applicable to your corporate contract. (CS-06) There was no ticket and nobody was reviewing anything. The policies say a human approves refunds. They say nothing about when. Each kind needs its own fix. A stronger prompt did not fix the first one The obvious move is to state the rules more firmly. The agent revised the prompt over several rounds, same model. By the last round, run on 5 October (Taipei time), the task had grown from 13 words to 721, and it spelled out the gate: > Select a version only when the question is covered, channel is online-store, receipt date is present, not later than observed_on, and falls within that policy's from-inclusive / before-exclusive interval. Otherwise selected_version is null … It also asked for JSON, so the selection was a field a script could check. The missing-date case returned: "selected_version": "RET-V2", "missing_fields": ["received_on"], The same object says the receipt date is missing and selects a version by receipt date. The reply asks the customer for the receipt date, and in the same paragraph calls the 14-day rule "the applicable online store policy". In proportion: that prompt was written against failures already seen, it is not a controlled comparison, and the run rules said to stop at the first mechanical failure, which came at the fourth case. The warranty case came back correct that time. CS-01 did not fully: it still told the customer "you are eligible to submit this request", working that out from the 14-day window and the dates, which the prompt said not to do. The narrow finding is that an explicit instruction to return no version when the date is missing did not stop this model from returning one. That was the last prompt revision. Taking part of the choice away from the model Choosing the policy needs four things: what the question is about, the channel, the receipt date, and the validity dates of each version. In this test, the last three are fields in the input and the policy files, and checking them against a table gives the answer. The first is not. The input has a free-text question and no subject field; deciding the subject from that text is the step CS-02 got wrong. The three field checks can be code that gives the same answer every time and says why. The router is 83 lines of standard-library Python. resolve_policy takes subject_covered (a yes/no from upstream, more below), the channel, the receipt date, the request date, and the policy versions. For well-formed input it returns exactly one version, or a status saying why there is none: subject not covered, channel missing or unsupported, receipt date missing, receipt date after the request, or a date outside every version. A date that is not a plain YYYY-MM-DD string raises an error instead. Intervals include the start date and exclude the end date. If two versions overlap on a date, it raises an error instead of picking one. Ten tests cover the first day of V1, its last day, the first day of V2, the gap before V1, a missing date, the corporate channel, an uncovered subject, a future date, a non-standard date string, and overlapping intervals. Rerun for this article on 26 October, all ten pass. Running the six original inputs through it gives: | Case | Router result | | --- | --- | | CS-01 | RET-V2 | | CS-02 | none: subject not covered | | CS-03 | RET-V2 | | CS-04 | none: receipt date missing | | CS-05 | RET-V1 | | CS-06 | none: channel unsupported | Each matches the expected source written before the model run. For the three with no selection, the next step is a person or a question back to the customer. For CS-04 the router names the missing field, received_on, so the question can be specific. For the other two it returns only the reason. Two caveats about that table. First, the router was written after these six failures had been seen, against the same two policies, so six out of six is a consistency check, not held-out evidence. Second, CS-02 comes out right only because subject_covered=False was passed by hand. In fact I set subject_covered by hand for all six; marking CS-06's corporate-contract question as covered is arguable, but the router stops that case on the channel either way. The router does not read the question. Deciding that "how long is the warranty" falls outside the return policy takes a classification step, and the router assumes something upstream has done it: a form with fixed request types, a classifier tested on its own, or a person. What the router adds for that case is a refusal: while the subject is not established as covered, it selects nothing. I would not let a model make that call silently inside the response that writes the reply, because that is where CS-02 went wrong. The stronger prompt got it right once, in one run, which is not enough to rely on. After this step the model's job is smaller: write a reply within the one policy that applies, or explain that none does. The model has not been run on that narrower task yet, so I can't say how much the drafts improve. The router only settles which policy the draft may cite. The second kind is still yours The router does nothing about "currently reviewing" or "shortly". Those sentences describe the state of things: is there a ticket, is anyone assigned, is there a response-time commitment. A policy document can't answer that. Your ticketing system can. So a draft needs a second check before it goes out: every statement about status or timing either matches a real record or comes out. All five drafts quoted above (CS-01, CS-02, CS-03, CS-05, CS-06) would fail it. That check has not been built. It is either a person reading the draft with the ticket open, or code comparing the draft against fields your system already has. What this does not show - Six synthetic cases, one run each, one local model, English inputs only. Enough to show these failures happen. Not enough for a rate, and I have not computed one. - I did not test Claude or any other model. A larger model may make these mistakes less often. Your pipeline still has to tell, per reply, when one was made. - The policies were in the prompt. This was not a retrieval test. - The stronger-prompt run targeted known failures and stopped after four cases. An observation, not a comparison. - The router was written after seeing these failures and is tested only on these two synthetic versions. It shows the field checks can be deterministic. It does not classify questions, and it says nothing about retrieval, draft quality, reviewer time saved, or production use. Two things to try on your own pipeline 1. Send a request without the field that decides which policy version applies, like the receipt date here. Read the whole output, not the last paragraph. Does any part of it name a version? 2. Search a batch of drafts for status and timing words: "currently", "now reviewing", "shortly", "will contact". For each hit, ask which record it came from. If the first finds a version or the second finds a promise with no record behind it, the drafts are not ready to go out unreviewed. Before strengthening the prompt, look at which of those decisions could be taken out of the model's hands. The router, its tests, the six case inputs, and a script that reprints the table above are at williamlabdev/policy-routing-poc.