标签：#AI

Flock Safety faces a growing public outcry over concerns that its surveillance technology could be misused.

Voice and chat assistants for the home share a deceptively hard job: turning messy natural language into precise, structured commands. “Make it cozy in here” has to become a concrete intent plus the right slots — which device, which room, which value. Domux is an open model from iFlytek that focuses on exactly this problem: command understanding for smart-home assistants, framed as intent parsing and slot filling. What it is Task: smart-home command understanding — intent parsing + slot filling Base model: fine-tuned on google/gemma-4-E2B-it Modality: multimodal (image + text input) Target: edge / on-device deployment rather than large cloud models License: Gemma Why the compact base matters Building on the small Gemma-4-E2B base keeps Domux in a size class meant to run close to the device. For home assistants, that direction is attractive: keeping command understanding on-device can reduce round-trips and keep more interaction local, instead of routing every utterance to a large hosted model. Try it The model card is on Hugging Face (access is gated — you may need to log in and request access): 👉 https://huggingface.co/iFlytekOpenSource/Domux We're sharing open work like this because on-device, task-focused models are a practical piece of the foundation-model and serving story — not everything needs to be a giant cloud model.

The single biggest operational risk for early-stage founders remains hiring traditional hourly dev shops. Before partnering with any external dev team, I've learned to run them through this 5-point evaluation framework: The 5-Point Evaluation (co-founder approved) 1. Quality of Questions If a team asks zero questions, it’s an immediate red flag. It's impossible to deeply understand a project without asking anything. But quality matters. Weak devs ask easily googled questions about basic blockchain mechanics. Strong engineers ask highly specific questions focused entirely on your business logic, edge cases, and tokenomics. 2. Proposing Solutions, Not Problems (obvious one) A weak team will message you saying, "We have a problem, how should we fix it?" A mature team says, "We hit a blocker. Here are three architectural workarounds, the trade-offs for each, and our recommendation." 3. Deep Ecosystem Knowledge Coding isn't enough. If an agency claims they can build a top-tier lending protocol but doesn't understand the role of risk engines and oracles, they are tourists. Your developers need to know top-tier market leaders like Gauntlet, Steakhouse, Chaos Labs, and RedStone, and understand how their risk modeling and data feeds directly dictate market parameters. If they lack this context, their expertise is strictly surface-level. 4. Full Product Lifecycle Understanding Writing code and calling it a day is a massive mistake. A real partner understands what happens outside the IDE. They account for security audit buffers, integration with risk providers and oracles before mainnet, and the proper setup of on-chain governance and admin functions. 5. High Agency & Proactivity Elite teams care about your overall success, not just their Jira tickets. To quote a BD i work closely with: “When a client is about to make a massive mistake, you have two choices: stay silent and watch them fail, or step in with your expertise, even uninvited, and say: 'We hear what you want to do,

Most published authors have, without their knowledge or consent, contributed to the development of the same AI tools that threaten to undermine their livelihoods. That seems illegal, right?

Jane Schoenbrun's latest film, Teenage Sex and Death at Camp Miasma, is making a splash in theaters right now. So it seems like the perfect time to revisit their first film, We're All Going to the World's Fair. I fell in love with this film when I first saw it at Sundance in 2021. We […]

