HeartbeatHocusFocusFilesMacHyperTile
Guide

mediaanalysisd, the daemon that looks at what is in your photos

mediaanalysisd is the Mac daemon that reads your photos and videos. What it builds, the 244 MB of models it ships, and how to get it to stop.

By Chethan Kumar S N · Updated

If you sort Activity Monitor by CPU and wait long enough, a name with no vowels in useful places will turn up: mediaanalysisd. It has no icon, it does not appear in any settings pane, and when you search for it the two answers you get are that it is malware and that you should disable it. The second answer is the more dangerous of the two, because there is nothing to disable and the instructions people follow to try will leave their Photos library in a worse state than they found it.

The name breaks down easily once you know the pattern. The letters MAD stand for Media Analysis Daemon, and the d on the end is the ordinary Unix convention for a background process. So the whole thing means the background service for analysing media. Nothing in the name refers to a file of yours.

Everything below comes from three places: Apple’s own documentation, the files the daemon and its framework ship on disk, and read-only checks on the Mac this was written on, a 14 inch MacBook Pro with an M1 Pro running macOS 27.0.1. Nothing was uninstalled, no photo or video was touched, and no setting was changed.

What mediaanalysisd actually is

One command gives you its identity:

$ ps -Awwo pid,ppid,user,%cpu,%mem,rss,etime,comm | grep -i "[M]ediaAnalysis"
  78454     1 chethankumar  0.0  0.0  11840  06:33:11 /System/Library/PrivateFrameworks/MediaAnalysis.framework/Versions/A/mediaanalysisd

Read the columns in order. The parent process is PID 1, which is launchd, so the system started it and not an app. It runs as your user account rather than as a system account. It lives inside a framework in the System folder rather than in /usr/libexec, which is where most of the daemons with names like this one sit.

That second point is worth pausing on, because it is different from its neighbours. The download daemon nsurlsessiond runs two copies, one as you and one as a privileged account called _nsurlsessiond whose declared purpose is written into the user database. There is no equivalent here:

$ dscl . -read /Users/_mediaanalysisd
<dscl_cmd> DS Error: -14136 (eDSRecordNotFound)

No such account exists. mediaanalysisd has no privileged half, and that is deliberate: it does not need one. Every photo library it is allowed to read belongs to a human who is logged in, so it runs as that human and asks the operating system for permission like any other process would.

That brings up the sandbox. The daemon carries an entitlement called com.apple.security.app-sandbox, so it cannot wander the disk even though it runs as you. What it gets instead is a list of specific grants, and reading that list tells you exactly what the process is for:

$ codesign -d --entitlements - /System/Library/PrivateFrameworks/MediaAnalysis.framework/Versions/A/mediaanalysisd | grep -c "\[Key\]"
58

Fifty eight entitlement keys. Among them are com.apple.private.security.storage.Photos for reading the library, com.apple.private.tcc.allow listing Photos, Address Book and Willow, com.apple.private.corespotlight.search.internal for handing results to Spotlight, and com.apple.private.homekit.cameraclips for camera video. Two more are the ones that explain the heat. The first is com.apple.aned.private.allow, plus an IOKit grant for the class H11ANEInDirectPathClient, which is how a process gets at the Neural Engine directly instead of going through the CPU or the GPU. The second is com.apple.TextUnderstanding.process, which is permission to run Apple’s text embedding model.

There is also a list of asset types it is allowed to download, and it is the reason this framework is not a fixed size. It includes com.apple.MobileAsset.ImageCaptionModel, com.apple.MobileAsset.UAF.AppleEmbeddingModel, com.apple.MobileAsset.UAF.FM.GenerativeModels, com.apple.MobileAsset.UAF.FM.Visual and com.apple.MobileAsset.UAF.FM.Overrides. The models that come with the operating system are not necessarily the models it runs. New ones arrive later as asset updates, and the daemon has the permissions to fetch them.

The binary, for anyone who wants the receipts

The executable itself is a normal Apple binary with an unusually broad set of instructions inside it:

$ file /System/Library/PrivateFrameworks/MediaAnalysis.framework/Versions/A/mediaanalysisd
Mach-O universal binary with 3 architectures: [x86_64] [arm64e] [arm64e.x1]
$ ls -l /System/Library/PrivateFrameworks/MediaAnalysis.framework/Versions/A/mediaanalysisd
-rwxr-xr-x  1 root  wheel  11387072 Sep 24 12:40 mediaanalysisd
$ codesign -dvvv /System/Library/PrivateFrameworks/MediaAnalysis.framework/Versions/A/mediaanalysisd 2>&1 | grep Identifier
Identifier=com.apple.mediaanalysisd

Eleven megabytes, three architectures including the arm64e variant Apple uses for code that talks to the kernel and the Neural Engine, and signed with its own identifier. The size is the honest signal here. A shell script masquerading as a daemon looks like a shell script, and this does not.

For comparison, the daemon that orchestrates it, photoanalysisd, is a 363 kilobyte binary. mediaanalysisd is around thirty times larger, and the reason is that the two do different jobs. photoanalysisd decides what needs analysing and in what order. mediaanalysisd does the looking. The third in the set, photolibraryd, owns the library itself and hands out the work, and it is the smallest of the three in both size and processor time.

The folder in your home Library that holds its own database

This is the part almost nobody knows, and it answers the question people actually have, which is what the process is working on.

In your home folder, Library, MediaAnalysis, there is a folder with the daemon’s own state in it:

$ ls -la ~/Library/MediaAnalysis/
drwxr-xr-x@  6 chethankumar  staff      192 Sep 23 19:55 .
drwxr-xr-x@  5 chethankumar  staff      160 Sep 23 19:55 Home
-rw-r--r--@  1 chethankumar  staff   147456 Oct 21 21:51 MediaAnalysis.sqlite
-rw-r--r--@  1 chethankumar  staff    32768 Nov 12 07:02 MediaAnalysis.sqlite-shm
-rw-r--r--@  1 chethankumar  staff  2892272 Nov 12 07:52 MediaAnalysis.sqlite-wal

Three files, one of them a write ahead log nearly three megabytes long. Note where this is not. It is not inside the Photos library, which macOS protects from casual inspection, and it is not in a container. It sits in the same Library folder as your preferences, and it is readable without any special access.

The tables inside name the work in plain English:

$ sqlite3 ~/Library/MediaAnalysis/MediaAnalysis.sqlite ".tables"
ZBACKGROUNDACTIVITYSCHEDULE      ZMADREQUEST        Z_METADATA      Z_PRIMARYKEY
ZBACKGROUNDACTIVITYSESSIONLOG    ZSPOTLIGHTENTRY    Z_MODELCACHE

ZMADREQUEST is a queue of requests, one per asset, with columns for the request type, the bundle identifier that asked for it, how many attempts it has had, and when it will next be tried. On this Mac it held zero rows, which is a good sign rather than a bad one: a queue with nothing in it means the backlog is clear.

ZBACKGROUNDACTIVITYSCHEDULE is the history, one row per time the daemon was woken to do something. There were 225 rows spanning 21 September to 12 November, and the numbers in them are more useful than any guess about what the process is doing:

$ sqlite3 ~/Library/MediaAnalysis/MediaAnalysis.sqlite \
  "select count(*) n, min(datetime(ZSTARTTIMESTAMP+978307200,'unixepoch','localtime')) first,
   max(datetime(ZSTARTTIMESTAMP+978307200,'unixepoch','localtime')) last from ZBACKGROUNDACTIVITYSCHEDULE;"
225|2026-09-21 07:26:57|2026-11-12 07:51:20
$ sqlite3 ~/Library/MediaAnalysis/MediaAnalysis.sqlite \
  "select round(sum(ZDURATION),0) total_sec, round(sum(ZDURATION)/60.0,1) total_min from ZBACKGROUNDACTIVITYSCHEDULE;"
10905.0|181.7

Ten thousand nine hundred and five seconds. Three hours and one minute of work, spread across 25 days of uptime. That is the whole cost of the analysis on this machine in processor seconds, and it gives you the right way to think about the process. It is not a background hum that never stops. It is a series of errands that take an average of under a minute each.

The exit statuses in the same table are worth showing, because they are the reason people believe the daemon is crashing:

$ sqlite3 ~/Library/MediaAnalysis/MediaAnalysis.sqlite \
  "select ZEXITSTATUS, count(*) n from ZBACKGROUNDACTIVITYSCHEDULE group by 1 order by n desc;"
