Ai on Christian Roy

The RAID Array That Kept Losing a Disk on Every Reboot

Tue, 07 Jul 2026 00:00:00 +0000

A NAS owner’s account of a firmware bug that dropped a healthy disk on every boot, and how I used Claude Code to reverse-engineer the fix out of the closed-source firmware.

A quick note on this post before we start: the NAS is mine, the problem was mine, and the tests (and the swearing) were mine. The deep reverse-engineering, disassembling the firmware’s own binaries and tracing data flow instruction by instruction, was done by Claude Code, which I drove and second-guessed throughout. So when you read “Claude found,” that is literally what happened. When you read “I rebooted and it was still broken,” that is me being the reality check. It was a genuine back-and-forth, and it is worth being honest about who did which part.

NOVA·FM: an endless AI radio station built on Stable Audio 3

Sun, 31 May 2026 00:00:00 +0000

NOVA·FM is a radio station with no library and no playlist. Every track is composed on the spot, seconds before it reaches your ears, then fades and is never reheard in quite the same shape. I built it in two days with Claude Code (Opus 4.7 and 4.8), guided by me, on top of Stable Audio 3, Stability AI’s open-weight audio model family released earlier this month.

More than seven stations so far, each a mood rather than a folder: lo-fi, synthwave, cinematic, deep house, jazz, ambient, classical, and a few more I keep adding. Two ways to listen: a private dial that’s just for you, and a shared live signal where everyone tuned in hears the same track at the same second.

opencode with a local Qwen3.6-35B-A3B backend iterated to a working color-physics web toy

Thu, 14 May 2026 00:00:00 +0000

I gave opencode a single-paragraph spec for “an HTML canvas where colored circles attract similar hues and repel opposites,” and pointed it at unsloth’s quant of Qwen3.6-35B-A3B (UD-Q8_K_XL, ~3B active params) running locally. About a dozen steering turns later, fixing bugs and nudging the behavior, I had a working single-file demo.

That is the part worth noting. Not one-shot, not magic: a small MoE that fits on one GPU, driven through an agentic loop, can converge on a real interactive artifact in a reasonable session. Local coding agents are becoming a usable workflow, not just a demo.

Gemini 3.1 Flash Live: Low-latency voice AI with native audio output

Fri, 27 Mar 2026 00:00:00 +0000

Google launched Gemini 3.1 Flash Live via the Live API for building real-time voice and vision agents. The model processes continuous audio, video, and text streams to deliver immediate spoken responses with acoustic nuance detection and 90+ language support.

Key improvements over Gemini 2.5 Flash Native Audio:

Better noise filtering in real-world environments
Stronger adherence to complex system instructions
More natural dialogue with improved latency
Thinking capability via thinkingLevel (minimal/low/medium/high) instead of thinkingBudget

The model outputs native audio (no STT+TTS pipeline) with a 128k context window. It supports synchronous function calling, Google Search grounding, and video input alongside audio.

Asana's official Claude MCP connector can't create tasks in Claude Code CLI because its tools require interactive UI

Thu, 26 Mar 2026 00:00:00 +0000

Asana’s official Claude connector uses a tool called create_task_preview instead of create_task. The name suggests a preview, but it’s actually the primary creation tool in the v2 integration. The catch: it requires an interactive UI to render a confirmation step. Claude Code CLI can’t render that interface, so task creation silently fails.

This was surfaced in the Asana forum after create_task also went missing from v1 toolset temporarily (Asana accidentally dropped it during a v2 update, now restored). Asana confirmed the CLI issue separately and said they’re working on detecting whether the surface supports interactivity before offering interactive tools. ETA: about a week from March 26.

Cohere Transcribe beats Whisper Large v3 on the HuggingFace ASR leaderboard with a 2B open-source model

Thu, 26 Mar 2026 00:00:00 +0000

