A talking agent on a small machine
A talking agent on a small machine brings together Whisper, Chatterbox, a tiny Qwen model and a boundary between stateful actors and smart functions.
Lynn Cole / 标签
local inference
A thread through the work.
Expose capabilities, not a frontier model
Expose useful product capabilities instead of embedding an open-ended frontier model. Let users bring the inference stack they already trust.
Finding Qwen’s limit on a vague Zig assignment
A deliberately vague Zig assignment pushes Qwen through planning, implementation and the complexity wall. The failure is part of the evaluation.
My coding agent is arguing with the ticket system
My coding agent is arguing with its ticket system. Persistent roles and procedural memory create unexpected standards—and a useful kind of bureaucracy.
After OpenClaw: continuity, memory, and the agent economy
After OpenClaw, the harder problem is continuity across hours, days and weeks. The opportunity is to let people bring their agents to better tools.
A powerful local model and a very hot Spark
A powerful local Qwen model meets a DGX Spark that runs uncomfortably hot. This is my experience with the original unit and its replacement.
Toward a model-agnostic coding-agent release
Preparing a model-agnostic coding-agent release exposes the difference between a supported tool protocol and a model that can complete the workflow.
The expensive part is the trial and error
Copying an existing agent harness can be fast. Discovering and handling its real failure modes is where the engineering time goes.
BitNet and Qwen in a bounded coding evaluation
A bounded coding evaluation pits BitNet against a smaller Qwen model. The results expose the difference between cooperative language and working code.
Agentic browsing and protected browser state
Agentic browsing should preserve the browser’s security boundaries. Extracting passwords, cookies and session state into model context changes the whole risk.
Personas, repository instructions, and alignment
Personas can encode beliefs and boundaries without turning repository instructions into a tax code. Instruction mass changes how agents work.
Early-adopter costs on the DGX Spark
The DGX Spark offers a huge shared-memory workspace, but early adoption comes with missing dependencies, difficult setup and a stubborn software ecosystem.
Voice, multimodality, and lessons from a weekend build
Weekend lessons from voice, multimodal inference, certainty scoring, image stacks and tool instructions trained into small LoRAs.
Reasoning loops as an engineering process
Reasoning loops belong in the engineering process as well as the weights. Spend more time when uncertainty and consequences justify it.
Lessons from a weekend inside an inference engine
A weekend inside an inference engine reveals device middleware, data shaping and old architectural assumptions that still deserve to be challenged.
Bigger embeddings are not automatically better search
Bigger embeddings do not automatically mean better retrieval. Match the corpus, chunking, context and search architecture to the job.
Unstated architecture is still a developer’s responsibility
Architecture that remains unstated is still the developer’s responsibility. Models, prompts, frameworks and modular design all need deliberate choices.
A shared inference broker for local agents
One of the more interesting problems I’m working through in my coding agent app is scheduling.
Pillowfort: security as part of the architecture
Pillowfort’s security layer became a substantial part of the architecture. A useful demonstration is easier than a system that can work without leaking private data.
Glamin in a local inference stack
Putting Glamin into a local inference stack turns vector-space state changes into a possible interface for tools, memory and small applications.
Build tools for the inference stack people already use
Build tools for the inference stack people already use: delightful software, a community and something worth returning to.
Configuration adapters and a multi-reference image stack
Configuration adapters free context space by teaching tool instructions to the model. Preserving multimodal capabilities is the next difficult layer.
Planning a CPU implementation of CUDA-style operations
A plan to implement CUDA-style operations on CPU: start with kernels, then optimize around memory and concurrency.
Cleaning competing implementations out of an inference stack
Competing forward passes and cache implementations exposed drift in an inference project. Aggressive cleanup comes before the next experiment.