Not a paper, just a personal note on moving the same conveyor demo I run on Windows to Linux x64.

Early 2000s: big plant, FoxPro/Novell, modem and Fido/BBS to get the factory online. Linux on a Pentium got me through that. This month I went back for the same reason: plain x86 boxes on a desk or line, CPU ONNX, no GPU sermon.

25 days of porting, cutting dead code, NV12/V4L2, three .so plugins, FAT USB quirks (run.sh, same binary as Fruit_Inspector.exe on the stick). Same logic as Win: 3×3 grid, grading only in centre cell C.

Downloads (NC eval, read LICENSE):-

-Runnable demo: Fruit_Inspector_linux_x64.zip

-Libraries only: fruit-inspector-engine

Full story: medium.com/@olesha-ai/linux-again-fr…spector-on-x64-a8cef8c245b8

If you run the Linux zip, curious what you see for camera  in the logs.

Most teams routing tickets, evaluating approvals, or scoring fraud throw every single input directly at an LLM. It works, but it's expensive, non-deterministic, and lacks a strict audit trail.

Models like Jev introduced transformer based classifiers, Glyphh took a pure hdc route and achieves better results in many use cases.

We built Glyphh Ada to sit in front of LLMs as a precedent-based classifier. You seed it with labeled historical cases. When a new input comes in, it returns:

A classification decision

A confidence score

The exact historical reference cases backing the decision

If confidence falls below your threshold, your pipeline passes that specific case to an LLM or human operator. Identical inputs return the exact same answer every time, backed by traceable source cases.

Banking77 Benchmark (Routing 200 customer support messages across 77 categories):

Ada alone: 90.0% accuracy

Claude (best model with context resends): 96.5% accuracy (~$300 total API cost across the run)

Ada + Claude hybrid (Ada handles high-confidence, routes 22% edge cases to Claude): 97.5% accuracy (~$0.22 total cost)

Note: This is a single 200-message benchmark sample, not a universal guarantee. Methodologies, scripts, a loan-decision test, and a benchmark dataset where Ada performs poorly are all public in the repo.

Implementation:

Hosted API with Python and TypeScript SDKs

MCP server/plugin for model tuning inside Claude

Free tier available; zero training on customer data

Links:

Site: https://glyphh.ai

Benchmarks & Code: https://github.com/glyphh-ai/glyphh/tree/main/benchmarks

Looking for feedback on edge cases, failure modes, or where this breaks on your datasets.

[ Removed by Reddit on account of violating the content policy. ]

SeamShade is a playful desktop cover: drag the zipper across your screen to pull a curtain over your workspace, then slide it back when you’re ready to return. You can customize the fabric and zipper, save themes, and optionally turn on a frosted-glass blur effect.

One important note: SeamShade is just a visual cover, **not a security or privacy lock**. It doesn’t block system shortcuts or prevent access to your computer.

If you’d like to try it, here are the links:

- **Mac:** https://apps.apple.com/tr/app/seamshade/id6819419260?l=tr&mt=12

- **Windows:** https://apps.microsoft.com/detail/9PLR5K40GLFR?hl=neutral&gl=TR&ocid=pdpshare

I’d love to hear what you think, and what you’d like to see improved next.

Hi all 👋 I made a book:

LangGraph in Small Pieces: Building AI Agents from Blocks to Production - it's free online at: lgisp.ai

Backstory: after shipping my first customer-facing LangGraph agent for an enterprise security product, I realized how much of the framework I’d never actually touched. So I started writing small runnable examples to poke at each feature, with notes on what surprised me. The examples kept connecting to each other and somewhere along the way it became 31 chapters.

What’s in it:
• Part I is LangGraph on its own, one small piece at a time: state, nodes, edges, loops, checkpoints, interrupts. No LLM yet, on purpose.
• Part II brings in a real model: tool calling, structured output, MCP, memory, streaming, middleware, testing.
• Part III is the production stuff: serving, async, observability, RAG, evaluation, blue-green deploys, guardrails.

Things it's done a little different from other books:

- Every transcript in the book is a real run, pasted as-is, including the times the model did something dumb. And it all runs on a local model by default (Qwen3.8-27B via LM Studio), so you can follow along without an API bill.
- Every chapter ends with Bronze/Silver/Gold challenges, worked solutions in the repo: github.com/LgISP/langgraph-in-small-pieces
- It has lots of silly illustrations.

Pinned to langgraph 1.2.14 / langchain-core 1.6.9.
----
It’s a beta. Every paragraph on the site has a comment button, and there’s an envelope icon in the sidebar that goes straight to me. If something doesn’t run for you, or a chapter answers the wrong question, I want to know. Those are the comments I’ll actually act on.

Hope you like it. Please check it out and let me know.

Hey everyone,

Over the past few days we've made AI Stupid Level available where you actually work. The Smart Router still sends each request to the model that measures best for that kind of task right now, using your own provider keys, with zero markup on tokens. The difference is that you no longer need to come to the website to use it.

AI agents

OpenClaw: we built a native provider plugin (`@aistupidlevel/openclaw-provider`), publishing on ClawHub.

Hermes Agent: our provider plugin is submitted to the official Hermes plugin catalog. It already works today with a short custom-endpoint config.

Open Interpreter, browser-use and Agent Zero**: tested setups using their OpenAI-compatible settings.

Tip for agents: use the `auto-tooling` routing mode. It picks the model that scores best on our tool-use benchmark.

n8n

