Signal-to-system playbooks
Practical guidance for teams deciding when a frontier signal deserves a trained model, a dataset, an eval gate, or a safer rollout path.
Start with the question
Public artifacts
These are inspectable model artifacts, not product promises. Hugging Face owns the current files, license text, and download state. The links below explain what each release is for and where it came from.
A character-shaped small model trained around a corporate goblin voice, with a browser lab that exposes the runtime and mutation experiment.
A collection of Benjamin Franklin voice experiments that turns fine-tuning and lore work into a set of narrow, inspectable model artifacts.
Model cards are curated from public release information and checked before publication. Current file contents, licenses, and availability remain on Hugging Face.
A private system on your network
You do not need another box of parts. You need a machine that starts, stays useful, and gives you a simple way to use it. I can help choose the hardware, preload a stable model runtime, expose a local API, and put a browser front end on your network.
Compact endpoint
A compact, low-power build for focused local work: private writing, transcription, vision, small agents, or a specialist model that does one job clearly.
Nano is a capability tier, not a fixed board or promise that every model will fit.
High-capacity endpoint
NVIDIA DGX Spark / GB10 for larger local models, agent experiments, evaluation, and heavier workloads that still belong on a private network.
Hardware, software versions, and model support are confirmed for the specific build before purchase or delivery.
Tell me who will use it, what it should do, what must stay private, and whether you already own hardware. We can scope the right endpoint from there.
Talk through a local-AI buildStart with decision quality, then move into data quality, then enforce ruthless evaluation before launch.
A field note on local vision-model workflows, examples, and why cheap local AI unlocks slower but useful inspection loops.
Read field note →A field note on using local vision segmentation, cheap inspection loops, and agentic review tooling to eyeball an early Independence Town build.
Read field note →How to decide between prompting, RAG, fine-tuning, or full custom training without burning six weeks for a 4% gain.
Read playbook →Build a dataset that reflects real user behavior, edge cases, and failure modes instead of happy-path vanity examples.
Read playbook →A practical eval stack: offline evals, scenario tests, red-team checks, and hard release thresholds that block bad launches.
Read playbook →A plain-language decision matrix for selecting the lightest approach that achieves your target behavior and reliability.
Read playbook →Field notes and a four-part series connecting Eric's local-inference experiments, pico-LLM work, nanochat, small-language-model research, and practical ability training.
A Jetson Nano field note on local AI economics, always-on generation, payback periods, and when edge inference starts saving more than it costs.
Read field note →A prompt-craft field note on queued agents, latent-space gardening, and pruning model work into practical operating loops.
Read field note →A field note on why agent-native Kanban, triage, and human unblock points make multi-step AI work feel less like Jira and more like a live operating system.
Read field note →A project-writing field note on capturing lessons while the system is still warm, drafting ahead, and turning publication into a reusable learning loop.
Read field note →A short model-training note on using the generated artifact itself to expose pixel-art technique cues the model can reuse.
Read field note →A short SLM field note on handing the GPU to an OpenClaw instance for nanochat experiments in intelligence per megabyte.
Read field note →A first look at the Snapdragon Elite X1E80100 Qualcomm Hexagon NPU as a local-inference path for low-cost agentic tokens.
Read field note →A rainy-day local-hardware note on testing whether a Jetson Nano can carry useful learning loops close to the bench.
Read field note →A short local-inference field note on a tiny Qwen model sketching a full C# app plan on older NVIDIA hardware in under a second.
Read field note →A field note on custom Qwen LoRAs, Benjamin Franklin model voice, pseudo-SWE-Bench experiments, and narrow-model usefulness.
Read field note →A short model-training note on constraining weights to -1, 0, or 1 and using overnight run stats to pressure-test generalization.
Read field note →A local-inference field note on Gemma, ONNX, battery-powered AI, and the harness needed to turn a small local model into a useful agent.
Read field note →A debugging field note on 3D pipeline views, runtime charts, and tooling ideas for finding where inference performance actually drops.
Read field note →A QNN field note on HTP, HMX, HVX, ONNX graph partitioning, and why Gemma4 workloads may still route through a hot CPU.
Read field note →A short benchmark note on why selected NPU runs can still show CPU token work when prompt prefill has not moved to the accelerator.
Read field note →A local Snapdragon benchmark note showing how a Gemma vision harness compares CPU, GPU, and NPU profiles on year-old hardware.
Read field note →A Gemma4 field note on moving a custom Snapdragon harness from slow token/sec baselines toward usable GPU-backed local inference.
Read field note →A short field note on Snapdragon NPU experiments, local Gemma sessions, and the slash commands that make a tiny-model harness usable.
Read field note →A short progress note on making local Gemma4 workloads target the GPU instead of drifting into CPU fallback.
Read field note →A local Gemma4 vision harness for progressive screenshot inspection, ONNX sessions, and cheap edge inference across GPU, NPU, and CPU targets.
Read field note →A benchmark field note on why CPU, GPU, and NPU numbers can tell a surprising story until the ONNX graph, kernels, and DirectML path are made visible.
Read field note →The preserved 64 MB RPG-state experiment reframed around constrained domains, token contracts, failure-first evals, and capability-per-megabyte.
Read part 1 →How nanochat's depth dial turns training into a comparable family of compute-optimal models instead of one-off checkpoint luck.
Read part 2 →What changes when GPT-2-level capability becomes cheap enough to repeat, and why data and evals become the real constraint.
Read part 3 →How synthetic data, token-visible task design, and identity tuning turn small models into useful narrow specialists.
Read part 4 →Source archive · August 2026
Short experiments belong beside the durable playbooks when they show the actual hardware, models, and failure modes behind the work.
A rainbow bomber and a neon jet test how far a local image workflow can push one aircraft idea.
Open field note →A six-year-old GPU rolls a ball, adds synchronized sound, simulates a million more, and keeps one eye on the temperature.
Read the experiment →A first look at the images, models, and hardware limits behind a local video workflow.
Open field note →A train, a sunset, and the opening frame of a video experiment that the hardware kept resisting.
Open field note →The local run finally moves after a string of short, blurry attempts.
Open field note →More frames from the same train experiment, kept together for comparison.
Open field note →A public visual record from a local image-model experiment.
Open field note →A compact record of a constrained-hardware image workflow.
Open field note →An honest training note: a small experiment, a crash, and the evidence retained from both.
Open field note →