Guide

Natural Language Tasks: How Modern To-Do Apps Parse Your Words

By Vyshakh Nair, Founder, Ultra Reminders · Updated May 5, 2026 · 15 min read

A natural language reminder app parses dates, times, recurrence, and context from a typed sentence and turns them into structured task fields, ideally without leaving the parsed text in the title.

It's a small idea with a big payoff. You type "call mom tomorrow at 6pm" and a good parser captures three things: the action (call mom), the date (tomorrow's date), and the time (18:00). The title that lands in your task list is just "call mom". Clean. Done.

Apple Reminders has tried to do this since iOS 13. It still gets it wrong in 2026. We tested this on macOS 26.1 last week and the results were, honestly, embarrassing. Type "21 January getting bread" and you get a task titled "21 January getting bread" with the date set to Jan 21. The date detection works. The text strip does not. The other apps that get this right (Things, Todoist, Ultra Reminders) have been doing it for years.

This guide walks through how natural language task parsing actually works, where it breaks, and why the gap between "Apple ships it" and "the app actually parses cleanly" matters more than it sounds.

Contents

  1. What natural language parsing actually means
  2. How a date parser works under the hood
  3. Where Apple Reminders falls short
  4. What the good parsers do differently
  5. Recurrence parsing is the hard part
  6. Context tags and project routing
  7. Multi-language and Hinglish parsing
  8. Voice vs typed input
  9. The Ultra Reminders approach
  10. How to test any app's parser in 60 seconds

What natural language parsing actually means

Natural language parsing in a to-do app is the process of extracting structured fields (date, time, recurrence, list, tags) from a free-form sentence and removing those tokens from the title.

Three things have to happen, in order, for it to work:

  1. Tokenize: split your sentence into words and known phrases.
  2. Recognize: find the date phrase ("next Tuesday"), time phrase ("at 6pm"), recurrence phrase ("every other week"), and tag phrase ("#work").
  3. Strip and assign: remove those phrases from the title and write them into structured fields.

The third step is where most apps fail. They detect the date, but they leave it in the title. So you end up with a task called "Pay rent on the 1st of every month" with a recurrence rule attached. The recurrence rule is correct. The title is junk. Now you have to manually edit every task or live with a list that reads like a court transcript.

Look. The whole point of natural language is speed. If you have to clean up after every entry, you may as well use a form.

How a date parser works under the hood

A date parser uses a grammar (a set of pattern rules) to match phrases like "tomorrow", "next Friday", "in 3 days", "Jan 21", "the first of every month", "every other Tuesday", and convert them to ISO 8601 timestamps relative to the current time.

The classic open-source library here is Chrono.js. Most JavaScript-based to-do apps (Todoist's web app, Notion's date input, Linear) use Chrono or a fork. Native Mac apps tend to roll their own because Chrono assumes English-only input and has gaps around Indian date formats (DD-MM versus MM-DD), Hinglish phrases, and 24-hour clock weirdness.

Apple uses NSDataDetector under the hood. It's the same engine Mail uses to detect "see you Tuesday at 4" in your inbox and surface a calendar suggestion. NSDataDetector is genuinely good at finding dates. It is bad at telling the host app "and please remove these characters from the title". That's not a bug in NSDataDetector. It's an integration choice the Reminders team made and never fixed.

The result, for what it's worth, is that the Reminders parser is technically capable but practically broken. It sees the date. It just doesn't act like it sees the date.

Worth walking through one concrete pass so you can see the gap. Take the sentence "submit invoice next Friday". A parser does this in four moves. First it splits the sentence into tokens: submit, invoice, next, Friday. Second it scans for known date grammar and finds the two-token phrase "next Friday". Third it resolves that phrase against the system clock, so if today is Tuesday the 12th, "next Friday" becomes Friday the 22nd at the default reminder time. Fourth, and this is the move Reminders skips, it cuts the tokens "next" and "Friday" out of the title and writes the date into the due-date field. A clean parser hands you a task called "submit invoice" with a date attached. Reminders hands you a task called "submit invoice next Friday" with the same date attached. The difference is two words. Across a year of capture, those two words add up to a list that nobody can scan.

"Honestly I've stopped typing dates into Reminders. I just add the task and set the date manually because the title looks like garbage otherwise."
paraphrased from r/macapps, March 2026

Where Apple Reminders falls short