0|206
-128|18
-18|1

Two hundred and six clean finishes, eighteen with a status of minus one hundred and twenty eight, and one with minus eighteen. Minus one hundred and twenty eight is the standard Unix value for a process killed by a signal, and in this table it means the system stopped the work rather than that the work failed. It is what happens when you come back to the keyboard, or when the machine is unplugged, and macOS decides the analysis can wait. Nothing is lost, because the request goes back on the queue.

The third table is the most descriptive of all. ZBACKGROUNDACTIVITYSESSIONLOG stores a JSON payload per session, and the payload counts assets:

$ sqlite3 ~/Library/MediaAnalysis/MediaAnalysis.sqlite \
  "select substr(ZPAYLOAD,1,180) from ZBACKGROUNDACTIVITYSESSIONLOG order by Z_PK desc limit 1;"
{
  "TotalPrepareTimeInSeconds" : 0.0014259815216064453,
  "NumberOfAssetsFailed" : 1,
  "NumberOfAssetsFetched" : 744,
  "TotalPublishTimeInSeconds" : 0.0090010166168212893,
  "TotalProcessTimeInSeco...

Read the two counts together. It fetched 744 assets and analysed two of them, which is the whole design in one line. The daemon does not pull your library into memory. It walks a list of identifiers, checks which ones still need work, fetches only those, and leaves the rest alone. That is why a session that touches a 744 item library can take two seconds.

There is a second database in the same folder, under Home:

$ sqlite3 ~/Library/MediaAnalysis/Home/HKSVStore.sqlite ".tables"
ACHANGE  ATRANSACTIONSTRING  ZCLIP  ZSIGNIFICANTEVENT  Z_MODELCACHE
ATRANSACTION  ZCAPTION  ZEMBEDDING  Z_METADATA  Z_PRIMARYKEY

ZCLIP, ZCAPTION and ZEMBEDDING are the HomeKit Secure Video tables: recorded camera clips, the captions written for them, and the vectors used to search those captions later. On this Mac every one of them held zero rows, because there is no HomeKit camera on this network. On a Mac that is acting as a home hub, that is where the results of your camera analysis live.

The 244 megabytes of models inside the framework

Sitting next to the binary is a Resources folder, and this is where the size of the process comes from:

$ du -sh /System/Library/PrivateFrameworks/MediaAnalysis.framework/Versions/A/Resources/
244M
$ ls /System/Library/PrivateFrameworks/MediaAnalysis.framework/Versions/A/Resources/ | wc -l
145

A hundred and forty five files, a quarter of a gigabyte, shipped with the operating system and not paid for by the Photos library. The biggest ones are worth naming, because the names are unusually honest:

$ du -sh .../Resources/* | sort -rh | head -8
 66M  mubb_md8.mlmodelc
 32M  regressiontree_landmark.dat
 21M  rtree_landmark_tracking.dat
9.4M  cnn_pet_pose.espresso.weights
8.8M  cnn_human_pose.espresso.weights
7.2M  face_model_tensor.dat
6.8M  hand_keypoint_detector_lite.espresso.weights
6.4M  cnn_moflow.espresso.weights

Inside the 66 megabyte bundle is a file called aem-md8-video-encoder-pal-6bit-grp-4.bin. AEM is the Apple Embedding Model, and this is the video half of it, quantised to six bits and shared in four groups so that it fits in memory alongside everything else. The landing point trees, at 32 and 21 megabytes, are the face landmark tracking structures.

Then there is the long tail, and this is where the folder turns into a list of everything macOS has been trained to notice. There is cnn_blur and cnn_blurV2 for sharpness, cnn_blink for eyes closed, cnn_smile for expressions, cnn_saliency for what the eye goes to in a frame, cnn_pets_detector_v2 and cnn_pet_pose for animals, cnn_human_pose, cnn_human_pose_single and cnn_human_pose_lite_v2 for people, hand_keypoint_detector_lite and hand_keypoint_detector_acc_v2 for hands, and gesture_recognition for what those hands are doing.

The video side is where it gets specific. There is video_backbone, cnn_moflow for motion flow, flow_estimation_2 through flow_estimation_6, and a set of small classifier heads with names taken from photo editing rather than computer vision: autoplay_head, highlight_head, quality_head, cameramotionscore_head, cameramotiontype_head and action_recognition_head. Those are the models that decide whether a clip is worth playing on its own, whether it belongs in a Memory, and whether the camera was moving while it was shot.

And then there is a list of things the video classifier can name:

$ plutil -convert json -o - .../Resources/action_taxonomy.plist
["none","other_action","walking","clapping","jumping_leaping","running_jogging","kissing",
 "hugging","dancing","crawling_baby_only","Martial_Arts","Playing_musical_instrument",
 "throwing_an_object","kicking_an_object","skateboarding","swimming","playing_on_a_slide",
 "eating_food_0-3_yr_old","hiking","yoga","playing_tennis","skiing","snowboarding", ...]

Thirty five labels. Every one of them is something you could have said yourself, except for the two that carry a suffix, crawling_baby_only and eating_food_0-3_yr_old, which are Apple’s own annotations for the cases where the action belongs to a specific age group. That kind of label hygiene is the difference between a model that tells you a video contains “eating” and one that tells you it contains a baby eating.

One more file in the same folder deserves its own paragraph, and it is the reason the Photos app has a collection you have probably wondered about.

Where the identity document collection comes from

Apple’s own guide to the Photos app lists, without explanation, a set of Utilities collections that exist because of what is in the picture rather than when it was taken: “find collections of photos based on the content of the photo, like identity documents, receipts, handwriting and illustrations.” It does not say how the app knows.

The framework answers it. Two versions of a classifier configuration ship side by side, and they name the document types one by one:

$ python3 -c "import plistlib; d=plistlib.load(open('.../MADContentClassificationAnalyzer-MD8.plist','rb')); print(len(d), sorted(d))"
22 ['aadhaar-card-text','barcode-text','barcodes-text','driving-license-jp','driving-license-text',
 'driving-license-tw','passport-cn','passport-es','passport-kr','passport-mx','passport-text',
 'passport-tw','social-security-number','visa-at','visa-ca','visa-cn','visa-hk','visa-jp',
 'visa-kr','visa-mx','visa-text','visa-tw']

The older file, MD7, has seventeen entries and a different approach: it goes by country, with driving licences for Brazil, Canada, China, Germany, the United Kingdom, India, Japan, Korea, the Philippines, Turkey, the United States and Vietnam, a generic passport class, plus a permanent account number card and a voter card for India. The newer MD8 file splits the passports by country, adds visas for Austria, Canada, China, Hong Kong, Japan, Korea, Mexico and Taiwan, and adds five classes with -text on the end that recognise the documents by reading them rather than by looking at their layout.

Each entry carries a 1024 byte embedding, an identifier and a minimum score, and several also carry a predicate requiring the barcode detector to fire first. In plain terms, it is a two stage system: find a code or a strip of machine readable text, then decide which of the listed documents it probably is.

Two things follow from reading that file. The first is that the collection exists because someone at Apple maintained a list of documents for each country, and the list is the kind of detail you only build if the feature is expected to be genuinely useful rather than a demo. The second is that the classifier is looking for things a person would not want to hand around, which is exactly why the Hidden album and the Recently Deleted album are locked by default elsewhere in the same app.

Why it runs when it runs

Unlike the download daemon, which has no timer at all, this one is scheduled, and the schedule is written down where you can read it. The launch agent is a 2,624 byte property list with a repeating task in it, and the live copy in launchd spells out seventeen separate triggers:

TriggerTypical allowanceExternal power
photos.full3,600 srequired
photos.full.cluster3,600 srequired
photos.fullimage3,600 srequired
photos.person7,200 srequired
photos.face7,200 srequired
photos.scene3,600 srequired
photos.ocr600 srequired
photos.visualsearch3,600 srequired
photos.textunderstanding3,600 srequired
photos.maintenance3,600 srequired
photos.telemetry3,600 srequired
photos.pecnot fixedrequired
home.maintenance3,600 srequired
filesystem.image3,600 srequired
filesystem.video3,600 srequired
ota.maintenancenot fixednot required
background.schedulerhourlynot required

Every row of that table is a job with a name that says what it does: face detection, scene labelling, optical character recognition, visual search indexing, text understanding, video, and a filesystem sweep for images and videos that are not in a photo library at all. Fifteen of the seventeen declare that they require external power. All seventeen declare that they require the user to be inactive.

The two that do not need a cable both run on a timer measured in hours rather than minutes. The hourly one is the general scheduler, and the maintenance one has a value of 79,200 seconds in its schedule, which is twenty two hours. That is Apple telling you how they expect the process to behave: an ordinary machine does most of its media analysis once a day at most, while it is idle, and ideally plugged in. What this work produces, the photosgraph.kgdb database inside the library, does not just feed the Photos app: the knowledge graph daemon holds read access to exactly that file, so the map of your photos becomes one of the ingredients in Apple Intelligence’s picture of your data.

The property list also says what happens when the conditions are wrong. It sets EnablePressuredExit, and its process type is Adaptive. Both are instructions to launchd to keep the process alive when it is useful and stop it without ceremony when it is not.

Why it appears and then disappears

That is the pattern people notice, and launchd keeps a record of it:

$ launchctl print gui/501/com.apple.mediaanalysisd | grep -E "runs|state|last exit"
	active count = 11
	state = running
	runs = 9
	last exit reason = JETSAM_REASON_MEMORY_IDLE_EXIT

Nine starts since the last login, and a last exit reason that is not a crash. It is a jetsam exit, which is the memory management system reclaiming a process that was holding memory while idle. In plain terms, macOS killed it on purpose because it had finished and was sitting on model weights that something else could use.

This is the single most useful thing to know about mediaanalysisd, because it reframes what you are looking at. The process is not failing and restarting. It is being loaded with a quarter of a gigabyte of models, doing a job, letting go of them, and then being asked to leave. Seeing it vanish from Activity Monitor is the intended end state of every session.

It also explains the memory figures, which look strange until you catch them at two different moments. Half an hour apart, on this Mac:

$ ps -Awwo pid,rss,%mem,comm | grep -i "[M]ediaAnalysis"   # during work
  78454  198016  0.6  .../mediaanalysisd
$ ps -o pid,rss,%mem,time -p 78454                          # after
  78454   11840  0.0   2:21.83

A hundred and ninety three megabytes at one moment, eleven point eight megabytes at another. The difference is the models. Judging this process by a single glance at a memory column is how people end up convinced their Mac is being attacked.

Why it uses CPU, measured

The log is the last piece. Over a six hour window on this machine, the daemon ran 221 tasks of one type, all of them the same, with zero errors recorded:

$ log show --predicate 'process == "mediaanalysisd"' --last 6h | grep -oE "Running task [A-Za-z0-9_]+" | sort | uniq -c
 221 Running task MADServiceTextProcessingTask
$ log show --predicate 'process == "mediaanalysisd"' --last 6h | grep -c "EmbeddingCore"
90

Text processing, not image processing, and every one of those sessions begins the same way:

2026-11-14 13:09:49.894 mediaanalysisd[78454] [Scheduler] Running <private> (157) [QoS: 9 Cost: 0.100]; remaining resource: 0.90
2026-11-14 13:09:49.895 mediaanalysisd[78454] (EmbeddingCore) Setting new context length 512
2026-11-14 13:09:51.322 mediaanalysisd[78454] [Scheduler] Completed <private> (157) [QoS: 9]

One and a half seconds from start to finish, holding a context of 512 tokens, and a resource cost of 0.100 out of 1.00. That last figure is the daemon’s own budget line. It tracks what fraction of its allowance each task uses and schedules the next one accordingly, which is why the CPU spike is a burst rather than a plateau.

What that log also tells you is that a great deal of what people blame on photo analysis is not photo analysis. This Mac had no camera library being scanned in that window. The daemon was busy with text, which is the work behind natural language search: turning words that describe your photos into vectors that can be compared against vectors built from your images.

The caption instructions Apple ships inside the binary

There is one more thing in the executable that is worth reading, and you can see it with a command that ships with macOS:

$ strings -a /System/Library/PrivateFrameworks/MediaAnalysis.framework/Versions/A/mediaanalysisd | grep -A2 "Home Intelligence"
You are a Home Intelligence caption assistant (V11.1Pro/V6). Describe what happened
 not how it looked. Only describe events visible in the clip. Be confident, neutral, and concise.

The daemon carries the full instruction set for the model that writes captions for HomeKit camera clips. It is not a short prompt. It is a document, with a numbered processing order, a restricted activity list, a list of banned words and formatting rules for two different caption lengths.

The restricted activity rule is the one that shows how carefully this was designed. Activities in a list, including sleeping, showering, grooming, undressing, taking medication, crying, arguing, fighting, eating, drinking, exercising, smoking and conversations, must not be described at all, but the scene is still allowed to be captioned by location:

- See two people sleeping on a couch
  "People in living room" / "Two people were in the living room." (NOT suppress; NOT "sleeping")
- See someone on a treadmill in the living room
  "Someone in living room" / "Someone was in the living room." (NOT "exercising"; NOT suppress)

And the list of words the captioner is forbidden to use reads like a privacy policy written by an editor:

**Prohibited Terms (subject naming):** Never reference age, gender, or appearance. Do NOT use any of:
`child`, `children`, `kid`, `kids`, `baby`, `toddler`, `infant`, `adult`, `man`, `woman`, `boy`, `girl`,
`teenager`, `elderly`, `person`, `family`, or any size/build/color descriptor.
**Subject Naming:** Use ONLY: "someone" (single), "two people", "three people", "people" (uncountable groups),
"a group" (4+), or specific animal names ("dog", "cat", "two dogs").

Notice the last instruction: person is on the banned list, and someone is the permitted word. That is not an accident of language. It is the difference between a caption that identifies a human being and one that identifies that somebody was there, and the binary is explicit about it.

Short captions get their own rules, including a maximum of twenty characters and a ban on past tense verbs, which is why a notification from a HomeKit camera reads “Car leaving” rather than “A car left the driveway”. There are even rules for exceptions, listing the cases where the location is the event, such as “Someone at door” and “Dog in kitchen”.

None of this prompt is secret in any meaningful sense. It is a plain text string in a signed system binary on every Mac, and it is readable with a tool that has shipped with macOS for decades. It is simply not written down anywhere that anyone would think to look.

Can you stop it?

Apple does not document this process in its user guide. The term does not appear anywhere in the 185 topics in the macOS user guide index, and it does not appear in any individual page consulted for this article, including the Photos guide’s own search, visual search and document sections. Everything above came from the operating system’s own files rather than from a support article about it.

There is also no setting that turns it off, and the reason is structural rather than a policy choice. It is started on demand through ten mach services, it has seventeen declared background tasks, and it is signed with an entitlement list built specifically for reading photo libraries. There is no on switch to find because there is no service to switch.

What you can change is how much there is to do, and one setting is the one that matters:

Enhanced Visual Search, in Photos, allows searches for landmarks and points of interest by privately matching places in your photos against an index Apple maintains. Apple’s privacy page is unusually specific about how: homomorphic encryption so the server never sees the images, differential privacy, and an OHTTP relay that hides your IP address. It is the one part of this pipeline that involves anything outside your Mac, and it is the one part you can turn off. If you would rather none of the analysis left the machine, that is the switch.

Everything else is local and lightly adjustable. Photos settings has a Show Holiday Events checkbox under General. The People and Pets album lets you control click a person and choose Don’t Feature. The Memories collection lets you choose Feature Fewer Memories Like This. Photos settings also offers Reset Suggested Memories and Reset Suggested People and Pets, which are the two buttons to press if the daemon has learned something about your library that you would rather it had not.

What not to do is what most of the internet suggests. Deleting the daemon’s database, disabling the launch agent with launchctl, or dragging the framework out of the System folder are all either impossible under System Integrity Protection or actively harmful. The database at ~/Library/MediaAnalysis is a queue and a history. Crop it and you do not stop the analysis, you just make it start over.

Where window managers fit

Nothing on this page is a window problem, and it would be dishonest to pretend otherwise. Media analysis is a real job that uses real processor time, and if your Mac is warm while it runs, that warmth is the work rather than a fault. What it is not is a reason for a fast machine to feel slow for the rest of the day.

That other feeling, the one where you cannot find anything, comes from what is on the screen rather than what is behind it. Twenty windows stacked in one place, a Dock you have stopped reading, and Control Up used as an expedition will do more to make a Mac feel slow than any background daemon, and unlike the daemon, you can fix that in about a minute.

Ribbon replaces the stacking with one rule: windows stay at full size on a scrolling strip, and the one you want is a swipe away instead of buried. It is $15 once for up to 3 Macs, with a full refund within 10 days, and it runs on macOS 14 Sonoma and later on Apple silicon and Intel Macs. You can drive the strip in your browser before installing anything.

The short version

mediaanalysisd is the media analysis daemon, the process that reads your photos and videos and writes down what is in them. It lives inside a framework in the System folder, it is eleven megabytes and signed by Apple, it is sandboxed, and unlike most of its neighbours it has no privileged half and no system account of its own.

It keeps its own database in your home folder, at ~/Library/MediaAnalysis, and that database answers the question people actually have. On this Mac the history table held 225 rows covering 25 days, adding up to three hours and one minute of work, with 206 clean finishes and 18 sessions stopped by the system when the conditions changed. The session log next to it showed one run that fetched 744 assets and analysed two of them.

It ships a quarter of a gigabyte of models and 35 named actions, and it maintains a list of identity documents for a set of countries, which is the reason Photos can offer you a collection of passports, visas and driving licences without ever saying how it knows.

The schedule is the honest part. Fifteen of its seventeen jobs require external power, all seventeen require you to be away from the keyboard, and the process is allowed to be killed for being idle. If you see it working, that is the system taking an opportunity, and if you see it gone, that is the system having taken one.

Questions

What is mediaanalysisd on my Mac?

It is macOS's media analysis daemon, the process that reads your photos and videos and writes down what is in them. Its path is /System/Library/PrivateFrameworks/MediaAnalysis.framework/Versions/A/mediaanalysisd, it is signed by Apple, and it runs sandboxed as you rather than as a separate system account. Everything it produces exists to make Photos searchable: face and pet detection, scene labels, optical character recognition, action recognition in video, embeddings for natural language search, and the machine that generates captions for HomeKit camera clips. It is not a virus, and on this Mac it used about two and a half minutes of processor time across six and a half hours of running.

Why is mediaanalysisd using so much CPU?

Because it is running neural networks over images and video, which is real work. Apple schedules it only when the machine is idle and, for most of its tasks, only on external power, so it tends to do that work in bursts while you are away from the keyboard. On this Mac it completed 221 text processing tasks in a six hour window, with no errors, and its memory swung between about 190 MB while a model was loaded and about 12 MB when the work was done. On a healthy Mac you should see it appear, work, and disappear rather than sit at the top of the list permanently.

What does mediaanalysisd actually do with my photos?

It writes metadata, not copies. Apple's own privacy page says Photos uses on-device machine learning to power Sharing Suggestions, Memories, the People and Pets album and Featured Photos, and that this on-device analysis includes scene classification, people and pets identification, photo quality analysis and audio classification. The daemon also builds the Utilities collections Apple describes as being based on the content of the photo, like identity documents, receipts, handwriting and illustrations. The images are not uploaded for any of that. The one feature that does leave the device is Enhanced Visual Search, which matches landmarks privately using homomorphic encryption, differential privacy and a relay that hides your IP address.

Can I disable or stop mediaanalysisd on Mac?

There is no setting that turns the daemon off, because it is not a service with an on switch: launchd starts it on demand through ten mach services and seventeen background task declarations, and it is sandboxed with an entitlement list built specifically for reading your photo library. What you can control is how much material there is to analyse. Turn off Enhanced Visual Search if you would rather nothing at all left the machine. In Photos settings you can deselect Show Holiday Events, and from the People and Pets album and the Memories collection you can choose to feature a person or a memory less often. Photos will still analyse new imports either way.

Is mediaanalysisd a virus or malware?

No. It is present on every Mac running a recent version of macOS, it lives inside a framework in the System folder, the binary is signed by Apple with an identifier of com.apple.mediaanalysisd, and it is a universal binary carrying three architectures. What makes it look suspicious is the size, because it is one of the few Mac processes that will happily sit at over a hundred megabytes of memory while it works. A real impersonation would require replacing an Apple signed executable in a system framework and forging a Code Directory hash, which is a far harder thing to do than to pick a name nobody would search for.

Ready? Buy Ribbon for $15, or read all the guides.