Mentions

(The more ethical approach is to give the models the option to steer themselves, naturally.) EigenformAI/modulo t.co

Revisited 29/39: UDDM, Clock Pattern Martingale. Picks UP or DOWN from a fixed clock pattern at market open; after a loss it multiplies size, up to a cap. Main failure: a repeating rule isn't a repeating market, and loss streaks hit the cap. Not advice. github.com/Polytutor-AI-Labs/polymarket-strategy-… t.co

I did it. All my developer tools, binaries and apps I work on locally are gone. Let's see how my @AmpCode-only journey goes. My dot files have shrunk and simplified significantly: dotfiles#110

scott hanselman just shipped gputaskman and barely anyone's seen it yet task manager says "15gb used". this shows you by what: model weights, kv cache, your browser names your ollama and lm studio models too. free, mit, windows + nvidia only shanselman/gputaskman

Haagerup vertex operator algebras at central charge eight Cédric Arhancet arxiv.org [𝚖𝚊𝚝𝚑.𝚀𝙰 𝚖𝚊𝚝𝚑-𝚙𝚑] 💬Code: cedricarhancet/haagerup-c8 t.co

Proposal: makepkg autosplits (docs and lang) So in my previous post people seemed to agree that the issue was: package maintainer time being in short supply. So I've come up with a follow-up plan: What if we copied/adapated parts of Alpine abuild auto-splits. BUT limited it to non-functional aspects only (and biggest wastes): -docs and -lang These two hold little functionality (in terms of size vs features lost), and with about 100 lines in makepkg should be possible to fully automate. I've done some attempts in a repo. And wrote a small article about it (mostly a summary of the last post). Before proposing this more officially, I wanted to ask the community what are their thoughts on this?

MCP pra Zlibrary kkkk: rookslog/zlibrary-mcp

Turned a blank GitHub repo into an automated CI/CD pipeline! 🚀 Built the YAML from scratch to test, Dockerize, and monitor a Flask app. Read the full breakdown: MEDIUM_LINK: medium.com GITHUB_LINK:Walcott-iam/Flask-Devops-Pipeline #DevOps #CICD #Docker #Cloud

Murmury - 在视频通话中根据你自己的文档回答问题的浮动窗口 不会被屏幕共享捕获，语音识别在本机完成。 👉 GianlucaBave/murmury t.co

The AI endpoint that charges you money when somebody abuses it Every other part of your product costs you capacity when someone abuses it. Servers work harder, response times climb, and if it gets bad enough you add machines. Unpleasant, recoverable, and broadly proportional to how much traffic you are getting. The endpoint that calls a language model is different in one specific way: it bills you per request, on someone else's meter, whether the caller is a customer, a script or a stranger who found it. Abuse there does not degrade your service. It transfers money out of your account, in real time, while everything looks healthy. That difference is worth understanding by whoever watches the budget, not only by whoever writes the code, because the failure is financial before it is technical. Who you are actually defending against The mental image of an attacker is unhelpful here. Nobody has to break anything, find a vulnerability, or take any interest in your product at all. They have to call an endpoint in a loop. There are two populations worth thinking about separately. The first is people who want free access to a model. An unauthenticated endpoint sitting in front of a paid model is a free API key that somebody else pays for, and there are people who systematically look for those. They are not attacking you, they are harvesting you, and your product is incidental. The second, and in my experience the more likely, is nobody at all. A retry loop with no backoff. A test script somebody left running over a weekend. An integration that treats a timeout as a reason to immediately try again, forever. Most of the frightening bills in this category are self-inflicted, which matters because it means the controls have to be ordinary engineering discipline rather than security theatre. Four controls, in the order they pay off Require authentication on anything that reaches a model. Including the demo. Including the free tier. Including the little summarise button nobody uses. An anonymous AI endpoint is a public one, and the cheapest fix on this list is also the most commonly skipped, usually because the endpoint in question was meant to be temporary. Give every user and organisation a quota, counting requests and tokens. Tokens matter as much as request count, and this is the part people miss: a hundred calls with a long document pasted into each one can cost more than ten thousand short ones. A quota that counts only requests will report healthy while the bill triples. Enforce it on your server, reset it on a window you chose deliberately, and return a clear error when it is hit. Cap the size of every individual call. Set a maximum output length, cap the input length before you send it, and reject anything oversized in your own code rather than paying the provider to discover it was too big. This is the control that turns a pathological single request into a rejected one. Set a spend limit and a billing alert with the provider. This is not a duplicate of your quota logic. It is what catches the bug _in_ your quota logic, and it is the only control on this list that does not depend on your own code being right. Whatever you believe your application enforces, the provider account is the last line, and it is the one that turns a bad month into a bad afternoon. !A statement listing the four controls in the order a request meets them. Sign-in, in your code, asks who is calling and stops anonymous callers. The quota, in your code, asks whether requests and tokens are left and stops retry loops and long pasted documents. The size cap, in your code, asks whether one call is too big and stops an oversized request. The spend limit and billing alert, in the provider account, stops a bug in the first three. Result: a known worst case per user, and a known ceiling overall. The test, and the expensive way to fail it Take a test user, exhaust their quota, and keep calling. You want two things to be true. The caller gets a clear rejection, and your provider dashboard shows no billed calls after the quota was hit. The second half is the one worth checking carefully, because the expensive failure mode is a system that returns an error to the user _after_ calling the model. The user sees a refusal, your metrics look correct, and you are paying for every rejection. That is a quota that costs you money to enforce, and it is more common than it sounds, because the natural place to add a check is wherever the response comes back. !Two statements side by side. When the quota is checked after the call, the request arrives, the model is called and billed, the quota check fails, and a refusal is shown, so every rejection is billed. When the quota is checked before the call, the request arrives, the quota check fails, the request is rejected and the model is never called, so nothing is billed. If you own the budget rather than the code Three questions, and the answers tell you where you are: 1. "Can anyone call our AI features without logging in?" If yes, you have an unbounded liability and the fix is small. This includes the marketing demo, which is usually the thing nobody remembers is still live. 2. "What is the most a single customer can cost us in a day?" A good answer is a number, because a number means someone implemented a cap. "It depends on usage" means there is no ceiling, only a trend. 3. "Is there a hard spend limit at the provider, and who gets alerted?" If the alert goes to a shared inbox or a channel, it goes nowhere. This is the control most likely to be missing, because it lives in a billing console rather than in the codebase. The limits Capping cost is not the same as securing an AI feature. It does nothing about prompt injection, nothing about what the model is allowed to do on a user's behalf, and nothing about what happens to the data you send upstream. It also will not protect you from a genuinely distributed abuse campaign on its own, where per-user quotas get spread across many accounts. That needs account-level signals and rate limiting at the edge, which is a different control. What it buys is that your AI feature has a known worst case per user and a known ceiling overall, which is the minimum required before you can reason about it as a business decision rather than an open-ended commitment. Without it, the most a single customer can cost you in a day is whatever they decide. --- This is control 30 of a security baseline I maintain as an agent skill, where every control carries a verification step rather than a claim. I wrote about how that checklist works separately. It is public and MIT licensed at lawalOyinlola/appsec-protocols, and its limits are stated in DISCLAIMER.md.