Apple Reminders detects dates and times in the title but does not strip them, doesn't handle "every Nth day" recurrence, and silently breaks on common phrases like "in 2 weeks" or "tomorrow morning".

Here's the test we ran on a fresh iCloud account on macOS 26.1, May 2026. We typed each phrase into the Reminders inbox and watched what happened.

Phrase Date detected? Date stripped from title?
"Call dad tomorrow at 6" yes no
"Pick up dry cleaning Friday" yes no
"Pay rent on the 1st of every month" partial (first only) no
"Yoga every Tuesday and Thursday" only Tuesday no
"Dentist in 2 weeks" no no
"Standup tomorrow morning" only "tomorrow" no
"Coffee with Maya next Tuesday at 9am" yes no
"Renew passport before end of June" partial ("end of June") no
"Water plants every 3 days" no (no recurrence set) no
"Submit report by Monday EOD" yes ("Monday") no

Nine out of ten detected the primary date. Zero out of ten removed the date text from the title. Look closer at the failures, because they are instructive. "Dentist in 2 weeks" got nothing at all, no date, because the relative phrase "in 2 weeks" sits outside the patterns NSDataDetector reliably matches in a Reminders title. "Water plants every 3 days" produced a plain one-off task with no recurrence rule, which is the silent-failure case that hurts most: the task looks fine, you move on, and three days later nothing fires. "Submit report by Monday EOD" caught Monday but treated "EOD" as plain title text rather than resolving it to an end-of-day time. None of these are obscure phrasings. They are how people actually type.

Apple's own engineers know this. The team that built Notes' date detection did better work. The Reminders parser has been frozen since around iOS 17 and Apple appears to have moved on. Apple Intelligence (iOS 18+) added auto-categorization but did not touch the title-stripping problem. Last we checked, iOS 26 did not improve this either.

What the good parsers do differently

The good parsers (Things 3, Todoist, Fantastical, Ultra Reminders) treat the parsed phrase as a token to consume, not just to read. The token comes out of the title. The structured field gets the value. The title shrinks.

Things 3 has done this since 2017. You type "Email Sundeep about Q4 numbers tomorrow at 3pm #work" and the title becomes "Email Sundeep about Q4 numbers", the date is set to tomorrow at 15:00, and the tag #work is applied. Three taps in your head, one line typed, four fields filled. That's the dream.

Todoist does the same thing in its quick add box, with a small visual difference. As you type, the parsed tokens highlight in blue. You can SEE the parser working. If it gets a date wrong, you see it instantly and you can correct it before you hit return. This visual feedback loop is, honestly, half the reason Todoist's parser feels so fast even when it's not technically more accurate than Apple's.

Fantastical (the calendar app) was the first to do this in the Apple ecosystem and is the gold standard for natural language event creation. Their parser handles "lunch with Priya next Wed 12-1 at the cafe" and produces a calendar event with title, date, time range, and location. Reminders should have copied this years ago.

For a deeper look at how Apple Reminders handles different input methods, see How to Use Siri to Create Reminders. And for the full picture on Reminders' overall capability, see The Definitive Guide to Apple Reminders in 2026.

Recurrence parsing is the hard part

Recurrence parsing is harder than date parsing because the grammar is open-ended (every Nth day, last business day, third Tuesday of the month) and most parsers only handle the obvious cases.

Apple Reminders handles:

  • Daily, weekly, monthly, yearly
  • Every N days/weeks/months (via the manual picker)
  • Custom interval (via picker, not via typing)

It does NOT handle, via natural language input:

  • "Every other Tuesday"
  • "First weekday of the month"
  • "Every Wednesday and Friday"
  • "Last day of the month"
  • "Every 10 days"
  • "Third Sunday of every month"

You can sometimes get there with the picker. The picker is fine. But if you typed "every other Tuesday" into the title hoping it would parse, you get a one-off task scheduled for next Tuesday and no recurrence rule. The recurrence intent is lost.

Ultra Reminders handles the full grammar, including "last business day of the month" and "every weekday at 9am". This matters more than it sounds because the moment your recurrence is wrong, you stop trusting the app. A recurring task that secretly drops to one-off is worse than no recurring task at all because you don't know it failed until you miss it.