Cohere, best known for text and embedding models, just shipped a speech recognition model that hits #1 on the HuggingFace Open ASR Leaderboard: 5.42% average WER versus Whisper Large v3’s 7.44%. It’s 2B parameters, Apache 2.0, available on HuggingFace today.

The architecture is a Conformer: a hybrid of CNNs and Transformers. CNNs handle local acoustic features (phonemes, rapid transitions), Transformers handle global context. Interleaving them is the standard trick for ASR; Cohere’s bet is that a dedicated, from-scratch training run focused on WER beats the generalist approach.

Tencent's Covo-Audio is a 7B end-to-end audio model with full-duplex conversation via THINK, SHIFT, and BREAK tokens

Thu, 26 Mar 2026 00:00:00 +0000

Most voice AI pipelines are cascaded: ASR transcribes, an LLM reasons, TTS speaks. Covo-Audio collapses all three into a single 7B model that takes audio in and produces audio out, built on Qwen2.5-7B with a Whisper-large-v3 encoder.

The full-duplex variant (Covo-Audio-Chat-FD) is the interesting part. It handles simultaneous listening and speaking using three special tokens baked into the architecture: THINK (listening, not yet responding), SHIFT (switching to speaking turn), and BREAK (user interrupted, stop speaking immediately). Each audio chunk is 0.16 seconds. The model and user streams are interleaved at a 1:4 ratio.

Google's TurboQuant compresses LLM KV caches 6x with zero accuracy loss and near-zero indexing time

Wed, 25 Mar 2026 00:00:00 +0000

The KV cache is a major memory bottleneck for long-context LLM inference. Traditional vector quantization methods like Product Quantization require expensive dataset-specific codebook training that can take hundreds of seconds. TurboQuant, from Google Research (ICLR 2026), is data-oblivious: no training, no calibration, works instantly.

The key insight: applying a random rotation to input vectors induces a concentrated Beta distribution on each coordinate in high dimensions, making coordinates nearly i.i.d. This lets you solve a simple 1D scalar quantization problem per coordinate instead of a complex joint optimization. Codebooks are precomputed once per bit-width and reused at inference time.

TinyLoRA fine-tunes a 7B model to 91.8% GSM8K accuracy with only 13 parameters using RL

Tue, 24 Mar 2026 00:00:00 +0000

A Qwen2.5-7B-Instruct model fine-tuned with 13 trainable parameters (26 bytes in bf16) reaches 91.8% on GSM8K. Full fine-tuning of all 7.6 billion parameters reaches 91.7%. That number is not a typo, and yes, they are the same kind of parameters.

To understand why this is possible, you need to know what those 13 parameters actually do. They are not 13 weights replacing 7.6 billion others. They are 13 scalar values that get projected through a fixed random tensor into a high-dimensional update, which then gets added back into the frozen weight matrices across all layers. You are not tuning 13 knobs instead of 7.6 billion - you are tuning 13 directions of change that each affect the whole model via a fixed mathematical transformation. The frozen weights do all the heavy lifting; the tiny update steers them.

GitAgent defines AI agents as git repos, exportable to any framework with one CLI command

Sat, 21 Mar 2026 00:00:00 +0000

GitAgent proposes that your git repository is your agent. Two required files - agent.yaml (manifest) and SOUL.md (identity) - define the agent. Everything else - skills, tools, memory, compliance artifacts - is optional structure layered on top.

The interesting part is the supervision model: when an agent updates its memory or acquires a new skill, the change becomes a git commit or PR. Human reviewers can diff the agent’s personality changes like any code review. If behavior drifts, git revert brings it back.

NVIDIA's Nemotron-Cascade 2 hits gold-medal math and coding with a 30B MoE using only 3B active parameters

Fri, 20 Mar 2026 00:00:00 +0000

Nemotron-Cascade 2 is a 30B Mixture-of-Experts model that only activates 3B parameters per forward pass. It’s the second open-weight model to reach gold-medal level on IMO 2025, IOI 2025, and ICPC World Finals - after DeepSeek at 671B, which is more than 20x the size.