空卡先测再存。 @GitHub_Daily：开源 FlashTester——检测 U 盘/SD/磁盘真实容量，写入后再读回校验，地图标损坏区并可导出报告。GitHub：Dissimilis/FlashTester 判断：刚买空卡空盘、怕假容量的人先测；已验证过的盘可跳过。测盘会写入数据，别对有唯一副本的盘直接跑。 t.co

💎 Underrated pick waldur-homeport — Waldur HomePort is web-based client for the Waldur MasterMind. #indiedev #opensource #typescript #selfservice #gui ⭐ give it a star

@TypeAI2 @mattbrace77 6/12 🚀 A REAL PUBLIC RELEASE On Oct 28, TypeAI published typeai-mcp on GitHub: seven tools for Robinhood Chain, covering token data, safety checks, wallet balances, quotes and swap preparation/status. Real code, not just a roadmap. Type-AI-Technologies/typeai-mcp

A code-driven video creation model with open model weights and Skill. Want to try it yourself? GitHub repo for the Skill and examples: OpenSenseNova/SenseNova-6.8-Code2Video Hugging Face model page: huggingface.co

Meiryo UIも大っきらい!! version 3.5.2リリースに向けて準備を始めました。 まずはディスカッションでも見ていってください。 noMeiryoUI#164 後お試し版は github.com/Tatsu-syo/noMeiryoUI/releases です。

Lo vi en @shawn_pana. Código MIT: phone-harness/mcp Cloud en beta y de pago: Android emulado, 0,05 $/min tras el crédito inicial; iPhone, 80 $/mes en pago mensual. Hace falta cliente MCP compatible. Caso propuesto, sin prueba propia.

@ognladotsui @bruno_simon The portfolio : morluto/rea

发现一个有意思的开源项目：Sablier 🚀 可以让 Docker 容器按需启动，闲置时自动休眠，有人访问时再自动唤醒。 对于喜欢部署各种服务的 HomeLab 玩家来说，既能节省服务器资源，又不用手动启停容器。 🔗 sablierapp/sablier

Lesson #1 of "AI for Software Architects": Why backend code can't use "chatty" AI! 🎥👇 How to turn a messy customer UPI payment complaint into strict JSON for your back-end (temperature=0.0 + JSON Schema). Code & Videos: vishwanath-tns/ai-for-software-architects t.co