Concertos VR 2026: como o streaming imersivo está redefinindo o show ao vivo Introdução Você já imaginou estar no meio da plateia de um show de rock, sentir o pulsar dos graves e, ao mesmo tempo, poder pausar a cena, mudar de ângulo ou conversar com amigos que estão em outro continente – tudo sem sair da sua sala? Em 2026 isso já é realidade. Graças a headsets 4K mais baratos, plataformas de streaming de baixa latência e a mudança de comportamento do público, os concertos VR deixaram de ser ficção científica e se tornaram a principal forma de consumo musical ao vivo. Neste artigo vamos mostrar, passo a passo, como funciona essa revolução, apresentar casos de sucesso, analisar o impacto econômico e cultural e, principalmente, oferecer um guia prático para artistas, promotores e fãs que querem entrar nesse universo. 1. O que é um concerto VR? Um concerto VR é um evento musical transmitido ao vivo em 360° (ou 180°) e entregue em tempo real para um headset de realidade virtual. O espectador tem liberdade total para olhar ao redor, mudar de ponto de vista e interagir com objetos digitais – como luzes, efeitos e até avatares de outros fãs. Como a transmissão acontece (exemplo de pipeline) # 1. Captura 360° com câmeras Insta360 Pro 2 ffmpeg -i rtsp://camera1 -i rtsp://camera2 -filter_complex \ "[0:v]crop=3840:2160:0:0[left];[1:v]crop=3840:2160:0:0[right];[left][right]hstack=inputs=2[v]" \ -map "[v]" -c :v libx264 -b :v 15M -f rtp rtp://livevrx.com:5004 # 2. Ingestão no servidor de baixa latência (WebRTC) node livevrx-ingest.js --source rtp://livevrx.com:5004 --room concert2026 # 3. Distribuição para o headset (WebXR) <video id = "vrStream" autoplay playsinline webkit-playsinline src = "webrtc://livevrx.com/concert2026" crossorigin = "anonymous" > </video> Esse fluxo garante latência ≤ 30 ms , qualidade 4K por olho e sincronização perfeita entre áudio e vídeo. 2. Equipamento necessário Dispositivo Resolução mínima Preço (USD) 2026 Comentário Meta Quest 3 2 K por olho $399 M

I want to be upfront about something: this whole project runs on free Kaggle T4 notebooks, an AWS EC2 t3.micro relay that costs almost nothing, and public internet. No A100s. No private datacenter network. No budget. And yet, ShardFlow v2.1 hits 28.10 TPS peak on Qwen2.5-7B across two separate cloud regions over WAN. This is the story of how that happened, and specifically the one fix in v2.1 that I did not see coming. The Problem: Running a 7B Model When You Have No Money A 7B parameter model in FP16 needs roughly 15 GB of VRAM. A single Kaggle T4 has 16 GB. Technically it fits, barely, with nothing left over for a KV cache. The solution is tensor parallelism: split the model across two machines. Node 0 (Iowa) handles layers 0 to 14. Node 1 (Oregon) handles layers 14 to 28, plus the LM head and final verification. They talk to each other through a TCP relay running on an EC2 t3.micro in Ohio. The baseline throughput with this setup and no tricks: 4.92 TPS. Usable, but not fast. Speculative Decoding: The Idea LLM inference is slow because it's sequential. You generate one token, wait, generate another, wait. Each round trip across WAN costs you ~86ms RTT. At 1 token per round trip, you're fighting the network the whole time. Speculative decoding flips this. Instead of sending one token at a time, you run a tiny draft model locally to guess the next K tokens ahead. Then you send all K guesses to the verifier in one shot. If the big model agrees with M of them, you've committed M tokens in a single round trip instead of one. ShardFlow uses Qwen2.5-0.5B as the draft model, running on cuda:1 of Node 0 while the 7B target slice runs on cuda:0. Zero VRAM contention. The drafter proposes 8 candidates, Node 1 verifies them all in parallel, and you get an average of 4.07 tokens per round trip instead of 1. With speculative decoding in eager mode: 14.3 TPS peak. 3x better. The Wall I Hit I thought 14.3 was the ceiling. The network was the obvious bottleneck: two Kaggle instan