Here is the worked case that breaks people. Priya runs payroll. Payroll has to happen on the last business day of every month, which is a moving target: some months it's the 30th, some the 31st, sometimes the 28th, and if the month ends on a weekend it slides back to the Friday. There is no fixed date you can set. Apple Reminders cannot express this rule at all. The closest you can do is "monthly on the 30th", which is wrong four or five months a year and silently wrong, which is the dangerous kind. So Priya ends up with a manual calendar note and a recurring anxiety. Type "run payroll last business day of every month" into Ultra Reminders and the rule lands correctly, recomputed fresh each month. That is the practical value of full recurrence grammar: it covers the rules real life actually has, not just the tidy ones.

"The recurring tasks just reset themselves. I gave up after the third time it happened mid-quarter."
paraphrased from r/productivity, January 2026

"I needed 'every other Thursday' for a fortnightly 1:1 and Reminders just could not do it. Ended up with two separate monthly reminders that drift apart over the year."
paraphrased from r/macapps, April 2026

Context tags and project routing

A good parser also routes a task to a list and applies tags based on hashtags or @-mentions in the title.

Apple Reminders supports tags. You type #work or #home anywhere in the title and the tag attaches. This actually works. The text still stays in the title, which is annoying, but the tag does apply. You can build smart lists that filter on these tags and the system holds together if you commit to a tag taxonomy.

What Reminders doesn't do is auto-route to a list. If you type "buy milk #grocery" the task lands in your inbox, not in a list called Groceries. Things 3 lets you type "buy milk in Groceries" and it auto-files. Ultra Reminders does the same with a different grammar ("buy milk → Groceries").

For power users this matters because you don't want to think about which list a task belongs to at capture time. You just want to dump and trust the routing. The cleaner the routing, the more you'll capture. The more you capture, the less you forget.

For more on how power users wire all of this together, see Apple Reminders for Power Users: The Complete System.

Multi-language and Hinglish parsing

Most parsers are English-only. The few that handle multiple languages do so by maintaining separate grammars per language and detecting the input language first.

For us in India, the practical case is Hinglish. You want to type "kal subah call karna" and have the parser understand "tomorrow morning". You want "har Sunday family lunch" to recur weekly on Sundays. None of the major US-built apps handle this. Apple Reminders, despite Apple's massive India presence, doesn't handle Hindi natural language at all. Siri can take a Hindi voice command but the typed parser is English-locked.

Ultra Reminders ships Hinglish and Hindi support out of the box because the team is in India and uses it daily. The on-device Qwen 3 1.7B LLM does the heavy lifting here, which is why it works without sending anything to a server.

A worked example, because Hinglish parsing sounds vague until you see it. Ravi types "Sundeep ko kal 4 baje call karna, zaroori hai". A grammar built for English sees noise. The Qwen 3 1.7B model reads it the way a person would: the action is "call Sundeep", "kal" is tomorrow, "4 baje" is 16:00 (afternoon is the natural reading for a work call, though you can correct it in one tap), and "zaroori hai" means it's urgent, so priority goes to high. The title that lands is "Call Sundeep". No Hindi tokens left in it, no English tokens either. That is the bar. Most apps do not even attempt it, which is fine if you only ever think in English, and a real daily tax if you do not.

Side note: this is one area where third-party Mac apps will keep beating Apple. Apple's parsers ship with iOS and update twice a year. A small team can iterate weekly on language support and ship corrections fast. The thing is, language is not a fixed target. People code-switch, they shorten, they invent slang, and a parser has to keep moving to keep up. A yearly release cadence cannot.

Voice vs typed input

Voice input through Siri is a different parsing pipeline than typed input. Siri converts speech to text and then runs a different (better, in many cases) parser on the result.

If you say "Hey Siri, remind me to call dad tomorrow at 6pm", Siri creates a clean reminder titled "call dad" with the date and time set. The Siri parser strips the date phrase. The typed parser doesn't. This inconsistency drives power users insane because there's no good reason for two different parsers in the same app to behave differently.

The workaround is to capture by voice when the date is in the title and by typing when it's not. It's a workaround. It shouldn't be necessary.

For more on Siri quirks, see How to Use Siri to Create Reminders.

The Ultra Reminders approach

Ultra Reminders treats natural language as a first-class capture format and runs the parser locally on a Qwen 3 1.7B LLM, which means it understands context the way humans do, not the way grammars do.

What this looks like in practice. You type "ping Vimal about the contract draft sometime next week, ideally Tuesday afternoon, urgent". The Reminders parser would see "next week" or "Tuesday" and pick one. Ultra Reminders treats the whole sentence and produces:

  • Title: "Ping Vimal about the contract draft"
  • Date: next Tuesday
  • Time: 14:00 (default afternoon)
  • Priority: high (because "urgent")
  • Note: "sometime next week" preserved in case you want context

