标签：#tools

Work shouldn't cost you your health Discussion | Link

This week's tooling news clusters around two themes that don't usually arrive together: token-efficient multimodal reasoning and infrastructure-level agent safety. The Inkling model launch dominates the conversation, but the more quietly significant story is Microsoft and Vercel independently shipping primitives that make running untrusted agent code and managing agent credentials meaningfully less dangerous. Here's what's worth your attention. Inkling mixture-of-experts model enables token-efficient reasoning Inkling is a decoder-only MoE with 1T total parameters and 40B active per token, native multimodal I/O (text, image, audio), and a reasoning_effort API parameter that lets you tune compute depth per request. It's live on Together Serverless today with no capacity queue. The practical upside is architectural simplification. If you're currently chaining a vision model, a transcription service, and a text LLM into a single reasoning pipeline, that's three API clients, three failure surfaces, and three billing relationships. Inkling collapses that into one endpoint. The reasoning_effort knob is the other interesting piece—per-request control over inference depth means you can spend tokens proportionally to task complexity rather than paying full reasoning cost on every call. The caveat: exact reasoning_effort parameter values aren't fully documented yet. Don't hardcode assumptions about accepted values into production before checking the official docs. Verdict: Evaluate. Worth spinning up against your current multimodal workload to benchmark latency and cost. Hold production migration until parameter documentation stabilizes. Inkling open model handles image, text, and audio natively This is the self-hosted side of the same model. The 1T-parameter MoE ships with day-0 support in transformers 5.14.0+ and SGLang, plus llama.cpp quantizations for teams that want to run trimmed variants. The catch is hardware: full NVFP4 precision requires 600GB VRAM; BF16 needs 2TB.

Open-source Mac dictation App that's 100% on-device Discussion | Link

Your teachable AI intern for everyday browser work Discussion | Link

Modern window dimming, built for focus for macOS Discussion | Link

AI Coworkers that run your projects and operations Discussion | Link

Catch mistake fares before airlines fix them Discussion | Link

Turn codebases into interactive maps, graphs, and governance Discussion | Link

Private inference for coding agents Discussion | Link

Find, research, and reach the right people Discussion | Link

Give every AI agent trusted context Discussion | Link

Publish and grow your profile across social apps Discussion | Link

See how a brain reacts to your clip Discussion | Link

I have a script called git_commit.py in one of my repos. It shells out to claude -p with the staged diff, gets back a Conventional Commit message, and prints it. It's wired into a prepare-commit-msg git hook so every commit gets a pre-filled message for free. Small, dumb, useful. The first version had one instruction in the system prompt: "Output ONLY the commit message — no explanation, no markdown, no quotes." That's it. It worked fine for a while, and then one day a commit landed with a trailing Co-Authored-By: Claude <noreply@anthropic.com> line that I never asked for and definitely didn't want on a personal repo's history. I did the obvious thing first: I made the prompt more specific. SYSTEM = ( " You are a git commit message generator. " " Output ONLY the commit message — one line, no explanation, no markdown, no quotes, " " no co-author lines, no signatures, no AI references. " " Follow Conventional Commits: type(scope): subject. " " Types: feat, fix, docs, style, refactor, test, chore. " " Subject: imperative, lowercase, max 72 chars. " ) This is the same move I see everywhere: the CLAUDE.md file in that same repo has a line that says, in bold, "NEVER add Co-Authored-By: or any Claude/AI reference to commit messages." I've seen the same pattern in a dozen other people's prompt files — a growing list of "never do X" instructions bolted onto a system prompt, each one added reactively after X happened once. It helped. It did not solve it. A model call is a sample from a distribution, not a function with a guaranteed return type. Any single generation can still ignore an instruction — a longer diff, a different day, a subtly different phrasing of the request, and the same "never" line just doesn't fire. I don't actually know the mechanism on any given miss and I don't need to. The point is: a natural-language instruction is advisory. It shifts probability mass, it doesn't clamp it. I ran into an article on dev.to making a point that reframed this for me: the al

Turn any 3D model into a buildable brick model Discussion | Link

AI schedules your whole week to take action Discussion | Link

A markdown editor you and your agent co-edit Discussion | Link

Last year my team had to pick a coding agent, and I volunteered to run the evaluation. I felt good about it. I pulled up the public benchmark scores, lined up the contenders, took the one at the top, and told everyone we had a winner. Then we actually pointed it at our repo. It did not blow up dramatically. It just kept being slightly wrong in ways that ate our time. It wrote diffs our reviewers would not approve. It renamed a function and broke three files it had never opened. The tests it ran passed, and the repo was still broken. I had confidently recommended a tool based on a number that turned out to say almost nothing about our situation. That was embarrassing enough that I went and figured out why. It took a few weeks of reading and a couple more bad calls before I landed on something that works. This is that, written plainly, and I hope it saves you the meeting where you have to walk your recommendation back. Why the benchmark score lied to me The score was not fake. It was just measuring somebody else's code. Once I looked properly, four gaps explained the whole thing: The agent might have already seen the answers. The problems in these public benchmarks are old. Models were very likely trained on the actual fixes used to grade them. So the score partly measures memory, not problem-solving. The setup is nothing like real work. A benchmark gives the agent a clean repo, one clear issue, and one command to run the tests. My engineers give it a half-open editor, a messy branch, a Slack thread, and a reviewer comment. Completely different job. Our codebase has its own habits. Our internal libraries, our wrappers, our test style, the imports we ban. No benchmark knows any of that, so an agent can write textbook-perfect code that our reviewers still reject on sight. The bar for passing is way lower. A benchmark passes a patch if the broken test now passes. My team passes a patch if it does that, and does not break unrelated tests, does not reformat the whole file,

Microsoft Corp. today released software updates to plug at least 570 security holes in its Windows operating systems and other software, almost triple the number of vulnerabilities the software giant fixed in its record-smashing Patch Tuesday release last month. Microsoft attributed the burgeoning patch counts to vulnerability discoveries aided by artificial intelligence.

TL;DR: Graph renderings of blockchain transactions carry topology signals that serialize badly into token sequences. A hub node surrounded by 47 short-lived leaf wallets looks like a table of addresses and amounts in text form — recognizable only if you already know the pattern. 📖 Reading time: ~23 min What's in this article The Problem: Blockchain Forensics Needs Vision, Not Just Text Hardware and Environment Setup on MI300X Data Pipeline: Rendering Blockchain Graphs as Training Images Fine-Tuning Loop: LoRA on 7B vs Full-Parameter on 7B ROCm-Specific Failure Modes and How to Diagnose Them Inference Serving: vLLM on ROCm for Classification Throughput Verdict: When This Setup Makes Sense and When It Doesn't The Problem: Blockchain Forensics Needs Vision, Not Just Text Graph renderings of blockchain transactions carry topology signals that serialize badly into token sequences. A hub node surrounded by 47 short-lived leaf wallets looks like a table of addresses and amounts in text form — recognizable only if you already know the pattern. Rendered as an image, that star topology is immediately visible as a structural shape. The same applies to layering patterns in mixing operations, where funds move through sequential depth levels that form visually distinct bands, and to clustering signatures where tightly-coupled address groups show dense internal edges versus sparse external ones. A vision-language model can learn to classify on those shapes directly. A text-based LLM working from a transaction list has to reconstruct the topology from raw numbers, which is possible but brittle — edge count and clustering coefficient can be computed and injected as tokens, but that's you doing the feature engineering that the vision model can learn to do itself. The reason Qwen2-VL entered this experiment rather than a GNN is mostly practical. Graph neural networks are the academically correct tool for graph classification, but they require a fixed-schema graph dataset and a trainin