AI agents can look reliable after one impressive demo and still fail the moment real users, messy repositories, and conflicting instructions enter the room. The dangerous part is not that an agent makes mistakes. The dangerous part is that teams often change agent rules based on vibes, not evidence. If you are building an AI feature, internal coding agent, support assistant, research workflow, or automation layer, your standards need tests. Not just model evals. Not just unit tests. You need a way to answer a practical question: Did this new rule, skill, prompt, or tool instruction actually make the agent better? This guide shows a lightweight experiment system for AI agent standards. You can use it before rolling out new agent instructions across a product, engineering team, customer workflow, or multi-tenant AI application. No vendor pitch. No magic framework. Just a repeatable way to stop guessing. Why Agent Standards Need Experiments Most teams already have standards for human developers: code review rules security policies testing expectations deployment checklists naming conventions observability requirements AI agents need the same kind of guidance, but they behave differently from humans and traditional software. A human may read a coding standard once and remember the intent. An agent may load the wrong instruction file, ignore a rule buried deep in context, over-follow a stale example, or select no skill at all. That means the main risk is not only bad instructions. It is unreliable instruction delivery. Recent practitioner discussion around agentic development points to the same pattern: teams are moving from simple prompts toward skills, rules files, context packs, tool registries, desktop agents, and workflow harnesses. At the same time, developers are asking harder questions about governance, cost, reliability, and whether agents can be trusted with production work. What Counts as an AI Agent Standard? An AI agent standard is any reusable instruction t

This is The Stepback, a weekly newsletter breaking down one essential story from the tech world. For more on GTA VI and the state of the video game industry, follow Andrew Webster. The Stepback arrives in our subscribers' inboxes at 8AM ET. Opt in for The Stepback here. How it started Four years ago, fans […]

MCP Was a Mistake. Here Are 200,000 Tokens That Prove It. "mcp were a mistake. bash is better." — Peter Steinberger, OpenClaw founder I didn't want to believe it either. MCP was supposed to be the USB-C of AI — one protocol to connect everything. Anthropic, OpenAI, Google all backed it. 97 million monthly downloads. 17,000 servers. But then I measured what MCP actually does to your context window. The Setup I connected 10 popular MCP servers to a token counter. Here's what happened before I typed a single word: Server Tools Tokens Injected Filesystem 11 3,847 Brave Search 8 2,103 Sequential Thinking 3 890 Memory 9 2,567 Puppeteer 15 5,890 Postgres 19 8,231 Notion 24 13,780 GitHub 28 12,440 Slack 22 14,672 Google Drive 31 47,293 Total 170 111,713 111,713 tokens. Before your first message. That's not a typo. Connecting 10 MCP servers to Claude means over 100K tokens of JSON schemas get injected into your context window. You haven't asked a question yet. You haven't made a tool call. The schemas are just... sitting there. The Math That Made Me Angry At Claude 3.5 Sonnet pricing ($3/M input tokens): Every conversation starts with 111K tokens of overhead: $0.33 20 conversations per day: $6.67/day 22 working days per month: $147/month Annual cost of JSON schemas: $1,764 That's more than a Claude Pro subscription. You're paying $1,764/year to read JSON braces describing tools you might never use. But Wait — It Gets Worse The 111K is just the schema injection. When you actually call a tool, MCP wraps the result: { "content" : [ { "type" : "text" , "text" : "{ \" file \" : \" app.py \" , \" size \" : 1024}" } ] } The actual content is 38 characters. The wrapping is 47 characters. 55% of your result tokens are JSON overhead. With 20 tool calls per conversation: Schema injection: ~111K tokens Result wrapping: ~18K tokens Total overhead: ~130K tokens per conversation Your $0.54 conversation now has 130K tokens that serve zero purpose. What Garry Tan Was Right About When YC's CE