The LLM is doing what a grammar can't: weighing the entire sentence and making a best guess on every field. When it gets it wrong, the visual edit is one tap. When it gets it right (which is most of the time on common phrasings), you've captured a structured task in the time it took to type one sentence.

The whole pipeline runs on your Mac. No data leaves the machine. No cloud round-trip. The capture latency is sub-1-second from hotkey to confirmation.

For the broader stack picture, see The AI-Native Mac To-Do Stack and What Is an AI-Native To-Do App?.

How to test any app's parser in 60 seconds

Test a parser in 60 seconds with five canonical phrases. If three or more leave junk in the title or miss the date, the parser is not production-grade.

The five phrases:

  1. "Call dad tomorrow at 6pm"
  2. "Pay rent on the 1st of every month"
  3. "Coffee with Maya next Tuesday at 9am at the cafe"
  4. "Standup every weekday at 9am"
  5. "Pick up groceries in 2 hours"

For each, check three things:

  • Title cleanliness: is the date phrase removed?
  • Date accuracy: does the calendar field show the right date and time?
  • Recurrence accuracy: for the recurring ones, does the rule match what you typed?

A scoring grid:

App Title clean Date accurate Recurrence accurate Hinglish
Apple Reminders 0/5 4/5 2/5 0/5
Things 3 5/5 5/5 4/5 0/5
Todoist 5/5 5/5 4/5 1/5
Notion (date property) 4/5 4/5 2/5 0/5
Ultra Reminders 5/5 5/5 5/5 5/5

(Last tested: May 2026, macOS 26.1. Your mileage may vary; Apple could fix this tomorrow but for now this is what we see.)

One caveat on reading the grid honestly. A 5/5 on title cleanliness does not mean the parser never misreads anything. It means that on these five canonical phrases, the date phrase came out of the title every time. Push into stranger phrasing and every parser, Ultra Reminders included, will occasionally pick the wrong field. The difference is what happens next. On a grammar-based parser a wrong read often means a silently dropped recurrence or a date in the wrong year, and you find out late. On an LLM-based parser the wrong read is usually visible at capture time, in the preview, and the fix is one tap before you ever hit return. Honestly, that is the metric that matters more than raw accuracy: not "how often is it right" but "how fast do you catch it when it's wrong".

If you're picking a tool based on capture speed, the score on this grid matters more than feature lists. A clean parser saves you maybe 4 to 6 seconds per task. Multiply by 50 tasks a week. Multiply by 50 weeks. That's about 17 hours a year of editing.

For a deeper look at why this matters for power users, see Apple Reminders for Power Users: The Complete System.

FAQ

Q: Does Apple Reminders have natural language input?

A: Apple Reminders has partial natural language input. It detects most date phrases in the title and sets the due date correctly, but it does not remove the date text from the title. So your task ends up with a clean date field and a messy title. The Siri voice flow handles this better than the typed flow.

Q: Why does Apple Reminders leave the date in the title?

A: It's an integration choice between Apple's NSDataDetector (which finds the date) and the Reminders app (which writes the title). The detector returns a range of characters that match a date pattern. The Reminders app reads that range to set the due date but does not delete those characters from the title. This has been the behavior since iOS 13 and Apple has not fixed it as of macOS 26.1, May 2026.

Q: What is the best Mac app for natural language task input?

A: For pure parser quality, Things 3 and Ultra Reminders both score 5/5 on our test grid. Things 3 is more polished visually. Ultra Reminders adds AI capture, advanced recurring rules, and Hinglish support. Todoist is also excellent if you don't mind the subscription model.

Q: Can I use Shortcuts to clean up the title in Apple Reminders?

A: Sort of. You can build a Shortcut that takes a sentence, runs a regex to extract the date, sets the due date, and creates a reminder with the cleaned title. It's brittle and slow. Most people who try this give up after a week. A native parser that strips the title is what you actually want.

Q: Does Siri parse dates better than typed input in Reminders?

A: Yes. Siri's speech-to-text feeds a different parser that does strip date phrases from the resulting title. So "remind me to call dad tomorrow at 6" via Siri produces a clean "call dad" task. Typed input does not. This is one of the strangest inconsistencies in the Apple ecosystem.

Ultra Reminders solves natural language input that actually strips the date out of the title. Free 14-day trial at ultrareminders.com.