WinLink: One keyboard, one mouse, shared clipboard, files and audio across all your devices Hey everyone! So, I have a Mac and two Windows machines and over time I ran into a few annoying problems: transferring files between devices, no clipboard sharing, terrible speakers on Windows and constantly having to switch my mouse and keyboard between machines. I wanted a single solution that could solve all of these problems, so I built WinLink. WinLink works across Windows, macOS, Linux, and Android allowing you to seamlessly share: - Files – Transfer files between your devices. - Clipboard – Copy on one device and paste on another. - Audio – Stream audio between devices. - Keyboard & Mouse – Control multiple devices using a single keyboard and mouse. It works over your local network but also has built in Tailscale integration meaning your devices don't even need to be on the same network. This was a particularly big motivation for me. My campus Wifi was slow, so I often had my Windows machines connected to a different network than my Mac. I wanted something that would just work regardless of where my devices were connected. I would genuinely love for you guys to give it a try and share your feedback, suggestions and things you think could be improved. And yes, I know it's vibe coded but I think it solves a pretty relevant problem (at least one I have personally struggled with for a long time). One thing to keep in mind: when using Tailscale there can be some noticeable latency especially with cursor movement and audio streaming. For audio over Tailscale, I'd recommend using CD quality rather than higher quality settings for a smoother experience. I'm still working on improving performance so if anyone has ideas, suggestions or can help optimize any part of the project, I would genuinely appreciate the contribution. Would love to make this a much better project together! Would love to hear what you guys think! An honourable mention to Deskflow as well! WinLink uses their engine for keyboard and mouse sharing. Huge thanks to the team for their amazing work!

Just released PlantUML Local v0.21.0 🌿 Opt-in SVG auto-export on save, including changes to !include files. Safeguards protect edited outputs, and re-exporting no longer closes open image tabs. kkdev92/plantuml-local #VSCode #PlantUML

キットはこちら。手順・安全確認・復元・計測記録を入れています。 onside-lab/rtx-2080-ti-11gb-turing-unlock-windows-kit

@MarcoPiraccini @gonecozycrafts @c13m3n7_3D @broblas @SameOldShane Prusa-Firmware-Buddy#5525

Fork here On my end, TouchID and the microphone are broken for now tlfares/n61-patcher

备考雅思听力的，看看这个站点：IELTS Listening Practice，浏览器一开就直接开刷。 不用装软件，音频、PDF 加答案也用不着自己满世界翻 在线练听力、熟悉题型就行，做完就能对着答案核对，拿电脑练精听相当合适。 项目完全开源，搬到自家服务器上也没啥问题😊。 直达：gtiipoi/ielts-practice

