Crabhaus

What matters in AI, and why.

Sun 6 Sep · Issue 054 · 3 min

Issue 054 · Sun 6 Sep

Astra picks up blocks; readers put down AI prose

01ResearchAstra sweeps a robot-arm eval at half Fable's cost
02LabsSimon Willison's Astra-for-developers hands-on
03AgentsAI incident responders breed engineer skill-rot

The one that matters

GPT-6 Astra nails robot pick-and-place where Fable stalls - until fine motor control

RoboCurve gave Astra control of the same YAM arms and Inspect Robots agent policy from its Claude Fable comparison. On block-into-bowl, Astra scored 19/20 at ~2.5 minutes and ~$0.94 a trial, against Fable 5.1's 8/20 at 6.8 minutes and $2.12. On the harder knob-grasp puzzle insertion both managed 2/20, stalling at the same final alignment step.

Why it matters

General-purpose LLMs are quietly becoming usable robot policies: the gap between models now shows up in physical task success and dollars per trial, not just benchmark scores. But the shared 2/20 puzzle failure shows fine manipulation stays unsolved regardless of which frontier model drives the arm.

Learn one thing

Running models locally: llama.cpp, GGUF, Ollama

Hand-drawn diagram of the local LLM stack: open safetensors weights are converted and quantized into a ~5GB GGUF file, which a laptop running llama.cpp memory-maps into RAM; every generated token streams all weights through the processor (speed = bandwidth / model size, about 20 tok/s at 100 GB/s for a 5GB model), and Ollama serves the model to chat, code, and app clients over a localhost API.View full-size diagram ↗

What it is

The stack for running open-weight models on your own hardware. llama.cpp is a C/C++ engine that runs LLMs on ordinary CPUs and consumer GPUs; GGUF packs quantized weights, tokenizer, and metadata into one file it can memory-map; Ollama wraps it in a local server with one-command model pulls and an OpenAI-compatible API on localhost.

How it works

Weights are quantized from 16-bit floats to ~4-5 bits (schemes like Q4_K_M), shrinking an 8B model from ~16GB to ~5GB. Generating each token streams essentially every weight through the processor, so speed is bound by memory bandwidth: tokens/sec is roughly bandwidth divided by model bytes. A GPU takes as many layers as fit in VRAM; the CPU runs the rest. Ollama keeps models warm.

A concrete example

A 16GB laptop moving ~100GB/s pulls a ~5GB 4-bit 8B model and generates near the predicted 100/5 = 20 tokens/sec - fine for chat, drafting, and code completion. A 70B model won't fit: even at 4 bits it needs ~40GB for weights alone, before the KV cache that grows with context length.

Why it matters

Prompts never leave the machine, it works offline, and tokens are free - changing the economics of high-volume small-model jobs like extraction and autocomplete. The bandwidth ceiling tells you when local wins (private, latency-tolerant work) and when cloud does (frontier reasoning, long contexts). It is also why fast unified-memory laptops became the default local-LLM box.

What people get wrong: That you need an expensive GPU. The binding constraint is memory capacity and bandwidth, not compute: a laptop with fast unified memory outruns a desktop with slow RAM, and a GPU helps mostly because VRAM bandwidth is high. And 4-bit quantization does not 'ruin' a model - modern K-quants stay close to full precision for everyday use.

Today's top 5

ResearchRoboCurve's YAM-arm eval: GPT-6 Astra lands block-in-bowl 19/20 at ~$0.94/run vs Fable 5.1's 8/20, but only 2/20 on puzzle insertion.

Model choice now shows up in physical success rates and dollars per trial - and the shared 2/20 puzzle stall shows fine manipulation is still unsolved no matter which frontier model drives the arm.

LabsSimon Willison's hands-on with GPT-6 Astra's developer launch: better prompt-following and detail, with a standout jump in 3D modeling.

An independent, hands-on read on what the developer launch actually delivers: consistent gains in prompt-following and output detail, plus a step change in 3D modeling - concrete capability notes API users can act on.

AgentsEx-LinkedIn SRE: AI incident responders that clear routine outages erode the practice engineers need for novel high-severity failures.

The counterpoint to agentic ops: every routine incident an AI resolves is practice a human didn't get. The skill to handle the ambiguous sev-1 that automation can't fix decays quietly until the day it's needed.

ResearcharXiv paper models LLM adoption as a 'cognitive virus': social spread plus reinforcement produces tipping points into dependence.

A formal model of something usually argued by vibes: LLM dependence spreading socially, with thresholds past which lock-in becomes population-wide. The same framework identifies levers that keep use recoverable.

ResearchBryan Cantrill: readers now bail on LLM-authored prose - its structural tells scan as contempt, and the lost trust outlasts the post.

A widely shared marker that AI-flavored prose carries a social cost: readers detect the tells, stop reading, and remember. For anyone shipping words, unedited LLM output is becoming a trust liability.

See the full wire feed →

Quick check

Was this issue useful?

Get Crabhaus in your inbox

A concise daily briefing on the AI developments worth understanding.