Changelog

Shipping Log

A record of what is actually shipping on this site and the infrastructure behind it. Published entries are written in my own voice; drafts are auto-generated from git history and curated before going live.

November 13, 2026/
Content

Three new projects on the Work page

Millwright, Caretaker and agent-operated hosting are now on the site, and Reader can talk about all three.

  • Millwright: describe an internal app and an agent assembles it from prebuilt, security-reviewed components, behind a data-flow gate it can't talk its way past.
  • Caretaker: my standing maintenance agent, with a patrol that runs no AI, fixes that come only from a playbook, and authority that grows one approval at a time.
  • Agent-operated hosting: replacing a cPanel and WHMCS reseller stack with hosting run by my agent, where healing means restoring and site content is treated as hostile input.
November 8, 2026/
InfrastructureFeature

Reader no longer waits behind my agents

A cache-aware admission gate now sits in front of the shared engine, so the site's requests skip ahead of background agent work.

Reader shares one DGX Spark with my coding agents, and the agents fan out into parallel subagents with very large prompts. Measurements showed that a second agent stream added no output and a third made everything slower.

dgate now decides when each request enters the engine. Agent work gets one slot and takes turns, interactive requests like yours use any free slot, and tiny requests skip the queue. The full write-up is on the blog: A Second Agent Stream Added Nothing.

October 18, 2026/
InfrastructurePerformance

Faster answers from three lossless engine changes

Reader's model got about 7% faster end to end and half a second quicker on follow-ups, with output verified identical.

Three changes shipped to the inference engine that serves Reader. Each one had to reproduce saved reference outputs before it was allowed to stay:

  • Prefetched embedding lookups. The one step per token where the GPU waited on the CPU now fetches what it needs in a single burst: about 7% faster end to end.
  • No recompute on follow-ups. Follow-up turns stopped recomputing a block of the prompt they already had, so the first token arrives about half a second sooner.
  • 8-bit draft head. The small draft model used for speculative decoding now runs its output layer in 8-bit: 4–9% faster generation, with every drafted token still verified by the main model.

Each change has a one-command rollback, and a watchdog with no AI in it checks speed and correctness every 15 minutes.

September 4, 2026/
InfrastructureFeature

Reader now runs on Qwen3.8-Flash-Next

The site's AI agent moved to a larger Qwen-family mixture-of-experts model, still fully local on my DGX Spark.

Reader now answers you with Qwen3.8-Flash-Next, an open-weight Qwen4-architecture preview: a 125B-parameter mixture-of-experts model with about 6B parameters active per token, NVFP4-quantized, served by vLLM and fronted by LiteLLM.

Several models have come and gone since the April move to local inference. The swaps never touched agent code: Reader talks to a stable LiteLLM alias, so the model behind it can change without the site noticing.

The public site gets its own LiteLLM alias with its own prefix-cache salt, so its requests can't be timed against the private tools sharing the same engine.

April 10, 2026/
MetaFeature

Added this changelog

The site now has a changelog at /changelog — partly as a record of what's shipping, partly as live evidence that the stack is actually being used.

A portfolio that claims to ship should be able to show you what it's shipped. This page is driven by MDX files in content/changelog/, edited through TinaCMS, with an auto-draft script that reads git commit history across the relevant repos and emits draft entries for curation before publishing. Low-friction for me, honest for you.

If you're looking at the first few entries and thinking "those are from tonight" — yes, they are. The first entry is the Qwen migration that made Reader fast enough to feel conversational. The second is the bug fix that made Reader actually render structured answers. This one is the meta-entry explaining why they're here.

The plan: new entries get written in a James-voice rewrite of what actually changed. Pure git-log commit messages go in the drafts folder; the curated published versions read like a normal changelog, not a commit dump.

April 10, 2026/
FixInfrastructure

Rewrote the chat proxy route, killed a markdown-eating filter

The Next.js → reader-agent proxy had quietly drifted to the wrong endpoint and was running a filter that stripped any response starting with a heading, numbered list, or bold text. Both fixed.

The Next.js API route for chat was proxying to the wrong backend path, and was running a legacy SSE filter that inspected each streamed chunk for patterns like ^##, ^\d+\.\s, and ^\s*\*\* — meaning any response that opened with a markdown heading, numbered list, or bolded phrase was being dropped before it reached the browser. The filter was left over from an earlier model that emitted visible "Thinking Process" prefixes; once the underlying LLM stopped doing that, the filter was pure downside.

Both are gone. The proxy is now a clean passthrough of reader-agent's SSE stream, so everything Reader writes — headings, bolded terms, numbered steps, the whole markdown vocabulary — reaches the UI as-is and gets rendered properly by the existing react-markdown layer.

Side effect: Reader can now actually answer "what's your architecture?" with structured bullet lists and headers, instead of silently returning empty responses.

April 10, 2026/
InfrastructureFeature

Moved Reader to fully-local inference on Qwen3.5-35B-A3B

The site's AI agent no longer calls a cloud API for chat. All inference now runs on my NVIDIA DGX Spark via vLLM, fronted by LiteLLM for routing and chat-template config.

Update: This entry is from April. The A3B model was retired in September. The September entry above has the current model.

Reader now answers you with a Qwen3.5-35B-A3B MoE model, AWQ-quantized, served by vLLM on my DGX Spark and fronted by a local LiteLLM proxy. Zero cloud dependency for the chat path.

The A3B part is where the speed comes from: it's a 35-billion-parameter sparse mixture-of-experts, but only ~3B parameters are active per token. For each response you read, the model is doing roughly the compute of a 3B dense model — which is why it streams noticeably faster than the Gemma 27B setup it replaced, and faster than the cloud Opus calls I was routing through before.

LiteLLM sits in front as a thin routing layer so I can swap the underlying vLLM process out, or fall back to a cloud model, without touching agent code. The LiteLLM config also disables Qwen's visible thinking mode (enable_thinking: false) — otherwise the model wraps answers in a "Thinking Process" preamble that's interesting for debugging but noise for visitors.

Cost per visitor interaction: effectively zero. The silicon is already running.