Claude Code Is Burning Your Token Budget. Here's the Receipt. I found $2,500/year of hidden token waste in my Claude Code setup. It was the MCP servers. The Discovery Last week I noticed my Claude Code conversations were dying at around message 15. Context window full. The model starts forgetting earlier instructions. Tool calls fail. The conversation degrades into hallucination. I assumed it was my fault — too many messages, too much context. So I started measuring. Here's what I found: Session start: Claude system prompt: ~8,000 tokens MCP schema injection: ~111,000 tokens User's first message: 50 tokens ────────────────────────────────────────── Total before any work: ~119,000 tokens Remaining context: ~81,000 tokens I was starting every conversation with 60% of my context already consumed. The culprit wasn't my prompts. It was the 10 MCP servers I had proudly configured in my claude_desktop_config.json . The Receipts I measured each server's schema injection using tiktoken: Server Why I Installed It Token Cost Times Used/Week GitHub PR reviews, issues 12,440 3 Slack Message reading 14,672 0 Google Drive Doc access 47,293 1 Notion Knowledge base 13,780 2 Postgres Query DB 8,231 4 Puppeteer Screenshots 5,890 0 Filesystem File access 3,847 15 Brave Search Web search 2,103 5 Memory Context persistence 2,567 0 Sequential Thinking Reasoning 890 2 Total 111,713 Look at the "Times Used/Week" column. Three servers were used zero times. Two more were used once or twice. But every single one of them was injecting 100% of its schema into every conversation. I was paying $0.33 per conversation — $2,500/year — to load schemas for tools I barely used. The Moment I Realized Everyone Has This Problem I posted my findings on Bluesky. Within hours: "I had the same issue. Removed 6 MCP servers and my conversations went from dying at message 15 to lasting 40+ messages." — @developer1 "GitHub MCP is 12K tokens but Claude Code already has gh CLI built in. Why did I install it?" — @dev

Garry Tan Was Right: "MCP Sucks Honestly." I Have the Token Receipts. "MCP sucks honestly. Context window eats too much, auth is a mess. I wrote a CLI wrapper in 30 minutes and it works better." When YC's CEO says this on X, people listen. But nobody had the data to back it up. Until now. What Garry Tan, Perplexity's CTO, and 97 Million Downloads Can't Hide Three things happened in the last 6 months that changed how I think about MCP: Peter Steinberger (OpenClaw founder) tweeted: "mcp were a mistake. bash is better." Eric Holmes wrote "MCP is dead. Long live the CLI" — it hit HN frontpage Denis Yarats (Perplexity CTO) publicly announced they're replacing MCP with REST API + CLI internally Garry Tan (YC CEO) replied: "MCP sucks honestly" The community split into two camps: "MCP is dead" — CLI is simpler, cheaper, faster "MCP is fine" — 97M downloads, 17K servers, it's the standard Both are wrong. The problem isn't MCP. The problem is what MCP does to your context window. The 47,000-Token Problem Nobody Measured I connected 10 MCP servers to a token counter. Here's what I found: MCP Server Tools Token Cost Equivalent Sequential Thinking 3 890 This blog post Brave Search 8 2,103 A short email Filesystem 11 3,847 A README Memory 9 2,567 A meeting note Puppeteer 15 5,890 A chapter of a book Postgres 19 8,231 A whitepaper GitHub 28 12,440 A court filing Notion 24 13,780 A legal contract Slack 22 14,672 A novella chapter Google Drive 31 47,293 Half of a novel Total 170 111,713 A short book One MCP server — Google Drive — injects 47,293 tokens into your context before you ask a single question. The entire works of Shakespeare is 900K tokens. Google Drive's schema is 5% of Shakespeare. For listing files. The Cost Breakdown (So You Can Get Angry Too) At Claude 3.5 Sonnet pricing ($3/M input tokens, $15/M output): Scenario Tokens Cost Annual Cost 1 server (minimal) 3,847 $0.01/conv $4.40/yr 3 servers (common) 14,528 $0.04/conv $19.40/yr 5 servers (typical) 33,061 $0.10/conv $4

