HeartbeatHocusFocusFilesMacHyperTile
Guide

syspolicyd: the daemon behind Gatekeeper and the Verifying dialog

The process behind Gatekeeper and the Verifying dialog, the policy database it keeps, and how to check its verdict on any app yourself.

By Chethan Kumar S N · Updated

Two searches lead here. One is a name in Activity Monitor, sitting just under the CPU column, belonging to a process you never installed. The other is a small window that appears when you double click something you downloaded, sometimes for a second and sometimes for longer, telling you that macOS is verifying the app before it opens.

They are the same process, and it is the same job, which is to decide whether the software on your Mac is allowed to run at all.

Everything below comes from reading the process, its property list, its man page, its own log and the database it keeps on a 14 inch MacBook Pro with an M1 Pro running macOS 27.0.1, plus Apple’s published documentation. Nothing was installed, nothing was killed, no setting was changed, and the database files that belong to root were left unread rather than opened with a workaround.

What the process is, in one command

$ ps -Awwo pid,ppid,user,%cpu,rss,time,etime,comm | grep "[s]yspolicyd"
  577     1 root               0.0  12176 135:04.63 25-08:12:44 /usr/libexec/syspolicyd

That is the whole identity in one line. Parent process 1, which is launchd, so this was started at boot and is not owned by any user session. User root, because it can only do its job if no ordinary app can reach into it. A path in /usr/libexec rather than /Applications, which is where Apple’s own helper daemons live. About 12 MB resident, 6 threads, and 135 minutes of processor time across 25 days of uptime.

The binary itself is 3,994,960 bytes dated 24 September 2026, and it is a universal one, carrying three slices for x86_64, arm64e and arm64e.x1. It is signed by Apple under the identifier com.apple.syspolicyd with Platform identifier 26, and it holds 42 private entitlements, among them keystore access, CloudKit system launch daemon access and a handful of authentication exceptions that no app you download can obtain.

Apple ships a man page for it, and the first paragraph is the entire job in two sentences. It says syspolicyd embodies the system policy controlling what may be installed, loaded, executed or otherwise used on the system, that it manages the policy database file, and that it serves as a general oracle that other system components may use to determine the system policy’s verdict on a proposed operation.

Read the last part again, because it explains almost everything people ask. This process is not a scanner that wanders your disk. It is a service that other parts of macOS call up and ask a single question: is this allowed. The same question is asked all day elsewhere in the system by sandboxd, the clerk that logs every file a sandboxed app is denied, and between them they are the reason a Mac can say no to code before it runs and while it runs. The FILES section of the same man page names one path, /var/db/SystemPolicyConfiguration/SystemPolicy, which it calls the master system policy database. We will come back to that folder, because there is a good deal more in it than the man page admits.

The job it was launched with, and its name is not the one you searched

Here is the first trap. There is no /System/Library/LaunchDaemons/com.apple.syspolicyd.plist, and searching the LaunchDaemons folder for the word you typed into Google returns nothing. The launch job is called something else.

$ ls /System/Library/LaunchDaemons/ | grep -i syspol
com.apple.security.syspolicy.plist

The label inside is com.apple.security.syspolicy, so the command you would naturally reach for fails with the spelling you had every reason to trust, and the command that works uses a name you would never guess.

$ launchctl print system/com.apple.syspolicyd
Bad request.
Could not find service "com.apple.syspolicyd" in domain for system

