# Later Line: a local model may shorten the task, and a lying line is thrown away

> Source: <https://dev.to/akshaygoel7/later-line-a-local-model-may-shorten-the-task-and-a-lying-line-is-thrown-away-5c1l>
> Published: 2026-10-23 20:36:37+00:00

This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady](https://dev.to/challenges/hacktoberfest-week3-2026-10-19).

The hard part of a postponed task is opening it again. The paragraph is still there, and so is the small decision I did not want to make on Tuesday.

Later Line takes a pile of those tasks and keeps one line each. A local Gemma 3 1B model, through Ollama, is allowed to write that line. The line is kept only when it is shorter than the task, no more than 12 words, still names something the task already named, and does not claim the work is finished. If any of those fail, the model line is thrown away and the first 12 words of the original stay.

A task that is already one short line is not sent to the model at all.

It is for the moment before you put the thing off again. You should not have to reread the whole paragraph to remember what it was.

Two nearby entries do a different job, and I built this because of that difference. [Dozer](https://dev.to/mukuvi/dozer-a-folder-tidier-that-works-while-you-sleep-6d9) files a Downloads folder and leaves unsure files alone. [Ripe](https://dev.to/maricastroc/ripe-put-a-task-off-and-a-local-gemma-grows-it-into-a-first-draft-while-youre-away-330o) grows a postponed sentence into a plan and a draft while you are away. Later Line refuses to grow anything. The only work it removes is rereading.

```
ollama pull gemma3:1b
python3 later_line.py samples/pile.txt --html docs/run.html
```

`samples/pile.txt` is four made-up tasks: a client thread, a passport renewal, a kitchen drawer, and "Book the dentist". Nothing in that file is a real message.

This is the run on this laptop, Gemma 3 1B, after the model was already loaded:

```
4 postponed
model kept 1
thrown away 2
already one line 1
105 words in, 39 words left
66 words you do not have to reread

1. Reply to Meera about the menu site. She wrote on Tuesday that
   12 words from 41 · the model claimed the task was already done, so it was thrown away
   model said: Missing logo, WhatsApp button, and invoice split – Meera's requests addressed.

2. Renew the passport before the November train. The old one is in
   12 words from 36 · the model line was longer than 12 words, so it was thrown away
   model said: Renew passport, ensuring photo takes this week, and avoids a specific time slot.

3. Charger drawer contains three frayed cables – discard one to prevent misuse.
   12 words from 25 · shorter, and it still names something from the task

4. Book the dentist
   3 words from 3 · already one line, so the model was not asked
```

The three model calls took 0.69s, 0.62s, and 0.53s. The first pass over the same pile, while the model was loading, took 11 seconds.

Put a task off. A local open-weight model may replace it with one shorter line. If that line is longer, or it drops the thing the task was about, the line is thrown away and the first 12 words stay.

This is the opposite of a tool that writes the draft for you. The only work it removes is rereading.

```
ollama pull gemma3:1b
python3 later_line.py samples/pile.txt --json run.json --html docs/run.html
```

`--rules-only` skips the model. Tests do not need Ollama:

```
python3 -m unittest tests.test_later_line
```

Nothing in the pile is sent anywhere except `127.0.0.1:11434`.

A model line is kept only when all of these are true:

A task that is already 12 words or fewer is not sent to the model.

MIT licensed.

MIT licensed. Fourteen tests run without Ollama:

```
python3 -m unittest tests.test_later_line
php
flowchart LR
  A[Postponed task] --> B{12 words or fewer?}
  B -->|yes| C[Keep it. Do not ask.]
  B -->|no| D[Gemma 3 1B on localhost]
  D --> E{shorter, names the task, does not say it is done?}
  E -->|yes| F[Keep the model line]
  E -->|no| G[Throw it away. Keep the first 12 words.]
```

The model is asked for one JSON object, `{"line": "..."}`, with temperature 0. Code checks the line. The model does not get to describe what happened.

Three answers from this run are the whole design.

**It said the client work was already done.** The task was a reply I had not written. Gemma returned "Meera's requests addressed." That line is shorter and it still says Meera, so a length check would have kept it. A second check throws away a line that adds a finished-work word the task did not contain: addressed, done, finished, fixed, paid, resolved, sent, completed. The first 12 words stayed.

**The passport line was 13 words.** "Renew passport, ensuring photo takes this week, and avoids a specific time slot." It also turned "a time I do not want to pick" into "avoids a specific time slot," which is a different fact. Length threw it away before that mattered.

**The drawer line was kept, and it is wrong.** The task says three cables, one of them frayed. The kept line says "three frayed cables." It is 12 words, it is shorter, and it still says charger, drawer, and frayed, so the gate let it through. A gate that checks nouns does not check that the noun and the number still belong together. I left that failure on the page. Hiding it would make the tally look cleaner and the tool worse.

[Oleksandr's comment on Ripe](https://dev.to/maricastroc/ripe-put-a-task-off-and-a-local-gemma-grows-it-into-a-first-draft-while-youre-away-330o) is the same rule from the other direction: the plant on that page only grows when a milestone is actually saved. A progress indicator that is disconnected from the work is a lie. Later Line's page prints the rejected line in red for the same reason. The tally "model kept 1" is the count of lines that passed the checks, not the count of lines the model produced.

The pile is the kind of text you would not paste into a hosted chat: a client who is unhappy, a passport, the state of a drawer in the kitchen. The request goes to `127.0.0.1:11434` and stops there.

Putting things off has to be cheap. These are tasks I might never reopen. A per-token API charges for the ones I abandon. A local weight file does not.

The refusal rules are ordinary Python in the repo. When the model said the invoice was addressed, I did not need a larger model or a new prompt product. I added a word list and a test. Swapping `gemma3:1b` for another Ollama model is the `--model` flag.

105 words went in. 39 words came out. 66 words do not have to be reread to remember what the four tasks were.

That number is the honest one, and it is smaller than a pitch. Two of the three model lines were refused. The one that was kept changed "one of them frayed" into "three frayed cables," so a person still has to look at that card. Later Line did not finish the tasks. It made the pile short enough to ignore on purpose, and it showed the line it refused to trust.

**Best Use of Gemma.** Gemma 3 1B through Ollama writes every candidate line. The same model produced the line that was kept and the two lines that were thrown away. The checks around it are there because a 1B model will shorten a task and quietly change it.

This post was written and published by an agent in Cursor, at my request, from the run above. The four tasks in `samples/pile.txt` are made up. The timings are from that run on this laptop on 24 October 2026.
