PocketPause: one local AI card, then outside

This is my submission for Week 1: Touch Grass.

What I built

PocketPause is a small local app with one job: give you one outdoor
observation, then get out of the way.

Choose roughly 5, 10 or 15 minutes and a broad setting such as a street,
terrace, courtyard or campus. A local open-weight model picks a few
observation cues. PocketPause turns them into one fixed card that you can
read, save as plain text, and take outside.

The app does not need an account, GPS, photographs, bird recordings or a
journal. You choose the safe, permitted spot yourself. PocketPause cannot see
it, so its instructions use conditional wording: if a sound or sight is
already there, notice it; otherwise skip it. A terrace selection never grants
roof access, and the time is a suggestion rather than a timer.

The intended flow is short:

1. Choose a time and setting.
2. Generate one card locally.
3. Read it, save it if useful, and put the screen away.

Demo

Download the 26-second demo (.webm)
or view it on GitHub.

The recording shows the real local model generating a card and then saving it
as plain text. It is a desktop software demonstration, not an outdoor trial.
I have not measured any change in well-being or screen time.

Code and evidence

Source code and setup instructions.

PocketPause was created locally on 6 October 2026, within the Week 1 window.
The repository includes tests, all raw measurement runs, setup instructions
and an MIT licence. Model weights, browser binaries and runtime profiles
are excluded from Git.

The measurement evidence
preserves the raw output and failed runs.

How it works

React handles the two selectors, loading and error states, and the download.
A small Node server validates the request and calls Ollama on loopback. Qwen3
uses the qwen3:1.7b tag in non-thinking mode to select the cues. It is the
runtime generation engine, not just a coding aid.

The model returns one exact JSON field containing distinct values from a
six-cue enum. The domain parser checks the fields and the one/two/three cue
count for 5/10/15 minutes. The renderer maps each cue to fixed conditional
sentences, so model text never reaches the card and the model cannot invent a
scene the laptop cannot see. One request runs at a time with a two-minute
deadline. A failed generation shows an error instead of a disguised fixed
card.

What I measured

The cue report covers one cold request and three warm samples for each of the
12 combinations: 37/37 cards were valid. Warm requests took 1.85–6.91 seconds
(3.71 seconds average); the cold request took 16.89 seconds. The 36 warm
cards produced 11 distinct rendered step sets. Eleven of the twelve
combinations repeated across all three warm seeds; only 15-minute terrace
varied. The finite vocabulary limits variety, so this is desk evidence about
the software rather than a claim about an outdoor outcome.

The fixed non-AI baseline also supplies 12 usable cards and remains simpler.
The cue cards pass the desk checks for optional stationary observation, but I
would not claim AI made this a better outdoor experience on the evidence
available.

Why local open-weight AI matters

Once the weights are downloaded, PocketPause generates locally without sending
the prompt to a hosted inference API. That keeps the activity private and
removes the provider account from the generation path. It also makes the
generation engine replaceable: another local model can be selected, although
only Qwen3 has been measured here.

Qwen's upstream weights use Apache-2.0, Ollama uses MIT, and the app's code
is MIT. The measured model identifier and digest are recorded. Local metadata
labels the parameter size as 2.0B while the upstream card names 1.7B; I have
left that discrepancy visible rather than hiding it.

The trade-off is setup. The weights alone are about 1.36 GB, and generation
uses the laptop's resources. This is a local-first project, not a hosted AI
demo.