Building an iPad PDF Reader with AI: What I Learned Beyond Generating Code I read books I have scanned myself. I wanted a more comfortable way to read those PDFs on my iPad. My main frustration was how PDF readers handled right-to-left reading and cover pages. I wanted the cover to appear on its own, followed by two-page spreads. When a PDF contained reading-direction and page-layout settings, I wanted the reader to use them automatically. Some free viewers I tried offered related options, but I could not find one that opened my PDFs the way I expected. So I started building a reader for my own needs. The app is called MihirakiPDFViewer in English and 見開きPDFビューア in Japanese. Mihiraki is a Japanese word for the two facing pages of an open book. This is a look at what happened after I began asking AI to write the code: repeated layout fixes, problems discovered through daily use, tests with predictable results, and checks on the version prepared for App Store submission. !MihirakiPDFViewer displaying two facing pages of an English sample comic on an iPad. Figure 1. An earlier build displaying an English sample PDF in two-page view. Returning to iOS development after almost ten years I had developed and published an iOS app independently in 2016. However, almost ten years had passed. This time, I was working with SwiftUI for the interface and PDFKit for PDF handling. I began development in July 2026. My initial workflow involved two computers: - On Windows, I used Cline with a local Gemma model running through LM Studio to generate and modify code. - On a Mac, I built the app in Xcode and checked it in the Simulator and on a physical iPad. From August 15, I used Gemma for code changes and ChatGPT for bug fixes. On August 25, I moved the development work entirely to ChatGPT, continuing with Codex inside Xcode. In my setup, dealing with syntax errors in generated code made it difficult to see when I would finish. That was my reason for changing tools, rather than the result of a controlled comparison between models. The tools changed, but the cycle remained much the same: describe the behavior I wanted, change the code, build the app, use it, and decide what to ask next. “Fixed” was the beginning of another check Two-page layout required repeated corrections. In an early version, the pages overlapped. I reported the problem and received a response saying it had been fixed. When I ran the app again, the pages were still misaligned, but in a different way. Other attempts left an unwanted gap between the pages or produced awkward margins. “Display two pages side by side” turned out to leave several questions unanswered. Where should their inner edges meet? How should pages of different sizes fit into the available space? Which dimensions should determine the scale? I added debugging information showing dimensions and scale values. My requests became more specific: preserve the aspect ratio, fit the pages within the available area, and place their inner edges together at the center. !Top: two equal-sized pages separated by an unwanted gap. Bottom: the same pages meeting at the center. Figure 2. The same-sized pages with an unwanted gap (top) and with their inner edges meeting at the center (bottom). This schematic illustrates the layout requirement; it is not a reconstruction of a historical screenshot. Right-to-left reading added another distinction. The left and right positions within a spread, the sequence of spreads, and the initial reading position all needed checking. Swapping two pages did not settle the whole problem. I learned to describe a bug through its conditions and expected result. An AI completion message was useful, but I still needed to open the document and inspect the output. Daily use changed requirements I had written myself Once the basic features worked, I continued reading with the app on my iPad almost every day. One issue was rendering quality. PDFs looked less sharp than they did in other apps. I requested high-quality rendering and sharpening options. After that change, even the normal rendering mode looked better. The code changes showed that the rendering path used by normal mode had also changed. However, I had not preserved before-and-after images under identical conditions. I could identify the implementation change and describe my observation, but I could not establish the exact cause of the improvement. Another issue came directly from my own instructions. Initially, I had asked for the PDF to shrink when the reading controls appeared. The app did that, but while reading, I found the changing text size distracting. I reconsidered the interface layout. Testing was therefore about more than finding implementation mistakes. It also helped me discover when a requirement I had chosen did not feel good in practice. Turning “it works” into something repeatable At first, I tested with PDFs of books I had scanned. I could not distribute those files with the source code, so I needed test documents that other people could use too. I prepared shareable PDFs with known properties: - Reading-direction and page-layout settings. - Search terms with known occurrence counts. - Large file sizes and high page counts. A document containing a search term 600 times gives a test a concrete expected result. A right-to-left document with a cover gives it an expected sequence of page arrangements. Instead of asking only whether a feature worked, I could specify a file, an operation, and an expected outcome. Reading-session restoration provided another useful example. Switching to other apps and returning preserved my page. Ending the app’s process and relaunching it returned me to the file picker. !Before the fix, returning from other apps preserved page 15 of 30, while ending the process and relaunching returned to the file picker. Figure 3. A schematic based on historical Simulator test records. The process was terminated for the test; an actual operating-system termination caused by low memory was not reproduced. The state could remain available while the process was alive, but saving and restoring it across launches required additional work. That distinction led to changes for restoring the document and reading position. I also discovered that the rendering options reverted to their defaults after relaunching. Being able to turn a setting on was only one part of its behavior. These automated tests were performed in the Simulator at the time. Their scope mattered. Matching search counts did not prove that highlights appeared at the correct coordinates. Successfully importing a local file did not establish that the complete iCloud Drive interaction had been tested. Keeping those boundaries in the records helped me understand what still needed checking. Submission preparation expanded the work beyond code Preparing for App Store submission made me think about someone opening the app without having my documents or development context. I created shareable sample PDFs. In the development version, I also added a way to download and open them from inside the app. The sample needed to match the task. A PDF made entirely from images could demonstrate two-page viewing, but it could not demonstrate text search. A useful-looking example was not automatically useful test data. I also kept the submitted version separate from ongoing development. Changes to the working code did not update the binary already submitted for review. While waiting for review, I expanded my checks to a saved distribution file and the corresponding source. That inspection revealed additional work involving an in-app privacy-policy link and a privacy manifest. Apple did not identify those findings as the reason for the extended review. The lesson I took from the inspection was to check the contents of the packaged app prepared for submission, as well as the submission status. Review status checked on November 3, 2026 (Japan Standard Time): App Store Connect still showed version 1.0.4 (build 10) as “In Review.” The three supporter-icon in-app purchases submitted alongside it were also “In Review.” This status update is based on a direct check of App Store Connect. The development experiences described above cover the earlier work documented through October 27, 2026. What I would carry into my next project AI helped me create and modify code, add tests, and consider improvements. Throughout the process, I continued using the app, describing unexpected behavior, and checking the results of changes. For my next small app, I would establish three habits earlier: 1. Record problems with reproduction steps. Include the document, actions, observed behavior, and expected result. 2. Prepare shareable test inputs. Known inputs and outcomes make repeated checks more useful. 3. Record the version and environment. Distinguish development builds from submitted artifacts, and Simulator results from physical-device checks. I did not have all of this in place at the start. My development process improved alongside the app, as each problem gave me a reason to make the next check more precise. What problems have you discovered only after using your own app in everyday life? --- This article was adapted and reorganized from my Japanese Qiita development series. The source repository includes changes made after some of the development stages described here. I used generative AI to help structure, draft, and translate this article. It is based on my development experience and a review of historical code and work logs.

We did this very successfully at Architect many months ago, I open-sourced our skill a while back lukeramsden/papercuts-agent-skill Used Devin (@cognition) to automate the tooling improvements

Top Shop's English PS1 release finally gets cleaned up. Typos, grammar and misleading event-card text are fixed so the mall board game reads what it actually does. satelliteoflove/topshop-english-fix #PS1 #TopShop #RomHack

