routined, the daemon that learns where you go
routined is the Mac daemon that learns where you go. Measured live: its three Core ML models, its sqlite schema, the off switch, and why it keeps crashing.
By Chethan Kumar S N · Updated
Of all the lowercase names in Activity Monitor, routined is the one that sounds like it was named after you. It was. The word is routine with a d bolted on, the daemon suffix, and the name is the entire job description. This is the process that learns the pattern of your days: which chair you sit in, which cafe the laptop lands on, what time you usually leave, and where you are likely to go next.
The people who go looking for it usually arrive from the other direction. They find locationd first, the location services daemon, and then they notice a second process with a similar name and a suspicious air. The two are a pair, but they do different jobs, and the division of labour is clean enough to write in one line: locationd works out where you are, and routined works out what that means.
This page is built the way the other process pages in this series are built, from the daemon’s own manual entry, its own launch configuration, its own framework, its own crash reports and one full day of its own logs, measured read only on one Mac running macOS 27.0.1 on Apple silicon with 27 days of uptime. Every command used is at the end if you want to repeat any of it.
The manual is one sentence long
Like spindump, usernoted and locationd before it, routined ships with its own manual page. routined(8) is 410 bytes, dated 2 November 2016, and it spends most of those bytes on copyright. The parts that say anything:
NAME
routined - A daemon that learns the historical location patterns
of a user.
DESCRIPTION
routined is a per-user daemon that learns historical location
patterns of a user and predicts future visits to locations.
There are no configurations to routined, and users should not
run routined manually.
That is a remarkable document, in its way. A 2016 writer at Apple sat down and described a machine learning system in two sentences that still hold ten years and eleven major OS versions later. Learn the patterns. Predict the visits. The page also contains the two answers people want before they know they want them: there is nothing to configure, and you are not supposed to run it by hand. Both are true.
A daemon that runs as you
Most daemons in this series run as root, and a few run as reserved service accounts with names like _locationd and _netbios that exist for one job only. routined belongs to the third group, the small one: it runs as your own user, because the thing it learns about belongs to you and nobody else.
$ ps -Awwo pid,ppid,user,%cpu,rss,etime,args | grep "[/]routined"
1043 1 chethankumar 0.0 32240 27-18:14:55 /usr/libexec/routined LAUNCHED_BY_LAUNCHD
Parent process 1 means launchd started it. The etime column says this particular life has lasted the full 27 days of the Mac’s uptime, and launchctl confirms it: one run since boot, last exit code “never exited”. In 27 days it has used 7 minutes and 25 seconds of processor time, about sixteen seconds a day.
The per-user design has a consequence you can see on disk. routined is sandboxed, and its home is a container in your own Library:
$ lsof -p 1043 | grep cwd
routined 1043 chethankumar cwd DIR ... /Users/you/Library/Containers/com.apple.routined/Data
A daemon with a container is a daemon with a fence around it. It cannot read your documents as a side effect of existing; it sees its own box and what the system hands it. On this Mac the container holds nothing but the fence itself, which will matter later in this page.
One more thing the ps command above hides by being a snapshot. If you develop iOS apps, you may see two or three routined rows in Activity Monitor, and only one of them is the Mac’s. Each booted iPhone simulator runtime ships its own copy, loaded from the simulator volume, serving the pretend phone. The measured Mac has one real routined and two simulated ones, for the iOS 27.0 and 27.1 runtimes. This sounds like a footnote. Keep it in mind, because it is about to explain every routined crash on this machine.
The wire from locationd
The relationship between the two daemons is not folklore. It is written into routined’s launch configuration, /System/Library/LaunchAgents/com.apple.routined.plist, and the plist is more talkative than most. It declares the events that wake the daemon, and the list is a summary of the whole feature:
| Event in the plist | What it means |
|---|---|
| com.apple.locationd.routine.leechedlocations | locationd has positions ready for it to learn from |
| com.apple.locationd.appreset | location permissions were reset, so its data must go |
| com.apple.mobile.keybagd.lock_status | the device locked or unlocked, a privacy boundary |
| com.apple.siri.cloud.synch.changed | synced Siri data changed |
| AppleAccountAddedOrDeleted | your Apple Account changed |
The first row is the one to pause on. Leech is the actual word in the actual plist. locationd catches position fixes the way a leech catches what it needs, and routined wakes up to drain them. The gatekeeper hands over the fix; the student writes down what it means.
The same plist advertises six Mach services, the doors other processes knock on: com.apple.routined.event, .internal, .registration, .safetyMonitor, .store.cache and .store.cloud. Those last two are the local database and the synced one. The fourth is the newest story, and its logs tell it better than its name does.
One setting rounds out the picture: EnablePressuredExit is true, meaning the system may reclaim this daemon’s memory when it is idle and restart it later. It has not needed to. One run, 27 days, no exits. A learner that never trips.
The machinery ships on disk
Here is the part no forum thread mentions, and it is the best evidence on the whole page. routined the binary is small, 296,720 bytes at /usr/libexec/routined, and the reason is that the daemon is a supervisor. The learning lives beside it in a private framework, CoreRoutine, 2.3 MB, and the framework’s Resources folder is an inventory of the feature:
| File on disk | Size | What it is |
|---|---|---|
| RTPlaceTypeClassifierModelMultiClass.mlmodelc | 204 KB | decides what kind of place a visit was |
| RTPlaceTypeClassifierModelRanker.mlmodelc | 112 KB | ranks the candidate answers |
| RTVisitTrajectorySequenceClassifierBatchMode.mlmodelc | 44 KB | classifies the path of a whole trip |
| CoreRoutine.momd | 152 KB | the Core Data schema of the store |
| Localizable.loctable | 132 KB | 76 English interface strings |
Those first three rows are compiled Core ML models. This is not a metaphor or a vibes-based guess about what “learning” means: the classification of what kind of place you visited, and the ranking of the candidate labels, and the judgement of the trip you took to get there, are three shipped neural networks running on device. A 360 KB student.
The .momd is just as explicit. Core Data models name their tables, and these are the entity names in routined’s schema, verbatim: a learned visit, RTLearnedVisitMO. A learned location of interest, RTLearnedLocationOfInterestMO. A learned place, a learned transition from one place to another, a learned place type inference, a predicted context, a histogram item counting the minutes at a location of interest, people density, a Wi-Fi fingerprint. The database this daemon keeps is a model of a person’s week.
The strings file is smaller but friendlier. It names the settings pane the feature lives in, and the name is newer than most documentation: “Significant Locations & Routes”, routes included. It carries the sentence the pane shows when a visit feeds a photo memory: “The Photos icon indicates this visit is being used to improve Photos Memories.” It even has the phrasing for a learned arrival, “%1$@, arrived via %2$@”, a place with the way you got there, and a confirmation title that is just “Clear History”.
One day in its logs
The unified log for a full day holds 3,502 lines from this daemon, which is a lot for a process showing 0.0 percent CPU. Sorted by category inside its own subsystem, com.apple.CoreRoutine, the day looks like this:
165 LOCATION
42 DEVICE LOCATION PREDICTOR
6 SAFETY MONITOR
2 DATABASE
The LOCATION rows are the leeching from the plist, fixes arriving and being graded. One line repeats all day and deserves quoting, because it shows the daemon auditing its own inputs: “downgrading leeched location integrity because trusted-time is unavailable”. A position whose timestamp cannot be trusted gets marked as second class before it is learned from. There is a small honesty engine in there.
The DEVICE LOCATION PREDICTOR rows are the prediction half of the man page, running and mostly failing harmlessly on a Mac that goes nowhere: “provider encountered error, Error Domain=RTErrorDomain Code=2”, the predictor asking for a provider that has no answer, again and again, using nothing but patience.
The SAFETY MONITOR rows are the surprise. Six lines, and they are not local at all. They talk to CloudKit, a private database in a container named com.apple.SafetyMonitor.SafetyCache, and the record zone has a name out of fiction: SentinelZone. That is the safety system family, the machinery behind features that notice you got where you meant to go. routined knows the places; the sentinel watches them. When it fails to fetch a location of interest, it logs exactly that, “requires a valid identifier”, and the schema above explains the word loi in the error: location of interest, one of the learned entities.
And the honest absence: on this Mac, the store is empty. No sqlite files in the container, no /var/db/routined directory, nothing learned, or the learning turned off, and either way the daemon runs its full day anyway, predicting nothing, failing quietly, costing sixteen seconds.
Why routined crashes on some Macs
This section exists because the crash reports do. Three of them, filed on this very Mac on 14 and 15 November, and each one is a small forensic gift, because the reports name their own context. The process path is inside a simulator volume. The coalition is com.apple.CoreSimulator.SimDevice, one per booted pretend phone. The responsible process is SimulatorTrampoline. And the termination, identical in all three:
"termination" : {
"indicator" : "XPC_EXIT_REASON_SIGTERM_TIMEOUT",
"namespace" : "LIBXPC"
},
"exception" : { "type" : "EXC_CRASH", "signal" : "SIGKILL" }
Read that as a story. The simulator was being shut down. Every process inside it was sent a polite quit request, with a deadline. The simulated routined did not finish quitting inside the deadline, so the watchdog killed it the impolite way, and macOS filed the kill as a crash. The dialog that result produces, routined quit unexpectedly, is the user-facing version of a process missing a bus by one second.
The real routined, the one at pid 1043, has never crashed, because it has never exited at all. So if you have these dialogs and Xcode on the same Mac, the two facts are probably one fact. The fix is not to remove a daemon. It is to let the simulator finish its own teardown, and to know that the report in DiagnosticReports was never about your system.
What Apple says, and where the switch is
Apple’s page for this feature is “Allow apps to see the location of your Mac” in the Mac User Guide, and it describes the whole system without once using the word routined, which is the normal state of affairs between Apple documentation and daemons. What it does say, verbatim, about this half of the system:
To allow your Mac to identify places significant to you and provide useful related information in Maps, Calendar, Reminders and more, turn on Significant Locations. Significant locations are encrypted and can’t be read by Apple. Click Details to view a list of locations that have been identified. You can select and remove locations from the list or click Clear History to remove all the locations.
That paragraph contains the three things worth knowing. The learning is opt in, and the switch is in System Settings under Privacy and Security, then Location Services, then System Services, as Significant Locations, in a pane whose own title is now longer than its documentation. The record is encrypted in a way Apple says it cannot read. And the front door is open: Details shows the list, each place can be removed, Clear History empties the lot, and the daemon’s own strings admit the one dependency, that clearing requires a network connection, because the synced copy has to be cleared too.
The same page makes one more disclosure worth passing on: when Siri Suggestions or Safari Suggestions are on, the Mac’s location at the moment of a search is sent to Apple to make suggestions more relevant. That is a different pipe from routined’s on-device learning, and it is the one part of the system that does leave the machine.
Two daemons, one job split in half
The shortest summary of this whole page, and of its sibling:
locationd is the instrument and the gatekeeper. It fixes the position, from Wi-Fi and GPS and motion, and it decides who may ask. routined is the student. It takes what the instrument measures and turns it into places, patterns and predictions, with shipped neural networks and a schema full of learned things.
They even coordinate at a stated precision. The locationd page recorded that the Routine client asks for positions with a DesiredAccuracy of 100 metres, a number that tells you the learning was never about pinpointing anyone. It wants the neighbourhood, not the address. Knowing the neighbourhood is what lets Calendar suggest a departure time, and Maps know the difference between a place you live and a place you were stuck in traffic near.
A daemon that learns your day, runs as you, never exits, costs sixteen seconds and 32 MB, crashes only inside pretend phones, and keeps its entire education in a fenced container with a Clear History button on the front. Of everything in this series, this is the one whose reputation least matches its measurements.
See for yourself
Every claim above came from commands like these, all read only:
$ ps -Awwo pid,ppid,user,%cpu,rss,etime,args | grep "[/]routined"
$ man routined
$ plutil -p /System/Library/LaunchAgents/com.apple.routined.plist
$ launchctl print gui/$(id -u)/com.apple.routined | grep -E "runs|last exit"
$ lsof -p $(pgrep -x routined) | grep cwd
$ ls /System/Library/PrivateFrameworks/CoreRoutine.framework/Versions/A/Resources
$ strings "/System/Library/PrivateFrameworks/CoreRoutine.framework/Versions/A/Resources/CoreRoutine.momd/CoreRoutine 8.mom" | grep ^RT
$ log show --last 24h --predicate 'process == "routined"' --style compact
$ ls ~/Library/Logs/DiagnosticReports | grep -i routined
The crash reports themselves open in any text editor, or Console, under Device, Diagnostic Reports. The interesting fields are coalitionName, responsibleProc and termination, and together they will usually tell you whether the crash was your Mac’s or a simulator’s.
Questions
What is routined on Mac?
It is the daemon that learns your routines. Its own manual page, unchanged since November 2016, describes it as a per-user daemon that learns historical location patterns of a user and predicts future visits to locations. Where locationd, the daemon people usually find first, fixes your position and decides who may ask for it, routined is the second half of the system: the one that watches those fixes over time, works out which places matter to you, and feeds that knowledge to Maps, Calendar, Reminders and Siri Suggestions. It runs as your own user account, not root, it lives in a sandboxed container, and on the Mac measured here it spent about sixteen seconds of processor time a day on the job.
Why does routined keep crashing or quitting unexpectedly?
On the Mac measured here, routined filed three crash reports in two days, and every one of them was a copy running inside an iPhone simulator. The reports name their own context: the coalition is com.apple.CoreSimulator.SimDevice, the responsible process is SimulatorTrampoline, and the termination is LIBXPC with the indicator XPC_EXIT_REASON_SIGTERM_TIMEOUT, a SIGKILL. In plain terms, the simulator was being torn down, the simulated phone's routined missed its quit deadline, and the watchdog killed it and filed the paperwork. The real system copy has run for 27 days without exiting once. If you see a routined quit unexpectedly dialog, the honest first question is whether Xcode simulators are involved.
What are the com.apple.routined sqlite files people find?
Searches for routined often lead to files named Local.sqlite, Cache.sqlite and Cloud-v2.sqlite under a routined container, usually inside an iPhone backup. Those names are real: the daemon's own framework ships a Core Data model whose entities are literally learned things, including a learned visit, a learned location of interest, a learned place, a learned transition between places, and a predicted context. The local store is the learning, the cache is the working set, and the cloud copy is the end to end encrypted sync. On the Mac measured here none of these files exist on disk, which is what the feature looking untouched looks like. Finding them in a backup is expected; finding them missing on a Mac is too.
Is routined tracking me, and how do I turn it off?
It learns, it does not follow. Nothing is recorded without Location Services being on, and Apple's own page for the feature, which never names routined at all, states the terms: significant locations are encrypted and can't be read by Apple, and you can open Details to view the list, remove individual places, or clear the whole history with one button. The switch lives in System Settings, under Privacy and Security, then Location Services, then System Services, as Significant Locations, listed in the daemon's own interface files as Significant Locations and Routes. Turning it off stops the learning. The position fixing and the permission checks are locationd's job, not this one's.
What is the difference between routined and locationd, and why does routined hold 32 MB?
locationd is the gatekeeper and the instrument: it works out where the Mac is and decides which apps may know. routined is the student: it takes the positions locationd collects, decides which of them are places, and predicts where you will go next. The handoff between them is written down in routined's own launch configuration, which wakes it for a notification literally named leechedlocations. The memory gap is the tell. locationd measured 19 MB; routined measured 32 MB, because it carries three Core ML models that classify what kind of place a visit was, plus a database schema with a dozen learned entity types. A clerk needs a ledger; a student needs a library.
Ready? Buy Ribbon for $15, or read all the guides.