I Benchmarked 10 MCP Servers — One of Them Burns 47K Tokens Just to Say Hello 10 popular MCP servers. 847 tools total. 312K tokens of JSON schemas. One server alone wastes more tokens than a full GPT-3 conversation. Here are the results. What I did I installed the 10 most popular MCP servers from the official registry. Connected each one to a token counter. Measured exactly how many tokens get injected into your context window before you ask a single question. The servers: # Server Tools Token Cost 1 Filesystem 11 3,847 2 GitHub 28 12,440 3 Postgres 19 8,231 4 Puppeteer 15 5,890 5 Brave Search 8 2,103 6 Memory 9 2,567 7 Sequential Thinking 3 890 8 Slack 22 14,672 9 Google Drive 31 47,293 10 Notion 24 13,780 Totals: 847 tools across 10 servers 111,713 tokens of JSON schemas 200,000+ tokens including server status messages, headers, and error schemas That's right — connecting 10 MCP servers to Claude means 200K tokens of overhead before your first message . The worst offender: Google Drive Google Drive's MCP server exposes 31 tools. Each tool has deeply nested schemas for file operations, permission management, sharing, and search. The full schema dump: { "name" : "drive.files.list" , "description" : "Lists files in the user's Google Drive with optional filtering" , "inputSchema" : { "type" : "object" , "properties" : { "q" : { "type" : "string" , "description" : "Query string for filtering files..." }, "corpora" : { "type" : "string" , "enum" : [ "user" , "domain" , "sharedDrive" , "allDrives" ]}, "includeItemsFromAllDrives" : { "type" : "boolean" }, "orderBy" : { "type" : "string" }, "pageSize" : { "type" : "integer" }, "pageToken" : { "type" : "string" }, "spaces" : { "type" : "array" , "items" : { "type" : "string" }}, "supportsAllDrives" : { "type" : "boolean" }, "fields" : { "type" : "string" } }, "required" : [] } } That's ONE tool. 31 of them. At ~1,525 tokens per tool average. 47,293 tokens. Just for Google Drive. For comparison, the entire works of Shakespea

OVHcloud will raise prices from September, with 2026-edition gaming servers up 87 percent and other recent servers 40 to 59 percent. Founder Octave Klaba says memory cost six times more in June than a year earlier, as RAM suppliers shifted capacity toward high-bandwidth memory for AI. AWS, buying years ahead, has repriced one reserved GPU product. By Steef-Jan Wiggers

Originally published on tamiz.pro . Introduction We are witnessing a fundamental shift in software architecture: the transition from passive APIs to active agents. While the industry has been obsessed with the race for Artificial General Intelligence (AGI) through massive cloud models, a parallel, often under-discussed revolution is happening locally. This is the emergence of the Agentic Operating System —a local-first stack where autonomous agents don't just chat; they operate files, manage repositories, and execute workflows using private, locally-hosted LLMs. This is not merely about privacy, although privacy is a critical driver. It is about latency, determinism, and the "Planning Problem"—the architectural gap between reasoning (what to do) and execution (doing it). Frameworks like Eliza have demonstrated that lightweight characters can maintain persistent state and tool usage. Meanwhile, projects like Hister are pushing the boundaries of agentic file-system manipulation. In this deep dive, we will dissect the architecture of a private agentic OS, analyze the mechanics of local orchestration, and address the hard engineering challenges of tool use and planning. 1. The Architecture of a Local Agentic OS A "private agentic OS" implies a software layer that sits between the user and the machine's resources (file system, network, CLI), mediated by an LLM running entirely on-device or within a private VPC. Unlike a traditional shell, which requires explicit human input for every command, an agentic OS maintains an internal state and can execute multi-step plans autonomously. 1.1 The Core Components To build or understand such a system, we must deconstruct it into five distinct layers: The LLM Layer (The Brain): This is the inference engine. In a private OS context, this is almost exclusively a local model (e.g., Llama 3, Mistral, Qwen) running via inference servers like llama.cpp , vLLM , or Ollama . The Memory Layer (The State): Agents need context beyond the immed