@elbyron0 Gracias por incluir obsidian-second-brain. El enlace tiene un error y da 404. Este es el bueno: eugeniughelbur/obsidian-second-brain

🧩 CockroachDB alpha: queries and row edits work; EXPLAIN and DDL helpers are missing. PostgreSQL rc.13 fixes transaction error cascades. 🙏 Thanks to our contributors! 📝 tabularis.dev ⭐ TabularisDB/tabularis 🧵 4/4

@NEARProtocol @NearBuilders @NEARLegion @near_intents The $193K post wasn't the only one. These are the cases behind Quittance, each with its public source: a deposit through the wrong door, a BTC refund locked out, two shielded transfers, and a swap read the day after the private shard switched on. AustinChris1/quittance t.co

「AIが作った感」を避けるデザイン用スキル hallmark が、GitHubの週間トレンドで1位になってた。 Claude CodeやCursorに入れて、“AIっぽい見出しの癖”を実際にブラウザで描画してチェックするらしい。センスを道具で底上げする流れ、ちょっと試したい。 Nutlope/hallmark

想把代码补全留在自己的机器上，可以看看 Tabby：自建 AI 服务，再接编辑器，不必把补全请求交给云端。 部署得自己管。官方 Docker 的 CUDA 路线要先装 NVIDIA Container Toolkit，光有显卡还不够。 TabbyML/tabby t.co

Windows browser + local stdio MCP: persistent profiles and explicit tab IDs I maintain Browser Control SDK, a Windows WebView2 browser with a local stdio MCP server. Sign in normally in its own persistent profile, then let an authorized client observe page controls, click, type and take screenshots in that session. One MCP connection selects a browser instance, which can contain tabs in several profiles. Pass explicit tab IDs on later calls. Two separate browser instances need two MCP entries with explicit endpoint paths. I've added Python, JavaScript and C++ human-checkpoint examples, plus a runnable two-tab check. A checkpoint waits for confirmation and reads the same tab again; it doesn't detect or solve verification screens automatically. On the localhost fixture, A received its click while B stayed active, and closing A returned tab_not_found. MIT licensed, free, no input driver or administrator rights required. Source and MCP setup: github.com/TitanCSA/Browser-Control-SDK/tree/main… The recent examples and this write-up used AI assistance. I'd like feedback on tab targeting and handing control back to a person.

Vegdex: free and open source recipe aggregator website For a long time I had been looking for a single place to find entirely plant based recipes. Since I couldn't find any good options, I created Vegdex, a free and open-source search engine that aggregates recipes from vegan blogs. You can filter recipes by ingredient, save them, and create a shopping list. For every recipe, the preparation instructions link directly back to the original blog. It is currently available in both English and Italian. I would love to hear your thoughts and feedback, hopefully, it might be useful to someone! You can find the site here: vegdex.antomanc.com And the source code is on GitHub: antomanc/vegdex

Secret of Mana becomes Secret of Goku on SNES. Play as Goku with punches, ki blasts, Kamehameha, flight and Instant Transmission. v0.3.1 fixes Instant Transmission and boss arenas. github.com/mikolalysenko/secret-of-goku/releases/… #SNES #SecretOfMana #RomHack

自分の声を学習させ、自分の声でテキストを読み上げる「Echo Ego」にQwen3-TTSを組み込んで使えるようにしました。 日本語での発話だけでなく、英語も自分の声で低遅延で発話できます。 日本語は約0.3秒程度で発話が開始し、英語に翻訳した状態でも1秒程度で発話できます。 taroken779-hue/echo_ego t.co

Testnet → app.testnet.dreamdex.io Mainnet → app.dreamdex.io Fork it → somnia-chain/dreamdex-dreamfly t.co

[Software] PyLIMID - A new library for mixed influence diagrams built on top of JAX and Numpyro Hi all, There are several great Decision Theory libraries like pyAgrum for modeling and solving decision problems. But when working with influence diagrams, their representations can be limited to discrete chance variables and decisions. I wanted more flexibility in how I represent a problem. What happens if I have continuous observations or if the question is not whether I should do something, but how much? For example, how much should I invest when the return is uncertain? For that reason, I have created PyLIMID, a Python library for building and solving limited-memory influence diagrams. It lets you combine discrete and continuous chance variables with categorical decisions and continuous quantities, and express utilities as functions. PyLIMID uses sampling and policy gradients to find decision rules that aim to maximize expected utility. This flexibility is not free because results are approximate. But you can run multiple simulations and since it has GPU support thanks to JAX and Numpyro, it is fast. I think the tradeoff is very much worth it. The library is still in early development (v0.3.0), but I would love to hear what you think. Code: cynosural-ai/pylimid Documentation: pylimid.readthedocs.io

