The Last Rung: A Local Model When Every Cloud Is Down

"Every rung above the bottom needs somebody else's service. The bottom needs a pool and a checkpoint. The household's coding agent calls that rung its definition of done."

The Ladder

The household's coding agent reaches a model through what it calls legs — an endpoint, an authentication source and a wire dialect — and it tries them in an order. The vendor harnesses that own their frontier brains. Frontier cloud models through the household's own daemon, signed in by the operator. OpenAI-compatible and subscription legs as compatibility surfaces. And, at the bottom, a local model through the Ollama daemon on whatever Mac is asking, with the household's 27B as the default. The code block lists what each rung needs to exist. The top three need a service, a login or a key — someone else's machine, reachable. The bottom rung needs a Mac, its daemon and one pulled model, and the agent's house rules make that rung the acceptance test for the whole product: "fresh machine, ollama with one local model, it runs, bare — is the definition of done, and it needs no API key and no vendor login."

What the Bottom Rung Carries

A frontier leg loads the agent's full identity: Pippa's vault, the shared instructions, the workspace rules — more than a hundred thousand tokens even on an M3 Ultra, the tier lesson's ceiling for the largest pool in the house. A local model cannot hold that, so the bottom rung loads the compiled mini protocol instead, the same slimmed identity the household's brain already uses for local tiers, chosen automatically by model class: local models get mini, cloud models get full, and a switch across the boundary re-resolves and records it. The physics track says why the slimming is not optional. A hundred-thousand-token prefill on the 27B is the curve lesson's wall extrapolated — five minutes before the first token at office's measured 340 tokens per second, where the lesson measured 90 seconds at 29,385; the mini protocol's few thousand tokens are seconds. The rung is usable because it is small, and it is small because someone decided that a local model with less context is better than no local model at all.

Measured, and Everywhere

On office the bottom rung is the journey track's Ollama lesson: the 27B through the daemon's MLX engine at 48–51 tokens per second of prose, 90 on repetitive text, with the speculative-decoding caveat the lesson explains. On any 128 GB laptop in the house the same 27B fits with a long context at the M-series Max tier's rates from the ladder lesson; on the 24 GB Air a 9B fits at 19 tokens per second, and the prose editor's own offline fallback and the voice sibling's on-device transcription are the same rung under other names. So the rung exists on every Mac the household owns, in three sizes, at speeds the lab measured, needing nothing outside the room. What it is for is the next lesson's subject: not privacy, which the household says is a narrative, but the day — or the eight hours — when no rung above it answers.

Code

last_rung.py — the agent's legs in order, and what each needs to exist·python

#!/usr/bin/env python3
"""The last rung: the coding agent's legs in the order it tries them, and what each needs
to exist. The bottom rung needs a Mac, a daemon and one local model -- no key, no login --
and that is the agent's own definition of done. Read from the agent's house rules, 2026-09-15."""
legs = [  # rung, leg, needs, what the agent loads for it
    (1, "frontier via a vendor harness CLI",     "the vendor's service and its login",       "the full identity: vault load order + workspace rules"),
    (2, "frontier Ollama cloud model",           "the daemon signed in by the operator + the cloud", "the full identity"),
    (3, "OpenAI-compatible / subscription legs", "a key and the endpoint",                   "per leg"),
    (4, "local model through the Ollama daemon", "a Mac, the daemon, one pulled model",      "the compiled mini protocol (a local model cannot hold the vault: >100k tokens)"),
]
for rung, leg, needs, loads in legs:
    print(f"rung {rung}: {leg:40} needs: {needs:52} loads: {loads}")
print("\nboot test, the agent's definition of done: a fresh machine, the daemon with one local model, it runs, bare -- no API key, no vendor login.")
print("on office the bottom rung decoded a 27B at 48-51 tok/s (T8); on a laptop, a 27B fits with a long context; the rung exists on every Mac in the house.")

Exercise

Write your own ladder of legs on the card, top to bottom, with what each needs to exist. Then run the boot test on your Mac: a fresh account, one daemon, one model, no keys. Record the model, the context it can hold usefully at your measured prefill rate, and the decode rate. That row is your last rung.

Hint

If your last rung's usable context is under ten thousand tokens, it needs a slimmed identity to be worth anything — the household's mini protocol is one design. If the rung does not exist, the rest of this track is about why it should.