At the bottom of ikie's home screen there's a "Write anything" field. Type a line like "dentist tomorrow at 3", "report by Friday" or "workshop next Tuesday 2–4pm", and ikie reads the date, the time and whether it's an event or a task, then puts it on the board.
These days, handing that to a large language model seems like the natural move. But we decided to keep LLMs off ikie's server. Judgment comes from the Claude the user connects, and the app server handles only the calendar, the tasks and their rules. So reading a line is done with rules, and the one exception is a small model running on the device.
Reading and creating are separate
First we split the paths. There's exactly one entry point that reads text, and it creates nothing. Creating doesn't accept text at all. It takes only values: title, day, time, length and deadline.
export type Captured = {
title: string;
on?: string; // 할 날 YYYY-MM-DD
at?: string; // HH:MM, on과 함께
due?: string; // 마감 날
dueTime?: string; // 마감 시각("내일 오후 3시까지")
minutes?: number; // "3시~5시"·"1시간 동안"
now?: boolean; // "지금·당장"
until?: string; // 여러 날 일정의 마지막 날
};
(The comments read: day to do it, time with that day, deadline day, deadline time, length from "3–5pm" or "for an hour", "now", and the last day of a multi-day event.)
At first there was a path that read and created in one step, and connected tools (MCP) could use it too. Then the word "now" in titles Claude wrote for its work log started turning into events starting now. Since we split reading from creating, whoever the caller is, what's about to be created shows up first as plain values. Claude, too, now reads with a read tool and then creates by passing values to a create tool. A test fails if any code other than the natural-language entry point calls a function that reads text.
Rules are the floor
Korean is read by a parser we wrote ourselves. English, Japanese, Chinese and Spanish are read by the open-source chrono-node. Text inside quotes is masked first, so a "now" inside a quoted title isn't read as a time.
The on-device model reads through the same port (CaptureReader → Captured). So if a device has no model, or the model is slow or fails, the rule reader is still there. The model is a chance to read better, not something the app depends on.
One yardstick
Every reader is measured against one test set: 107 Korean lines, with "now" fixed at 2:00 pm on Friday, October 9, 2026 in Seoul. There are 67 tasks and 40 events. Eighty lines have a day, 50 a time, 10 a deadline, 9 a length, 5 a "now" and 4 span several days.
We put in ambiguous lines on purpose. "Chicken tomorrow evening" could be a task to buy chicken or a plan to eat it, and even people disagree on its title. For lines like that we mark which fields aren't scored (ignore).
The server test passes only when the lines the rules get wrong are exactly the listed 11. Getting more wrong fails, and so does getting fewer wrong, because then the list should shrink. The Swift copy of the rules on iOS runs against the same set.
Where the rules go wrong
The rules get 96 of 107 lines right. The 11 misses are almost all one kind: tasks with a time, like "write the report at 3" or "groceries at 7pm". The rules treat anything with a time as an event. The hard part isn't computing dates and times. It's telling meanings apart: is this "an appointment that ends when its time passes" or "something that ends only when I finish it"?
The model gets one question
At first we let the small model read dates and times too. It went badly. Small models invented times that weren't in the text, filled in 00:00 when no time was given, and were weak at date math. On the simulator, a model even read "Friday" as Sunday.
So we split the work. Rules compute the date and time, and the model picks only the kind. The model's output is constrained by a grammar so it can produce nothing but {"kind":"event"} or {"kind":"task"}: a GBNF grammar for llama.cpp, and a generation schema that picks one of two values for Apple Foundation Models. When the rules are already certain, like a line with a date and no time, the model isn't called at all.
So far, that's the Korean path. In other languages the Apple model reads more, but date math still isn't its job. We give it a table naming each day of the next two weeks ("tomorrow", "next Tuesday") and have it choose from the table. Then we throw away anything the text doesn't support, like a day the text never mentioned or a midnight nobody said.
Three models, one test set
These numbers were measured on a Mac (M2 Max, Metal) against the 100-line set we had at the time. The model was called on only 45 of the 100 lines.
LFM2 was no better than the rules, so we dropped it. You can choose LFM2.5 or Qwen3 today. Both are 4-bit quantized GGUF files downloaded on first use and run with llama.cpp.
- The download is checked with SHA-256, resumes if interrupted, and is excluded from backups.
- When opening the capture field starts the download, it waits for Wi-Fi. Tapping download in Settings uses cellular too.
- The model isn't loaded unless free memory exceeds the file size by more than 300 MB, and it's unloaded on a memory warning.
- Devices with less than 3.5 GB of RAM can't choose these readers.
The default is Apple Foundation Models where the device supports it, and the rules otherwise. Apple's model couldn't go in the same table because that Mac lacked the model assets. We don't have numbers from a real iPhone yet either. The simulator runs llama on the CPU at about 6 seconds a line, so we didn't use those numbers.
How the app combines the two
While you type, the app asks the server's rule reader and the device model at the same time. The server's reading shows first, and the model's answer replaces it when it arrives. When combining, this is the order:
- A date or time the person picked with a chip beats anything read.
- The kind comes from the person's choice, then the device model, then the server's rules.
- The create request carries a kind only if the person chose one or the device model read one. The server rules' kind isn't sent, since the server recomputes it from the same values.
That last rule was corrected in a review against our principles. The iOS app used to always send the kind it computed, so even without a model the app was deciding the kind in the server's place.
We also have to be precise about privacy. The text doesn't stay only on the device, because the server's rule reader is called too. The accurate statement is that no outside or cloud LLM ever sees it.
The comparison screen
In Settings, "Reading what you jot" is where you pick a reader and download models. Test builds also have a comparison screen ("Compare readers"). It reads one line with every reader side by side and shows the model's input (system, user, grammar), its raw output, the values extracted and the final result. You can edit the input and run it again. That's where we saw Qwen3 start writing a long <think> once the grammar was removed. The screen also scores the whole test set field by field, with first-call time, p50/p95 and memory.
What we learned
- Ask a small model a small question. Rules compute dates and read times more accurately and faster. The model gets the one question rules can't answer: what does this line mean?
- Constrain the output with a grammar. With only two values to choose from, there's no room to make things up.
- The model is a layer on top, not the floor. Because rules are the floor, the app does the same job without a model or when the model fails.
- Use one yardstick. Rules, three models and Apple's model are all set up to be measured on one test set, so "the model is better" is something we can back with numbers, not a feeling.