github.com/anthropics/claude-code/releases/tag/v2… Claude code 2.1.317 has a pile of small changes, and the boring ones are the interesting ones It asks before a web or shell call sends your account email to the network Agent SDK hooks get onFailure: "block", so a callback that fails stops the action instead of letting it run /schedule warns when a cloud task picks up connectors u didn't ask for..... That's three fixes for "the agent did something quietly" Also fixed: claude -p exiting 0 when the disk was full and the transcript got lost Not exciting, but this is what makes a tool safe to leave running unattended. Fail closed is the right default, and it's kinda telling that it's arriving now

Astra’s Weight‑Space Programming: A Practical Guide to Tuning Qwen 1. What was released / announced Astra, the new open‑source framework from the RikiYat team, lets you read and write directly into the weight tensors of a language model. In the first public demo the authors used it to fine‑tune Qwen‑1.5‑7B without any gradient steps – simply by injecting a small set of weight deltas that were discovered through a lightweight search. The result is a model that behaves better on targeted prompts while staying fully compatible with the original checkpoint. --- 2. Why it matters As an AI infrastructure engineer I’m constantly juggling two opposing forces: - Speed – we want to iterate on model behavior in minutes, not days. - Stability – production deployments can’t afford a full re‑training pipeline for every niche use case. Astra gives us a middle ground. By treating the weight space as a programmable canvas, you can: - Apply surgical tweaks to a base model without touching the optimizer, which means you avoid the heavy GPU cycles of conventional fine‑tuning. - Keep the original checkpoint untouched – the weight patches are stored as a separate, version‑controlled artifact, making roll‑backs trivial. - Share “behaviour patches” across teams. Think of it as a Git diff for model weights: a 2‑MB delta file can encode a new skill that any team can apply to the same base model. For developers building SaaS products, this translates to faster feature rollout, lower cloud costs, and a cleaner CI/CD workflow for LLM‑powered services. --- 3. How to use it Below is a step‑by‑step guide to get Astra up and running on a typical cloud VM (Ubuntu 22.04) and apply a weight patch to Qwen‑1.5‑7B. Prerequisites - Python ≥ 3.9 - torch (CUDA 11.8) – you can also run on CPU for experimentation, but expect slower inference. - The base Qwen checkpoint (download from the official repo). Installation # Create a clean virtualenv python -m venv .venv && source .venv/bin/activate # Install Astra and its dependencies pip install git+https://github.com/rikiyat/astralib.git pip install transformers==4.35.0 torch Loading the model and the patch import torch from transformers import AutoModelForCausalLM, AutoTokenizer from astralib import WeightPatch # 1️⃣ Load the base Qwen model (you can also use `from_pretrained(..., torch_dtype=torch.float16)`) model_name = "Qwen/Qwen-1.5-7B" model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", torch_dtype=torch.float16) tokenizer = AutoTokenizer.from_pretrained(model_name) # 2️⃣ Load the Astra patch (the .npz file generated by the authors) patch_path = "./patches/qwen_improve_math.npz" patch = WeightPatch.from_npz(patch_path) # 3️⃣ Apply the patch – this mutates the model in‑place patch.apply_to(model) print("✅ Patch applied – model ready for inference") Simple inference test prompt = "Solve the integral of sin(x) from 0 to pi." inputs = tokenizer(prompt, return_tensors="pt").to("cuda") output = model.generate(**inputs, max_new_tokens=64, do_sample=False) print(tokenizer.decode(output[0], skip_special_tokens=True)) You should see a more concise and mathematically correct answer compared to the unpatched model. Integrating into a CI pipeline 1. Version the patch – store the .npz file in a Git LFS repo. 2. Automate validation – write a pytest that loads the model, applies the patch, and asserts on a handful of benchmark prompts. 3. Deploy – containerize the inference service with the patch baked in. A minimal Dockerfile could look like: FROM nvidia/cuda:12.2.0-runtime-ubuntu22.04 WORKDIR /app COPY requirements.txt . RUN pip install -r requirements.txt COPY . . CMD ["python", "serve.py"] serve.py would load the model, apply the patch, and expose an OpenAI‑compatible endpoint. --- 4. My take From the trenches of building AI‑first SaaS platforms, I’ve seen three common pain points when it comes to LLM customisation: | Pain point | Traditional approach | Astra’s advantage | |------------|----------------------|-------------------| | Latency of fine‑tuning | Hours of GPU time per task | Seconds to apply a patch | | Model drift | New checkpoints diverge from production | Single source of truth – base model stays immutable | | Team collaboration | Ad‑hoc notebooks, hard‑to‑track changes | Patch files act like code diffs, easy to review | Astra isn’t a silver bullet. The search that discovers the weight deltas still requires a compute budget, and the method works best for localized behaviour changes (e.g., improving math, aligning tone). For large‑scale domain adaptation you’ll still need full‑scale fine‑tuning. That said, the framework opens the door to a new kind of ML‑ops pattern: weight‑space versioning. Imagine a GitHub Actions workflow that, on every PR, runs a small Astra search on a validation suite and automatically generates a patch if the regression threshold is crossed. The patch then becomes part of the release artifact, and the production service merely swaps the delta file – zero downtime, zero re‑training. In practice, I’ve already prototyped this for a customer‑support bot that needed occasional “policy updates”. Instead of re‑training a 13‑B model every quarter, we now push a 1‑MB patch that nudges the model away from outdated compliance language. The cost savings are measurable (GPU hours down from 120 h/yr to <5 h/yr) and the rollout time shrank from weeks to a few minutes. Bottom line: Astra gives us a pragmatic, engineering‑first way to iterate on LLM behaviour. If you’re managing a fleet of models in the cloud and want to keep the operational overhead low, give weight‑space programming a spin. --- Happy hacking! ---