If your mental model of RAG is "chunk → embed → search → LLM," you're missing about 80% of what actually makes a RAG system production-ready. Here's a practical checklist across all 10 lifecycles I ran into while building one. Full technical breakdown with diagrams is on Hashnode (linked above) — this is the condensed, "what to actually check" version. ✅ Document lifecycle [ ] Can you update a single document without a full re-index? [ ] Do you have a deletion path (not just an addition path)? [ ] Are you deduplicating before you embed? ✅ Embedding lifecycle [ ] Do you know what happens if you switch embedding models? [ ] Are you tracking dimensions and normalization consistently? [ ] Can you re-embed the whole store without downtime? ✅ Retrieval lifecycle [ ] Are you tuning Top-K, or using a default and hoping? [ ] Do you have metadata filtering before similarity search? [ ] Have you tried hybrid (keyword + semantic) search yet? ✅ Inference lifecycle [ ] Do you know your cold-start latency vs. warm inference? [ ] Are you tracking tokens/sec as a real metric, not a vibe? [ ] CPU or GPU — did you choose, or did it choose you? ✅ Prompt lifecycle [ ] Are you compressing context, or dumping everything retrieved? [ ] Do you track input vs. output tokens separately? [ ] Is your system prompt fighting your retrieved context? ✅ Request lifecycle [ ] Can you see latency broken down by stage (embed / retrieve / generate)? [ ] Do you know which stage is your actual bottleneck? ✅ Cache lifecycle [ ] Are you caching query embeddings? [ ] Are you caching full responses for repeated questions? ✅ Evaluation lifecycle [ ] Can you measure retrieval precision/recall? [ ] Do you have a faithfulness or answer-relevance check? [ ] If you "improved" something, can you prove it? ✅ Production lifecycle [ ] Health checks, retries, rate limiting — in place or assumed? [ ] Are secrets actually out of your codebase? [ ] Do you have CI/CD, or are you deploying by hand? ✅ Cloud lifecycle [ ] Do y

I spent two months building Vestibule, an open-source Python framework for the boring layer of RAG ingestion — stable document IDs, a state ledger, error classification, per-vertical governance. The parts every team struggles with once the demo works and production doesn't. Most of the code wasn't typed by me. Four AI agents did the work — one wrote designs, one reviewed them, one implemented, one reviewed the code — all through real GitHub pull requests, with me signing off at every gate. The result: twelve components, three releases, 878 tests. Two moments defined the whole experience. When the process caught what I couldn't The trickiest component provisions vector indexes on first use, safely even when workers race each other. Its design was rejected and revised five times before any code existed. In the first round, the reviewer agent found a genuine race condition: a worker still inside a slow index-creation call (~390 seconds with retries) would look stale (the threshold defaulted to 300 seconds), lose its claim to a waiting worker, and now two workers create the same index. A production race, in the default configuration, spotted by one AI reading another AI's design — before a single line was written. When green tests lied to me After v0.2 shipped, I wrote a quickstart script and ran the pipeline the way a stranger would — for the first time. pip install didn't work. At all. A packaging conflict made the whole framework uninstallable, while 483 tests sat green. An hour of actually using it turned up two more: a default model name that had never once worked against the real SDK, and an import that took down an entire package when an optional dependency was absent. What went wrong wasn't the tests — it was what they measured. They proved the code agreed with itself: same working tree, same mocked seams. Nothing ever checked the world a user lives in: clean machine, real install, real SDK. Passing tests and a working product turn out to be two different claims