The core technique is Cascade RL: sequential domain-by-domain reinforcement learning, where each domain (math, code, instruction following, SWE agents) gets its own hyperparameters without destabilizing the others. The novel addition is Multi-Domain On-Policy Distillation (MOPD): when a Cascade RL stage causes regression on other benchmarks, they distill from the best intermediate teacher model for that domain on the fly. On AIME 2025, MOPD reached teacher-level performance in 30 steps; GRPO hit only 91.0 after the same number of steps.

GLM-OCR: A 0.9B document parsing specialist beats 235B models

Thu, 19 Mar 2026 00:00:00 +0000

GLM-OCR is a 0.9B multimodal OCR model that achieves 94.62 on OmniDocBench V1.5, ranking first overall despite its compact size. Built by Zhipu AI, it beats Qwen3-VL-235B (260× more parameters) and Gemini-3 Pro on document parsing benchmarks.

The model combines a 0.4B CogViT visual encoder with a 0.5B GLM language decoder. Its key innovation is Multi-Token Prediction (MTP), which predicts 10 tokens per step instead of one. For OCR—a deterministic task—you’re copying characters, not sampling creative text. This delivers about 50% higher throughput vs standard decoding.

Baidu's Qianfan-OCR collapses the multi-stage OCR pipeline into one 4B model with Layout-as-Thought

Wed, 18 Mar 2026 00:00:00 +0000

Traditional OCR pipelines chain at least three models: a layout detector, a text recognizer, and a language model for understanding. Qianfan-OCR replaces all three with a single 4B model that goes directly from image to Markdown.

The key innovation is Layout-as-Thought: appending a <think> token to any prompt triggers an optional reasoning phase where the model explicitly works through bounding boxes, element types, and reading order before producing output. It’s Chain-of-Thought for document layout - and it’s optional, so you can skip it for simple single-column documents to save latency.

Google's Colab MCP server lets any AI agent create and run notebooks in the cloud

Wed, 18 Mar 2026 00:00:00 +0000

Google released an open-source MCP server for Google Colab. Any MCP-compatible agent - Claude Code, Gemini CLI, or a custom agent - can now programmatically control a Colab notebook: create cells, write and execute code, install dependencies, rearrange content.

The setup is one config block:

"mcpServers": {
  "colab-mcp": {
    "command": "uvx",
    "args": ["git+https://github.com/googlecolab/colab-mcp"],
    "timeout": 30000
  }
}

The motivation is concrete: developers were copying code from their terminals into Colab cells to run or visualize things. That context switch kills flow. With this server, the agent writes directly into an open notebook - you get a reproducible, executable artifact in the cloud instead of a code snippet in your terminal.

NVIDIA's OpenShell enforces AI agent guardrails outside the agent process so a compromised agent can't override them

Tue, 17 Mar 2026 00:00:00 +0000

The problem with agent guardrails that live inside the agent: a compromised agent can override them. Claude Code and Cursor ship with internal safety prompts, but those protections are inside the same process they’re supposed to guard. A prompt injection or a bad third-party skill has access to the same runtime.

NVIDIA OpenShell moves the enforcement point outside. It wraps any agent in an isolated container with YAML-defined policies the agent cannot read or modify. Network access is deny-by-default and hot-reloadable; filesystem and process constraints are locked at creation. The agent can’t escalate privileges because the kernel won’t allow it - not because the agent was told not to.

Unsloth Studio is an open-source no-code UI for training and running local LLMs

Tue, 17 Mar 2026 00:00:00 +0000

Unsloth Studio bundles local inference, fine-tuning, and model export into a single no-code web UI. One curl command installs it; then you can run GGUF or safetensor models on Mac, Windows, or Linux without writing any code.

The training side is the main draw: 2x faster fine-tuning with 70% less VRAM across 500+ model families (text, vision, TTS, embeddings). LoRA, FP8, and full fine-tuning all work on NVIDIA hardware, with multi-GPU support already in.