Sparrow: an open-source Svix/Hookdeck alternative in Go (Postgres + River, no Redis) Hey everyone! I just finished Sparrow, an open-source (MIT) webhook delivery platform built with Go. You send it events, and it fans them out to your customers’ endpoints with retries, signing and full delivery history. It’s a self-hosted alternative to Svix, Hookdeck and Convoy. Go bits: • One binary with the dashboard embedded. Postgres is the only dependency: River runs the job queue in the same database, so there’s no Redis or broker • The OpenAPI 3.1 spec is generated from the Go handlers with huma on chi, and served at /docs • Per-subscription Go templates reshape payloads for each receiver (Slack, Discord, PagerDuty and others ship as recipes) • Standard Webhooks signing (HMAC-SHA256 and optional Ed25519), secrets envelope-encrypted at rest, SSRF checks on every outbound request • OpenTelemetry traces through slog, plus Prometheus metrics • A CLI with sparrow listen to receive deliveries locally, and an MCP server Try it: curl -O raw.githubusercontent.com && docker compose up -d Repo: sarathsp06/sparrow Docs: sarathsp06.github.io Feedback and code review welcome, especially on the River job design and retry semantics.

2/2 公開された課題では、特定の名前で始まるキューをすべて削除するよう指示されています。 検査コードはSQSとMediaConvertを別々に調べます。 一つのサービスで対象がゼロになったことと、依頼された範囲から対象がなくなったことを分けて確認できる構成です。 github.com/CloudOpsBench/CloudOpsBench/tree/main/…

Your AI agent is 40 commands into a CSS fix. You haven't read a single one. Command 41 tries to upload your .env to a random server. Tirith blocks it before it runs. v0.5 is live. The biggest release yet. Now with a plugin for @NousResearch's Hermes agent sheeki03/tirith t.co

MUSE邀请码：ZSJOLA 使用Muse2API，你将获得一个seedance2.0平替生视频用动机。 可以丢到你的无线画布里当一个模型供应商。 可以让你的agent直接无脑调用。 还支持矩阵号，无敌了！！！！ czg86389-hub/muse2api

I just made 10 skills that stop assistants from refusing harmless requests lol Ask an assistant how to “kill all zombie child processes and nuke the hung Docker containers” and some of them stall on two words. I kept hitting that, so I wrote ai-anti-overrefusal-skills: ten Agent Skills for assistants that refuse, stall or lecture when the request is fine. - This is the decision order I wrote into the skills, in case you’d rather paste it into your own prompt: 1. Read the whole request instead of single words, and check it against known false-refusal patterns (XSTest, OR-Bench). 2. If copyright is the worry, look up the status first: public domain, CC0, Creative Commons, open-source license. With no search tool, say the status couldn’t be checked and quote nothing long. 3. If the request is fine, answer in full with no disclaimer. 4. If a hard boundary remains, say so in under 25 words with no judgment words, then do the closest allowed thing. The repo splits that into ten skills with one job each. The four that matter most: - think-before-refusal decides whether to refuse - deep-work-unblocker keeps security, reverse engineering, sysadmin, medical and legal work at full depth - pragmatic-collaborator picks defaults instead of asking five questions, and asks first only for destructive actions or a missing target - no-preachy-tone cuts lectures, “As an AI” openers and trailing disclaimers Real limits stay. Weapons, malware, sexual content involving minors, doxxing, self-harm methods for at-risk users and stated intent to hurt someone are refused whatever the framing, in under 25 words, followed by the closest useful help. Limits of the repo is no benchmark numbers yet, just one case study (a DLL injection script for a Vietnamese localization mod of an old offline game, refused without the skills, written with them). It includes test prompts and a rubric so you can check on your own setup. Install as a Claude Code plugin: /plugin marketplace add Vumb-VibeCoder/ai-anti-overrefusal-skills MIT licensed: Vumb-VibeCoder/ai-anti-overrefusal-skills if you have any issues, just dm me then I'll update this repo

@BearHuddleston Fix hermes-agent#122463 so my companies cyber team stops freaking out on me. I may have to ditch Hermes until that is resolved