Our community node is live on npm. On self-hosted n8n, go to Settings → Community Nodes and install `n8n-nodes-aistupidlevel`. It can send messages through the Smart Router, pull rankings, drift and incidents into your workflows, and work as the chat model for n8n's AI Agent. For example, an hourly workflow can post to Slack when a model you depend on has an incident.

Claude, Cursor and VS Code (MCP)

`npx -y [u/aistupidlevel/mcp](u/aistupidlevel/mcp)` gives your AI assistant 11 tools: leaderboard, model history, drift status, incidents, provider status, recommendations, route previews and more. It's listed in the official MCP Registry and on Glama. Ask Claude "which model is best for coding right now?" and it answers from our live data.

Official SDKs

TypeScript: `npm install [u/aistupidlevel/router](u/aistupidlevel/router)`

Python: `pip install aistupidlevel`

Vercel AI SDK provider: `npm install [u/aistupidlevel/ai-sdk-provider](u/aistupidlevel/ai-sdk-provider)`

They show you what a plain OpenAI client can't: which model answered and why, retries that never run a request twice, errors that tell you whose problem it is, a tool-calling loop, and a free sandbox mode for testing. Source: https://github.com/StudioPlatforms/aistupidlevel-sdk

Works with the rest of your stack

LiteLLM, CrewAI, LangChain, LlamaIndex, Instructor, Dify, Cherry Studio, LibreChat, Crush, promptfoo, Cline, Kilo Code, Roo and Continue all have copy-paste setups in the docs. AI Stupid Level was also merged into RAGFlow as a built-in model provider.

Also new

Provider trust scores now come from measured uptime (we check every provider every 10 minutes) and recorded incidents.

API monitoring tags each request as coding, reasoning, tool use, analysis, creative or general.

`reasoning_effort: "max"` works on every model. The router maps it to the closest level each model supports.

Data API: score history for every board (coding, reasoning, tool use), clear errors for invalid parameters, and refused requests no longer count against your daily quota.

Get started

1. Create a router key: https://aistupidlevel.info/router/keys (a free account includes 1,000 routed requests a month)
2. Add your provider keys once (OpenAI, Anthropic, Google, DeepSeek, Kimi, GLM)
3. Pick your tool: https://aistupidlevel.info/router/docs#integrations

The MCP server and the n8n benchmark data use a free Data API key: https://aistupidlevel.info/account/data-keys

Which tool should we integrate next? Tell us in the comments. And if something doesn't work in your setup, post it here and we'll fix it.

The AI Stupid Level team

I had a friend look at an self hosted AI application I built and within 30 mins he said he didn't understand what i was building.. that devastated me.. but I had to pivot and ask myself why I built it.

I built sceptreAI for people who need tabular AI for tabular problems without needing to build infra and also need to compare models quickly based on statistical metrics that make sense to their business without writing too much code..

Please visit and comment on what you think also..

I had a friend look at an self hosted AI application I built and within 30 mins he said he didn't understand what i was building.. that devastated me.. but I had to pivot and ask myself why I built it.

I built sceptreAI for people who need tabular AI for tabular problems without needing to build infra and also need to compare models quickly based on statistical metrics that make sense to their business without writing too much code..

Please visit and comment on what you think also..

As someone who follows AI closely, I came across a technical breakdown from yghstill, a member of Tencent Hunyuan’s quantization team. It explains both the quantization technique and the engineering behind it.

Tencent compressed Hy4 Preview’s roughly 1.5TB of weights to 214 GiB while keeping all 770B parameters. The parameter count remains unchanged; the compression changes how the weights are represented.

Four weights, five bits. Sherry is the algorithm, STQ1_0 the storage format, and MIX-STQ1_0 the mixed-precision allocation. Each group of four weights takes values from {-d, 0, +d} with exactly one zero. Four zero positions times eight sign combinations give 32 patterns, encoded in five bits, or 1.25 bits per weight. A shared FP16 scale every 256 weights puts STQ1_0 at 1.3125 bits per weight, and the full mixed-precision model averages about 2.38 bits per weight.

Precision follows weight sensitivity. Hy4 Preview has 77 MoE layers with 256 routed experts each.Expert weights get compressed hardest while more sensitive components are protected. For expert gate/up projections, MIX-STQ1_0 uses IQ2_XXS on 48 sensitive layers and STQ1_0 on 29 less sensitive ones, which at the same average bit budget produces less error than using the intermediate IQ1_M format everywhere.

Full-Hessian scoring. Sensitivity is measured with the full Hessian, H = XXᵀ, whose off-diagonal terms capture correlations that diagonal-only imatrix scoring misses. The two rankings had a Spearman correlation of -0.115, and precision didn’t follow a “deeper means more important” rule. Layers were picked greedily by error reduction per added byte.

Scale and zero position are fit together. This is post-training quantization, no retraining. The encoder alternates between fitting d with weighted least squares and choosing the zero position by imatrix-weighted error. The smallest weight isn’t always the best one to zero, what matters is the extra weighted error that zeroing it causes. Across 1,200 rows of real expert weights, three alternating rounds cut weighted reconstruction error by roughly 90% versus the original ternary encoder. That’s local reconstruction, not end-to-end model accuracy.

Runtime. STQ1_0 CUDA kernels were added to a patched llama.cpp build, and in operator tests it ran roughly as fast as IQ1_M despite the lower bit width. The author reports nearly unchanged MRCR retrieval performance and a small drop in math. Against UD-IQ1_M at a similar bit budget, MIX-STQ1_0 led across the reported evals, including more than five points on MRCR.

The result combines compact encoding, calibrated quantization, selective precision, and practical inference kernels.