Mistral Small 4 merges instruct, reasoning, and coding into one model with per-request reasoning effort

Mon, 16 Mar 2026 00:00:00 +0000

Mistral Small 4 replaces three separate Mistral models - Magistral for reasoning, Devstral for coding agents, and Mistral Small for instruct - with a single 119B MoE model (128 experts, 4 active, 6.5B active params per token). You pick the behavior per request with a reasoning_effort parameter:

reasoning_effort="none": fast chat-style responses, equivalent to Mistral Small 3.2
reasoning_effort="high": deep step-by-step reasoning, equivalent to Magistral

Same weights, same deployment, different behavior at inference time.

OpenViking: A context database using filesystem paradigm for AI agents

Sun, 15 Mar 2026 00:00:00 +0000

OpenViking abandons traditional RAG vector storage and uses a filesystem paradigm instead. It organizes agent context (memories, resources, skills) under viking:// URIs with a three-tier structure:

L0 (Abstract): One-sentence summary for quick retrieval
L1 (Overview): Core information and usage scenarios
L2 (Details): Full original data, loaded on demand

This enables directory recursive retrieval that locks high-score directories first, then refines content exploration. The retrieval trajectory is fully observable, letting users see exactly how context is being accessed.

You can force an LLM to only output valid answers

Tue, 03 Mar 2026 00:00:00 +0000

YouTube just open-sourced a project called STATIC that solves a problem most people don’t know exists: LLMs can say anything, but sometimes you need them to only pick from a specific list.

The Problem

When an LLM generates text, it picks one token (word/number) at a time from a vocabulary of ~32,000+ options. That’s great for conversation, but terrible when you need it to output something specific: a valid product ID, a medical code, or a video recommendation from a catalog of millions.

Pipe Mastra agent responses through jq to colorize reasoning and tool calls in the terminal

Mon, 02 Mar 2026 00:00:00 +0000

Mastra’s agent HTTP API returns a JSON structure with steps, each containing content items typed as reasoning, tool-call, tool-result, and text. The raw output is dense. Start by exploring it:

# Hit the API and see raw structure
http localhost:4111/api/agents/weather-agent/generate \
  messages[0]="what's the weather in montreal?" | jq .

# Get just the final answer
http localhost:4111/api/agents/weather-agent/generate \
  messages[0]="what's the weather in montreal?" | jq -r '.text'

# Explore what's inside steps
http localhost:4111/api/agents/weather-agent/generate \
  messages[0]="what's the weather in montreal?" | jq '.steps[].content[] | .type'
# "reasoning"
# "tool-call"
# "tool-result"
# "text"
# "reasoning"
# "text"

# See what fields each type has
http localhost:4111/api/agents/weather-agent/generate \
  messages[0]="what's the weather in montreal?" | jq '.steps[].content[] | select(.type == "tool-call")'

Once the structure is clear, pipe through jq -r with inline ANSI escape sequences to colorize each piece:

OpenClaw custom skills silently disappear without quoted YAML descriptions and openclaw metadata

Fri, 20 Feb 2026 00:00:00 +0000

If a custom OpenClaw skill doesn’t show up in openclaw skills list and the agent can’t see it either, the SKILL.md frontmatter is likely the culprit. OpenClaw fails silently, so the debugging feedback is minimal.

Two things must be right. First, any name or description containing a colon must be wrapped in double quotes, otherwise YAML interprets the colon as a key-value separator and the parse fails. Second, the frontmatter must include an openclaw metadata block declaring the emoji icon and any required binaries or environment variables. Without it, OpenClaw won’t register the skill at all.

Google DeepMind's Lyria 3 generates full songs from a photo or a sentence

Wed, 18 Feb 2026 00:00:00 +0000

Lyria 3 takes a text prompt or an image and produces a complete track: instrumentation, vocals, lyrics. Not a loop, not a mood board. A song.