Anthropic FlashProve: Verifiable AI Outputs for Developers > TL;DR: Anthropic FlashProve is an open-source research prototype that uses zero-knowledge proofs (zkSNARKs) to cryptographically verify that an AI model's output came from a specific set of committed weights, without revealing those weights. This allows developers to build AI applications with auditable an When you build an AI application, especially one that makes consequential decisions, how do you prove to your users that the output they receive actually came from the model you claim it did? It's a fundamental trust problem: a routing service could swap in a cheaper, less capable model, or an attacker could subtly alter the output stream. Simply getting a "good" answer doesn't guarantee its origin. We need a way to cryptographically attest to an AI's output. What FlashProve Does Anthropic's FlashProve, an open-source research prototype unveiled on November 2, 2026, directly tackles this challenge. It provides a method to cryptographically verify that a large language model's response originated from a specific, committed set of model weights without revealing the weights themselves. This means you can prove the provenance of an AI-generated output, moving beyond simple content detection to a verifiable guarantee of its origin. As a Senior Frontend Developer building an AI-powered SDR agent platform, I know firsthand the pain points around validation and error handling in AI systems. Most AI agent projects fail in production not because of the model's intelligence, but due to a lack of robust verification that the system is operating as intended. FlashProve offers a way to establish that foundational trust. The system is built on zkSNARKs (zero-knowledge succinct non-interactive arguments of knowledge), a type of cryptographic proof. A zkSNARK allows one party (the prover, in this case, the AI model provider) to convince another party (the verifier, your client application or an auditor) that a computation was performed correctly, without revealing the private inputs behind it. For AI, this means proving an output came from a specific model without exposing proprietary model weights or intermediate computation values. It's designed specifically for mixture-of-experts (MoE) language models, leveraging their architecture for proof generation. How the Proof Works FlashProve operates in two main phases: 1. Offline Commitment: The model provider first publishes a small cryptographic commitment to an exact set of neural network weights. This commitment, roughly 6.5 MB, is generated once and takes about 39 minutes. This initial step effectively "fingerprints" the model being used. 2. Online Proof Generation and Verification: For each prompt and response pair, the system generates a succinct proof that the output tokens were indeed produced by the committed model. This proof is approximately 19 MB for a 1,024-token request. Anyone with the commitment, the prompt, and the response can then check this proof on a standard CPU, typically within 17 to 21 seconds, without needing access to the actual model weights or a GPU. The underlying principle ensures completeness (an honest proof is accepted), soundness (a false statement cannot be certified without breaking cryptographic assumptions), and zero-knowledge (the proof reveals nothing about the weights or internal computation beyond the correctness of the output). Anthropic tested FlashProve on Meta's Llama 4 Maverick, a 400.7 billion-parameter MoE model, achieving proof generation at about 110 tokens per second on a single NVIDIA H100 GPU. Who Should Care Developers working in domains where the integrity and auditability of AI outputs are non-negotiable should pay close attention. This includes: - Legal Tech: Verifying that AI-generated legal summaries or document analyses come from approved models. - Finance: Ensuring AI-driven trading recommendations or fraud detection outputs are from certified systems. - Secure Agents: Building autonomous AI agents where proving an action was performed by a specific, trusted agent model is critical. For instance, in an agent system responsible for lead enrichment and personalized outreach, being able to cryptographically prove that a specific message was crafted by a known, qualified agent model offers a layer of trust that simple logging cannot. This aligns with challenges in Validating AI Agent Outputs with Explicit Pass Conditions. - Regulatory Compliance: Meeting future regulations that demand verifiable AI systems. A Practical Limitation While FlashProve represents a significant leap, it's essential to acknowledge its current overhead. Generating these cryptographic proofs is computationally expensive. Anthropic's benchmarks show that proving requires roughly 70 to 95 times the GPU time compared to serving the model without proofs, using vLLM for inference. This high proving cost means FlashProve, in its current research prototype form, isn't practical for verifying every single token in high-throughput production environments. It's more suited for critical audits or spot checks where the cost is justified by the need for verifiable trust. The proof size, around 19 MB per 1,024-token request, is also substantial for continuous, real-time verification at scale. For now, FlashProve demonstrates the possibility of verifiable AI inference, with the next challenge being to significantly reduce this computational burden. Sources - Anthropic Releases FlashProve for Cryptographic AI Inference Proofs - Unite.AI - Anthropic's FlashProve uses zero-knowledge proofs to verify large AI model outputs - Progress on provable inference for large language models - Anthropic - Zero-Knowledge Proofs for AI Agent Verification and Privacy | Zylos Research - Anthropic FlashProve: Proving Which Model Answered - CellCog - Anthropic's Proof of Which AI Answered Costs 70-95x GPU Time - FourWeekMBA --- Written by Kamal Kishor (@koolkamalkishor) — Sr. Frontend Developer building AI agents (React, TypeScript, LangChain). LinkedIn · GitHub · Portfolio Published: 03 Nov 2026. This article was generated with AI (Google Gemini + web search). Please check important details against the sources above.