Control Plane (Master) & Worker Nodes Control Plane components: API Server Scheduler Control Manager etcd Worker Node components: Container Runtime Kubelet Kube-proxy Node Processes Each node has multiple Pods on it. 3 processes must be installed on every node — used to schedule and manage those Pods. Nodes are cluster services that actually do the work. Container Runtime Examples: Docker, containerd, CRI-O. containerd is used in worker nodes — it's lightweight in nature. This should be installed on every node because application Pods need to run containers inside the node. Kubelet The process which schedules the Pods and containers underneath is Kubelet. Kubelet interacts with both the container and the node. Kubelet starts the Pod with the container inside. Communication between two nodes is because of Services. Creation of Pod: Kubelet insures the Pod is always running — if not, it will inform etcd. Kube-proxy Kube-proxy forwards the request from Pod to Service. Makes use of the communication, with load balancing. Provides networking (container ID, IP address). Load balancing — basically using IP tables. It makes sure to send the request to the same machine instead of sending it to others (from same node communications). So, how do you interact with this cluster? Schedule the Pod Monitor Re-schedule/restart the Pod Join a new node Managing processes are done by master nodes (the control plane). API Server When you, as a user, want to deploy a new application in a Kubernetes cluster, you interact with the API server using some client — could be UI or CLI. It's a cluster gateway — it gets the initial request of any update into the cluster, even the queries from the cluster. It also acts as gatekeeper for authentication. It means when you want to schedule new Pods, deploy new applications, create new services, or any other components — you have to talk to it first. Flow: Some request → API server → Validates request → Other processes → Pods Only one entry point to t

A generic image model is rewarded for producing a convincing picture. A virtual-staging system has a stricter job: produce a convincing picture without changing the property being represented . That distinction sounds small until you build a workflow around real listing photos. A beautiful render can still be unusable if a window moves, a doorway narrows, the floor line bends, or the apparent depth of the room changes. The model has improved the image while damaging the information. This is why I have come to think of virtual staging as a constraint problem rather than a styling problem. The source photo is part of the product contract In an inspiration tool, the uploaded image is a prompt. In a listing workflow, it is evidence. The walls, windows, doors, flooring, built-ins, camera position, and room proportions describe a property that a buyer may later visit. Those elements are not raw material for creative interpretation. They are invariants. That changes how the product should talk to users. Instead of asking only, “Which style do you want?”, the interface should also make the operational boundaries clear: Is the room empty or furnished? Should movable furniture be replaced? Which architectural elements must remain untouched? Is the result intended for an MLS, a brochure, or a social post? Does the final image require a disclosure label? These questions are not secondary settings. They define the job. Separate movable objects from structural truth One practical design decision is to treat furniture replacement and room staging as related but distinct operations. An empty room needs furniture added. A furnished room may need existing movable objects removed or replaced before new furniture is introduced. If the system treats both cases as “redesign this image,” it is more likely to improvise around everything in the frame. A better mental model is: Preserve the structural layer. Identify the movable layer. Replace or add only what the user requested. Compare the

skillcheck is a static analyzer for SKILL.md files, the format agents like Claude Code, Copilot, Codex, and Cursor use to load reusable skills. It validates frontmatter, scores description discoverability, checks file references, enforces token budgets, and flags cross-agent compatibility issues. No network calls, no LLM calls, no file mutations. Runs as a CLI, a GitHub Action, or a pre-commit hook. pip install skillcheck skillcheck skills/ Latest pass was hardening and accuracy, not features. Here's what changed and why. Description scores went up. Skills that were scoring low because the scorer was broken will now see a jump in scoring. Median across the reference corpus went from 75 to 90. --explain-score also now tells you which pattern hits or misses instead of just a number. The score exists to predict whether an agent will actually find and trigger your skill, so a scorer that under-credits good descriptions defeats the point. The fix was validated against real-world skills, and the separation held: filler still scores 28-65, well-written descriptions 85-100. Corrupt files now fail cleanly instead of crashing. Before, a bad history ledger or non-UTF-8 skillcheck.toml above the skill dumped a Python traceback. It's now a clear error naming the file and byte offset (exit code 2). Config discovery walks up the directory tree, so one bad file could break every scan under it. Now every untrusted read (ingest, history, config) goes through the same guard before parsing, so they all reject the same way. README has been corrected in regards to token estimates. Without tiktoken, expect roughly 20-30% over-estimation, so install the extra if you're near a budget limit. The offline heuristic feeds the budget checks and its accuracy had never actually been measured, just assumed. It's benchmarked against tiktoken across the full corpus now, and the documented numbers are the measured ones. pip install "skillcheck[tiktoken]" The rest of the pass is invisible on purpose: f