The image input is what makes it interesting. Most generative audio models take text. Lyria 3 can look at a picture and decide what it sounds like. That’s a different kind of creative interpretation, closer to how a composer might respond to visual art than to a spec.

HTTPie needs --ignore-stdin in non-TTY environments like Claude Code

Tue, 17 Feb 2026 00:00:00 +0000

HTTPie detects whether it’s running in a TTY. When there’s no TTY, like when Claude Code invokes it as a subprocess, HTTPie assumes stdin might have data coming and interprets the request as a POST, even if you meant a GET.

The fix is --ignore-stdin:

http --ignore-stdin GET localhost:3000/things

The catch: once you tell Claude Code to always use --ignore-stdin, it will also use it when piping data, which breaks that use case entirely:

Claude Code runs natively as a GitHub Action

Thu, 12 Feb 2026 00:00:00 +0000

Anthropic ships an official claude-code-action that runs Claude Code inside a GitHub Actions workflow. It can read your repo, write files, run commands, and commit, all triggered by a PR comment or a schedule.

The interesting part: it uses the same Claude Code you run locally, so your CLAUDE.md instructions carry over. The action respects the same permission model.

Immediate use cases I’m thinking about:

Auto-generate TIL posts from GitHub Issues with a specific label
Run a nightly review pass on open PRs
Summarize recent commits and update a changelog

The main constraint is the Actions runner environment: you need to install any tools Claude Code will call (glow, rsync, etc.) as workflow steps before handing off to the action.

Kimi's agent swarm runs up to 100 parallel sub-agents to escape context window limits

Mon, 09 Feb 2026 00:00:00 +0000

The interesting part isn’t the parallelism itself, it’s the reason for it. A single agent on a long-horizon task eventually hits its context window and starts compressing earlier context, degrading output quality. Kimi’s solution: spawn up to 100 sub-agents, each with their own fresh context, coordinating as a swarm.

The system is self-organizing: it determines how many agents to deploy and how to split the work based on the task. In benchmarks they cite 4.5x faster results and over 1,500 tool calls per task.

Zvec is an embedded vector database aiming to be the SQLite of vector search

Wed, 21 Jan 2026 00:00:00 +0000

Zvec is an open-source embedded vector database from Alibaba, built on their Proxima engine. The pitch is simple: vector search that runs in-process, no server required, with the same frictionless setup as SQLite.

The gap it fills is real. Faiss gives you indexes but no CRUD or crash recovery. DuckDB-VSS has limited vector features. Milvus needs its own process and network hop. Zvec aims to be the option that just works when you’re building a local RAG pipeline, a CLI tool, or anything on-device where you need semantic search without infrastructure.

LLMs struggle with Asana's strict non-standard rich text format

Fri, 12 Sep 2025 00:00:00 +0000

Asana’s rich text API doesn’t use standard HTML. It accepts a strict subset with specific rules: only certain tags are allowed, nesting rules differ from what browsers tolerate, and the format is closer to XML than HTML, meaning unclosed tags, loose attributes, or anything outside the allowed set will be rejected or silently mangled.

LLMs tend to produce plausible-looking but subtly wrong output here. They’ll use tags Asana doesn’t support, nest things incorrectly, or generate valid HTML that Asana’s parser rejects.

MCP servers support prompts as a first-class concept, separate from tools

Tue, 03 Dec 2024 00:00:00 +0000

When I shipped mcp-server-asana 1.1.0, the headline addition wasn’t the six new Asana tools (task dependencies, stories, subtasks, project sections). It was prompts.

In the MCP protocol, prompts and tools are distinct concepts. Tools are individual actions an LLM can invoke: create a task, add a dependency, fetch a comment. Prompts are predefined conversation templates: parameterized, reusable starting points that an MCP host can surface directly to users.

The task-summary prompt added in 1.1.0 illustrates the difference. Instead of leaving the LLM to figure out what to fetch and how to present it, the prompt defines a scaffold: current status, key updates, blockers, next steps. The LLM gets structure, not a blank page.