$ launchctl print system/com.apple.security.syspolicy
system/com.apple.security.syspolicy = {
        state = running
        program = /usr/libexec/syspolicyd
        runs = 1
        pid = 577
        immediate reason = ipc (mach)
        last exit code = (never exited)

runs = 1 and last exit code = (never exited) mean what they look like: this instance started at boot and has never been restarted. The immediate reason for it being awake is ipc (mach), which is the IPC channel other processes call, not a timer.

The property list declares four Mach services, which are the doors other software knocks on. Three of them are named after the job itself, com.apple.security.syspolicy plus .exec and .kext variants. The fourth is com.apple.security.AppleSystemPolicy.mig, registered as HostSpecialPort 29, which is the system port that the modern Gatekeeper assessment call arrives on.

It also sets EnablePressuredExit to false. That is the quiet sentence that answers the question of whether you can get rid of it: under memory pressure, macOS is allowed to reclaim certain daemons and start them again later, and this one is explicitly excluded from that.

The thirteen jobs hiding inside its property list

A daemon that only answered questions would be idle most of the day and would not appear in energy reports. This one also maintains itself, and its property list lists every maintenance job it runs, each with its own schedule and its own conditions.

TaskScheduleNotes from the property list
check.revocationevery 259200 s (3 days)needs network, needs screen asleep, Power Nap
db-cleanupevery 604800 s (7 days)needs screen asleep
find.bundlesevery 604800 s (7 days)not allowed on battery
gatekeeper.policy-metricsevery 518400 s (6 days)maintenance priority
invalidatedelay 86400 s, grace 259200 sflagged CPUIntensive
kext.deprecationdelay 1209600 s (14 days), grace 604800 skernel extension deprecation
kext.mtdelay 518400 s (6 days), grace 43200 skernel extension migration
legacypolicyevery 42300 s (11.75 hours)needs network
measureevery 259200 s (3 days)flagged CPUIntensive, not allowed on battery
rearmdelay 86400 s, grace 3600 sre-arms the checks
reportdelay 86400 s, grace 43200 snot allowed on battery
sample-uploadevery 86400 s (1 day)needs network and screen asleep
xprotect-updateevery 86400 s (1 day)needs network, grace 28800 s

Thirteen named jobs, all at maintenance priority, which in macOS terms means they yield to anything you are actually doing. Several carry conditions worth reading literally. RequireScreenSleep means the daemon waits until the display is off, which is why a spike can appear during a lunch break. AllowBattery false on three of them means they wait for mains power. RequireNetworkConnectivity on five means they will not run offline at all, and if you have ever wondered why a Mac that lives on a plane behaves differently from one on a desk, this table is part of the answer.

The two marked CPU intensive are the ones to know about if you are hunting a spike. measure and invalidate are Apple’s own labels, not an inference, and they run a few times a week rather than continuously.

The database it keeps, and why it needs root

The man page names one file. The folder holds twenty four items, and the three databases in it are the daemon’s memory of everything it has ever checked.

$ ls -l /var/db/SystemPolicyConfiguration/
ExecPolicy              1478656   (with a 3316632-byte write-ahead log)
Tickets                  659456   (with a write-ahead log)
SystemPolicy             602112
KextPolicy                4096
SystemPolicy-prefs.plist    230
Default.plist               652
TamperExceptions.plist    12531
migration.plist             467
gatekeeper-migration.plist  335620
XProtect.app
.LastGKReject               181

Three things in that listing are worth pausing on.

First, the write-ahead logs. ExecPolicy is a SQLite database and its -wal companion was last written today, which tells you the daemon is actively recording scans rather than sitting still. A database this busy is the mechanism behind the one-time cost of the Verifying dialog: the second launch is fast because the answer is already written down.

Second, SystemPolicy-prefs.plist contains a single key, enabled, set to yes. That is the same switch that spctl --status reports to you, stored where you cannot casually edit it. Third, .LastGKReject is the file that records the last Gatekeeper refusal. On this Mac it is an empty dictionary, which is the honest version of a clean bill of health.

There is also gatekeeper-migration.plist, a 335 KB record of 754 items that macOS wants to re-evaluate, each with a volume UUID and an object ID rather than a name, and TamperExceptions.plist, which lists the system’s own helper apps by bundle identifier with a flag beside each. And Default.plist carries Apple’s small Allowlist of third-party kernel extensions from specific teams, among them HP, Epson and Canon print drivers, which is a tidy illustration of how narrow the built-in exceptions are.

The one thing to be clear about is access. These files are owned by root, and sqlite3 will not open them as your normal user. That is not a puzzle to solve with a workaround, it is the design, and it is why a page like this one can describe the shape of the database from the schema Apple ships inside the binary rather than by querying it.

What it is doing, from its own log

The daemon writes a plain log, and in one 24 hour window it produced 1,879 lines under a single subsystem, com.apple.syspolicy.exec. Grouped by message, they read like this.

Message in the logLines in 24 hours
Unable to initialize qtn_proc: 3830
dispatch_mig_server returned 268435459413
Putting executable into provenance with metadata154
GK evaluateScanResult192
Found provenance data on target111
GK performScan44
Code did not match any currently allowed policy30
BE adhoc signing8

A real line, with the file path replaced by a hash before it ever reaches the log viewer, looks like this.

$ log show --predicate 'subsystem == "com.apple.syspolicy.exec"' --last 1h --style compact
2026-11-14 20:42:23.836 Df syspolicyd[577:2b73b89] [com.apple.syspolicy.exec:default]
  GK evaluateScanResult: 3, PST: (path: ed19191a4485909), (team: 7S8W4W365S),
  (id: ai.perplexity.CometUpdater), (bundle_id: (null)), 0, 0, 1, 0, 4, 4, 0
2026-11-14 20:42:23.836 Df syspolicyd[577:2b73b89] [com.apple.syspolicy.exec:default]
  Found provenance data on target: TA(9f3e81d0b70b8517, 2), PST: (path: ed19191a4485909),
  (team: 7S8W4W365S), (id: ai.perplexity.CometUpdater), (bundle_id: (null))
2026-11-14 20:42:23.838 Df syspolicyd[577:2b73b89] [com.apple.syspolicy.exec:default]
  Putting executable into provenance with metadata: TA(9f3e81d0b70b8517, 2)

Three sentences, and they are the whole lifecycle of one check. The app was scanned and got a verdict. The daemon found existing provenance data for it, which is macOS’s record of where a file came from. And then it wrote a fresh provenance entry.

Two details are worth naming. The PST path token is a hash, not the path, so the log is precise about counting and useless about naming, which is deliberate. And when the app has a real developer identity, the log names it: in the lines above you can read ai.perplexity.CometUpdater and team 7S8W4W365S in plain text. Elsewhere the log gives names to Anthropic’s Claude apps and to com.openai.codex, and shows plain Unix executables with every field null.

The two loudest lines in the table are also the emptiest. Unable to initialize qtn_proc: 3 and dispatch_mig_server returned 268435459 appear around every check, in their hundreds, and they are routine bookkeeping for an optional scheduling feature, not errors about your Mac. The line worth knowing is the quiet one, Code did not match any currently allowed policy. That string, from a GatekeeperPolicyScanError, is what an actual refusal looks like in the log, and there were 30 of them in a day on a machine where every visible alert was dismissed normally.

The half of it that is a network client

The same log holds the other half of the daemon. Over 12 hours, its network activity dominated the line count: 2,135 lines under com.apple.network:connection, 929 under com.apple.network:quic, 782 under com.apple.network:boringssl, and 645 under com.apple.CFNetwork.

That is a security process talking to Apple, and the property list tells you what it is talking about. check.revocation runs every three days over the network, which is how macOS learns that a certificate has been pulled. xprotect-update fetches new detection data daily. sample-upload is the one that deserves a sentence of its own, and it has one further down. And there is a division of labour worth knowing: syspolicyd decides whether software is allowed to run, while the separate question of whether a certificate chain is any good is answered by trustd, the certificate trust daemon, a sibling with its own page.

The tables inside the binary name the design

You do not need to open the database to learn how it is built, because the schema ships inside the executable as plain text. Four tables and their columns, read out of the binary, describe the whole system.

That is the design in four lines. A cache so the answer is remembered, a provenance record so a file that arrives with an app can be traced, and a small history of malware that was actually blocked. It is also the answer to a question people ask about downloads: the reason macOS remembers that a file came from the internet is not a setting you turned on, it is this table.

The Verifying dialog, and how to skip it

Apple is unusually direct about this in the man page of a small tool it ships alongside the daemon. gktool exists, in its own words, because a scan is useful for pre-warming the cache so users do not see the Verifying dialog on first launch of an application.

That one sentence answers both halves of the question. The dialog is this daemon doing a first scan, and it is a cost you pay once per app rather than every time, because the result goes into the cache above. If you want it paid before the person opening the app is watching, a single command does it.

$ gktool scan /Applications/SomeApp.app

What the dialog is emphatically not is a warning. A warning is a different window with a button on it, and if you see that one, the verdict was no.

Checking an app yourself

Three commands cover most of what this daemon does, and all three are safe to run.

The first tells you whether the system is enforcing policy at all.

$ spctl --status
assessments enabled

The second asks for a verdict on one app, and prints the reason. On Apple’s own apps it reports a system origin; on a third party app signed and notarised properly it names the developer and team.

$ spctl -a -vv /Applications/Safari.app
/Applications/Safari.app: accepted
source=Apple System
origin=macOS Software Signing

$ spctl -a -vv /Applications/Claude.app
/Applications/Claude.app: accepted
source=Notarized Developer ID
origin=Developer ID Application: Anthropic PBC (Q6L2SF6YDW)

The third runs the same checks macOS runs, and is the one to reach for when an app will not open and you want to know why. The output is honest enough to be useful, and it is not always flattering: asked about Safari on this Mac, it fails, with a fatal error about a missing notarization ticket, because Apple’s own preinstalled apps are handled differently from developer software. Asked about a properly notarised third party app, it passes in as many words.

$ syspolicy_check distribution /Applications/Claude.app
App passed all pre-distribution checks and is ready for distribution.

$ syspolicy_check distribution /Applications/Safari.app
App has failed one or more pre-distribution checks.
Notary Ticket Missing
    Severity: Fatal
    Full Error: A Notarization ticket is not stapled to this application.

Why it uses CPU

Put the numbers side by side and the shape is clear. The process had used 135 minutes of processor time in 25 days, which works out at a little over five seconds per hour, and it read 0.0 percent in top at the moment it was measured. That is not a process that is busy.

Then look at its log spread across the hours of a day, and the bursts appear: 106 lines in one hour, 188 in the next, 266 in the next, and 480 in a single afternoon hour, against single and double digit counts overnight. The single busiest hour on this Mac was the one where several apps were opened, a browser updated itself and a build ran.

So the practical answer to why it is using CPU is a question back: what were you doing at the time. If the answer is opening or installing an app, you are watching the verification, and it is proportional to the app. If the answer is nothing, and the screen was asleep, you are watching one of the thirteen maintenance jobs, most likely measure or invalidate, both of which Apple flags as CPU intensive in its own property list. Neither is a fault, and neither needs interrupting.

What Apple’s own documentation says

Apple documents the system this daemon implements far more thoroughly than the daemon itself. Its Platform Security guide describes three layers of defence, and the words are worth having exactly: the first layer is to prevent launch or execution of malware, using the App Store, or Gatekeeper combined with Notarization. The second is to block malware from running on customer systems, using Gatekeeper, Notarization and XProtect. The third is to remediate malware that has already executed, using XProtect.

The line that follows explains why this daemon sees every app, not just downloaded ones. Apple writes that by default, all software in macOS is checked for known malicious content the first time it is opened, regardless of how it arrived on the Mac.

The consumer side is covered by two pages. The first, on opening an app from an unknown developer, states plainly that overriding security settings to open an app is the most common way a Mac gets infected with malware, and that you should not override them for software Apple has not checked even when it looks like it came from a major developer. The override route it describes runs through System Settings, Privacy and Security, an Open Anyway button that stays available for about an hour after you first try to open the app, and your login password.

The second, on safely opening apps, adds the notarization requirement in one sentence: by default, macOS Catalina and later also requires software to be notarized, so you can be confident that the software you run on your Mac does not contain known malware.

Is it malware, and can you turn it off

No, and yes, and the second answer is the more interesting one.

Turning it off is a real thing you can do, and Apple’s own tool is the way in. The spctl man page says that globally disabling the assessment subsystem requires root access, and that doing so reveals an option in the Privacy and Security settings pane to allow applications downloaded from anywhere. On this Mac that option is not currently exposed, which is what this reports.

$ spctl --disable-status
The option to globally disable the assessment system is currently not available in System Settings.

That is the honest measure of how much freedom you have here. The switch exists, it is off by default, it takes root to flip, and flipping it means nothing you download gets its first check. Almost nobody should do it, and if you have been told to do it to fix a stubborn app, the System Settings route above is the smaller hammer with the same result for one app instead of all of them.

As for the process itself, there is nothing to remove. It is root owned, it lives on a signed and read-only system volume, SIP protects the path it runs from, and its job is explicitly excluded from launchd’s memory pressure reclaim. Force quitting it gets you a gap of a few seconds and the same process back.

The one privacy detail worth knowing

One of its thirteen jobs is called sample-upload, runs once a day, and waits for the network and for the screen to be asleep. It is worth knowing what that uploads, and Apple states it in the Platform Security guide: users might be asked to share malware samples with Apple to improve macOS security, and if they agree, XProtect uploads only the malware executable or, if it is inside an app bundle, that entire bundle. Nothing else is shared.

So the upload is opt in, it is scoped to malware, and it exists to improve signatures rather than to report on your activity. It is the one part of this daemon where your answer changes its behaviour.

What to do about it

Nothing. That is not a brush off, it is the finding. The process is idle to within measurement error, its bursts line up with things you did, its maintenance jobs deliberately wait for the screen to be off or for mains power, and the only lever you have over it is one you should leave alone.

The two cases where it is worth a minute of your time are both about a specific app. If an app will not open, run syspolicy_check distribution on it and read the reason rather than searching for a way to disable the check, because the reason is usually concrete, a missing notarization ticket or a broken signature, and it tells you whether to go back to the developer or to the download. And if the first launch of an app you use every day is slow because of the Verifying dialog, run gktool scan on it once and you will not see it again.

Everything else you will find on the web about this process falls into two groups. Forum threads where the answer is a shrug, and cleanup tools that promise to fix it. Neither the shrug nor the tool is needed, and the tool is worse than the shrug, because the thing it wants to turn off is the thing that stops a downloaded file from running.

What this page cannot tell you

The database itself could not be read, only described. /var/db/SystemPolicyConfiguration is owned by root and there is no passwordless path in, which is the correct state of affairs and the reason the table above comes from the schema Apple ships inside the binary and from file sizes and timestamps rather than from queries. A page that told you what is in those rows would have had to do something it should not.

The log has a matching limit from the other direction. Paths arrive as hashed tokens and URLs are replaced with a private marker, so the log is excellent at counting and useless at identifying, and the version of it quoted here is the version macOS is willing to show an ordinary user rather than the raw record.

And the documentation line is thin by design. Apple documents Gatekeeper at length and this daemon almost not at all, so the man page and the property list carry more weight here than they would on most pages. All of it is read from one Mac, one build and one 24 hour window, which is 27.0.1 on an M1 Pro, and a page about a moving target is only as good as the build it was written on.

Where window managers fit

Nothing here changes how your windows behave, and no amount of policy hygiene makes a desktop easier to work on. The two meet at the same feeling, though, which is a Mac that seems to be doing a great deal you did not ask for: checking an app, indexing a disk, syncing photos, resolving names. That is the invisible half of using a Mac, and windows are the visible half, which usually means a screen full of them and Control Up pressed like an expedition.

Ribbon takes the other approach. Windows stay at full size on a single scrolling strip instead of stacking on top of each other, so the window you want is one swipe away and nothing ends up buried behind anything else. 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

syspolicyd is the daemon that decides whether software on your Mac is allowed to run. Apple’s own man page calls it the system policy oracle, and that is the right word, because it does not scan your disk on a schedule, it answers questions other parts of macOS ask it. On this Mac it is PID 577, it runs as root from /usr/libexec, it used about 2 hours 15 minutes of processor time in 25 days, and it was using nothing measurable at the moment of reading.

Its launch job is named com.apple.security.syspolicy, not after the process, which is the first reason people fail to find it. The property list behind that job lists thirteen maintenance tasks with their own schedules and conditions, two of them flagged CPU intensive, most of them waiting for the screen to be off or for the machine to be on mains power.

Everything it knows is in /var/db/SystemPolicyConfiguration, where three databases, two active write-ahead logs and a record of the last refusal live behind root-only permissions. Its own log names what it does in plain English, from a scan to a provenance record, and the two lines that look alarming in it are the two that matter least. The dialog you see on a first launch is a one-time scan that gets remembered, and gktool exists to pay that cost early. The Verifying dialog is the price of the check that stops a bad download from running, and once per app is a fair price.

Questions

What is syspolicyd on Mac?

It is the daemon that decides whether the things on your Mac are allowed to run. Apple's own man page describes it in two sentences: it embodies the system policy controlling what may be installed, loaded, executed or otherwise used on the system, it manages the policy database file, and it serves as a general oracle that other parts of macOS ask for a verdict. On this Mac it is a single process, PID 577, running as root from /usr/libexec/syspolicyd, and it had used about 2 hours 15 minutes of processor time in 25 days of uptime. It is the machinery behind Gatekeeper, the alert you get when an app cannot be verified, and the small dialog that says macOS is verifying an app the first time you open it.

Is syspolicyd a virus or malware?

No. It is Apple's own code, it lives in /usr/libexec, and it is signed with the identifier com.apple.syspolicyd under Apple's platform signature. It runs as root because it has to: it is the process that decides whether other software is allowed to run, so it cannot itself be something a normal app can modify, and it carries 42 private entitlements that only Apple's own system daemons have. The reason it looks suspicious is the same reason mds_stores and kernel_task do, which is that it appears in Activity Monitor with a name unlike anything you installed and users look it up before reading the process path.

Why is syspolicyd using CPU?

Because something is being checked. The work is bursty rather than steady: on this Mac it averaged a little over 5 seconds of processor time per hour across 25 days, and 0.0 percent at the moment of reading, but the log shows bursts in the hundreds of lines per hour when apps are opening and downloading. Two of its thirteen scheduled jobs are flagged CPU intensive in its own property list, the one labelled measure and the one labelled invalidate, so a few times a week it will do a chunk of heavier work while the screen is asleep. The honest test is timing: if the spike lines up with you opening an app, that is the verification, and if it lines up with an idle Mac and an empty Battery or energy report, that is the maintenance job.

Can I delete or disable syspolicyd?

You can turn off the policy system it runs, and you would regret it. The whole subsystem is controlled by the spctl command, whose man page is blunt that globally disabling it requires root access and reveals a setting to allow applications downloaded from anywhere. On this Mac that option is currently hidden, which is what spctl --disable-status reports. You cannot meaningfully delete the process either: it runs as root from a read-only system volume, and its launch job has EnablePressuredExit set to false, so launchd is not allowed to quietly reclaim it. Force quitting it works the same way force quitting any launchd job does, which is that it comes straight back, and in between nothing you download can be assessed.

Why does my Mac say Verifying when I open an app, and can I stop it?

That dialog is this daemon scanning the app for the first time, and Apple documents the fix in the man page of a tool it ships, gktool, whose own words are that a scan is useful for pre-warming the cache so users do not see the Verifying dialog on first launch of an application. So the delay is a one-time cost that is remembered, not a hang. If you want it gone before you hand a Mac to someone, a single gktool scan of the app path does the same work up front. What you should not do is use the presence of the dialog as a reason to click past a security alert.

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