sandboxd, the clerk of the rules the kernel enforces
The daemon behind App Sandbox on a Mac: what its kernel extension blocks, what its own logs say, the three events that wake it, and why you leave it alone.
By Chethan Kumar S N · Updated
Some process names worry people because they are opaque, and some worry people because of what they seem to promise. sandboxd manages both. It sits in Activity Monitor as root, it never seems to do anything, and its name suggests a process that decides what other processes are allowed to do, which is exactly what it is. On the Mac measured for this page, a 10-core MacBook Pro running macOS 27.0.1 with 26 days of uptime, it has been running since boot as process 478, and in all that time it has consumed 50 seconds and 56 hundredths of processor time. Under two seconds a day. The enforcement system of the entire Mac App Store runs through this daemon, and its total footprint is about 4 MB of memory.
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 binary, and its own logs, captured while nothing user-facing was happening. Everything was measured read only on one Mac, nothing was quit or killed or changed, and every command used is at the end if you want to repeat any of it. One experiment below triggers a real sandbox violation, using Apple’s own deprecated tool to do it, and the only file involved was /etc/hosts, which was not harmed for even a moment.
The 561-byte manual, from 2008
The manual page for sandboxd is 561 bytes and dated July 29, 2008:
NAME
sandboxd - sandbox daemon
DESCRIPTION
sandboxd performs services on behalf of the Sandbox kernel extension.
SEE ALSO
sandbox-exec(1), sandbox_init(3), sandbox(7)
One sentence of description, and it has been true for over 18 years. What the sentence does not say, but the options below it do, is what kind of services. The manual lists two flags: one tells the daemon to log “basic sandbox violation information without a backtrace”, the other tells it not to symbolicate backtraces at all. That is the job description hiding in the fine print. sandboxd receives violation reports from the kernel and turns them into readable log entries, symbolicated, with the call stack of the process that broke its own rules. It is a clerk. The gavel is somewhere else.
The “not intended to be invoked directly” warning that closes the page applies to the daemon, but the see-also list is a map of the whole family, and every relative on it still exists on a current Mac: sandbox-exec(1), marked DEPRECATED in capital letters, sandbox_init(3), the old C interface, and sandbox(7), the overview page, which deserves its own quote later.
The kernel blocks. Here are the receipts.
The 2008 manual says the daemon serves a kernel extension, and on this Mac that extension is alive and loaded, verified with kmutil: com.apple.security.sandbox, version 300.0, loaded in the kernel alongside 23 other Apple extensions. This is the part most explanations skip. The blocking is not done by a process you can watch in Activity Monitor. It is done inside the kernel, on every file operation, every network connection and every information request a sandboxed process makes, and what surfaces in user space is the paperwork.
Apple’s own developer documentation describes the arrangement in one line, fetched live while writing this page: the App Sandbox “is an access control technology that macOS provides and enforces at the kernel level”, its primary function being to contain damage to the system and the user’s data if the user executes a compromised app. The same page is honest about the limits, which is worth repeating because it is the honest answer to people who expect a sandbox to be antivirus: “While the sandbox doesn’t prevent attacks against your app, it does reduce the harm a successful attack can cause.”
While the log was open for this page, the kernel’s Sandbox channel was quietly producing verdicts, and the excerpts below are verbatim:
(Sandbox) Sandbox: tccd(1051) deny(1) system-info vfs.disk-space
(Sandbox) Sandbox: ContextStoreAgent(17915) allow file-read-data
/Applications/Slack.app/Contents/Info.plist
(Sandbox) Sandbox: BiomeAgent(1033) deny(1) system-info vfs.disk-space
(Sandbox) 4 duplicate reports for Sandbox: BiomeAgent(1033) deny(1)
system-info vfs.disk-space
(Sandbox) Sandbox: IntelligencePlatformComputeServi(81291) deny(1)
system-info vfs.disk-space
Read the first line twice. tccd is the privacy permissions daemon, the process behind every “allow access to your camera” question on a Mac. It is itself sandboxed, and it was itself denied an information request, by the same system it administers. Nobody is exempt, including the exemptors. The second line shows the other half of the ledger: allow decisions are logged too, so the kernel’s record is not just a list of busts but a complete audit of what sandboxed processes touched. ContextStoreAgent, part of Spotlight’s context system, reading Slack’s Info.plist, and being permitted.
Two small honest details in those lines. IntelligencePlatformComputeServi is truncated, not a typo in this page; the kernel cuts long process names at the source. And the “4 duplicate reports” line is the system saving itself from repetition: violations that repeat rapidly are coalesced into a single counted line, which is also why the daemon’s own launch configuration caps its log rate, as you will see below.
A violation on demand
Everything so far was overheard. This part was ordered. Apple ships a tool, deprecated but present, that runs any command inside a sandbox profile of your choosing, and using it makes the whole system visible in one move:
$ sandbox-exec -p '(version 1)(allow default)
(deny file-read-data (subpath "/private/etc/hosts"))' /bin/cat /etc/hosts
cat: /etc/hosts: Operation not permitted
That is a real sandbox violation, triggered on purpose. cat was allowed everything by default, denied one file, and denied it was. No prompt appeared, no dialog, no crash. The kernel simply returned “Operation not permitted” to a request for /etc/hosts, and cat reported it the way it reports any unreadable file. That silence is the design: a sandboxed app that wanders past its rules does not get warned, it gets a failed syscall, exactly as if the file did not exist or the permissions said no.
The tool that did this carries a warning of its own, in its manual, in capital letters: DEPRECATED. “Developers who wish to sandbox an app should instead adopt the App Sandbox feature.” sandbox-exec is the research tool from an earlier era of the system. The modern form is the App Sandbox capability in Xcode, where an app declares its entitlements up front, and Apple’s documentation is plain about who must use it: the sandbox entitlement is “an App Store requirement for any app that you submit to the Mac App Store for review”. Every app on the Mac App Store is running inside one of these profiles. That is what the little daemon at process 478 is clerk for.
The overview manual, sandbox(7), 2,495 bytes and dated January 29, 2010, states the philosophy in two sentences that have not aged a day: the sandbox facility “allows applications to voluntarily restrict their access to operating system resources”, and it “is not a replacement for other operating system access controls”. Voluntary, and additional. A sandbox is a wall the app agrees to live inside, on top of the normal Unix permissions, not instead of them.
The other job nobody mentions: brokering permissions
For one quiet hour, with nothing user-facing happening, sandboxd wrote 166 log lines, and nearly all of them were one activity:
sandboxd[478] request approval
sandboxd[478] (TCC) tcc_send_request_authorization() IPC
sandboxd[478] [com.apple.xpc:connection] activating connection:
mach=true listener=false peer=false name=com.apple.tccd
This is the daemon’s second job, and it is the opposite of the first. Instead of reporting a denial, sandboxd is trying to upgrade one. When a sandboxed app has a legitimate claim to something outside its profile, an entitlement, a user intent, the request passes through sandboxd to tccd, the privacy permissions system, and comes back as a grant or a refusal. The vocabulary for this is in the daemon’s own binary: strings on /usr/libexec/sandboxd finds “extension-class-list”, “matched-extension”, and “matched-user-intent-extension”. A user intent extension is what the system mints when you pick a folder in an app’s open dialog: you, the user, told the app it may have this one folder, and that grant is recorded as an extension to the app’s sandbox, brokered through this path.
The binary holds a stranger detail, countable by anyone. Among its 6,318 strings there are 341 entries in the form of a developer team id followed by a bundle id: JQ525L2MZD/Adobe.NGLApp, 4JP9M2NB5F/com.niceax.vpn.mac.TunnelExtension, 5U8NS4GX82/com.dayoneapp.dayone.Day-One-Classic-Share-Extension, and hundreds more. The enforcement daemon ships with a compiled-in directory of known apps by developer, the reference list its extension brokering works from. Where cfprefsd is six strings and nothing else, and locationd is 41,296 strings of satellite vocabulary, sandboxd is a short book of rules and a long guest list.
What wakes it: three events, no clock
Every daemon in this series so far has been woken by something. Usually a Mach message, occasionally a timer, in locationd’s case a semaphore and a twice yearly check. sandboxd’s launch configuration, 2,091 bytes at /System/Library/LaunchDaemons/com.apple.sandboxd.plist, has no timer of any kind. No StartInterval, no calendar, no KeepAlive clause. What it has instead is a subscription list, three events that tell launchd to poke it:
| Wake trigger | Fires when |
|---|---|
| com.apple.tcc.access.changed | any privacy permission changes |
| com.apple.xprotect.bundle.update | XProtect malware signatures update |
| OpenDirectory user records | a user account is added, deleted, or its home or uid changes |
This is the most legible wake configuration measured in this series, because each line maps to a moment you can remember living through. Flip a privacy toggle in System Settings, and sandboxd is told, because permission state feeds directly into what the sandbox will grant. The XProtect signature database updates itself silently in the background, and sandboxd is told again, because the malware lists inform what gets trusted. Create or delete a user account, and the daemon is notified through OpenDirectory, with the trigger watching exactly two attributes by name: NFSHomeDirectory and UniqueID, the home folder and the user id. Nothing else about a user interests it.
Two more entries complete the picture. The job vends its Mach service on a numbered host special port, port 14, a slot launchd reserves for services the rest of the system reaches by fixed number rather than by name lookup, the same addressing family the kernel itself uses. And the daemon’s environment carries OSLogRateLimit set to 64, the reason the violation reports above arrive coalesced: past 64 similar messages in a window, the kernel folds them into “duplicate reports” lines instead of flooding the log.
At runtime, launchctl reports state running, runs = 1, last exit code = never exited, minimum runtime 10 seconds, exit timeout 5, and an immediate start reason of “speculative”, launchd’s term for a job started at boot because it will certainly be needed rather than in response to a request. It has never once had a reason to leave.
553 rulebooks
The rules themselves are on disk, readable by anyone, at /System/Library/Sandbox/Profiles. On this Mac there are 553 of them, one profile per sandboxed system service, each a few hundred bytes to a few kilobytes of a Lisp like language that reads like policy written by a very cautious programmer:
(allow file-read-data (literal "/Library/Preferences/")))
(deny file-write-data (subpath "/System"))
The filenames are a tour of the system’s own services, and a few deserve quoting for no reason other than that they exist: airlock.sb, FindMySecureEnvironmentXPCService.sb, WeatherKitAuthService.sb, CryptegraftService.sb, NANDTaskScheduler.sb. Every service with a profile is pre assigned its walls. When you install a Mac App Store app, its walls come from the entitlements its developer declared, the same system at a different scale.
And there is a way to see this from the other side that Apple documents itself, in the very page quoted above: open Activity Monitor, choose View, then Columns, then Sandbox, and a new column appears naming which running processes are sandboxed. On the Mac measured here the column fills with Yes for App Store apps, browsers and most of Apple’s own services. It is the one settings screen that makes the invisible architecture visible, and it comes from Apple’s own instructions, not from a forum.
Is any of this a problem? No, and the numbers say so
The reason people look up sandboxd is that it appears as root, or it briefly shows CPU in Activity Monitor during an app launch, or its name surfaces in a crash log. The measurements here answer the first and third directly: 50 seconds of processor time in 26 days, about 4 MB of memory, one run since boot, no exits. During the measured hour it logged 166 lines, all permission brokering, no violations of its own. A daemon this quiet is not a symptom. It is a system doing its job so efficiently you only ever see it in the cast list.
If it ever does run hot, the diagnosis is not inside sandboxd, it is inside whatever is talking to it, and the kernel’s Sandbox channel names the talker in every line. The commands follow, and they include the one that produces the receipts.
The launch configuration, verbatim
$ plutil -p /System/Library/LaunchDaemons/com.apple.sandboxd.plist
{
"EnablePressuredExit" => true
"EnableTransactions" => true
"Label" => "com.apple.sandboxd"
"LaunchEvents" => {
"com.apple.notifyd.matching" => {
"com.apple.tcc.access.changed" => {
"Notification" => "com.apple.tcc.access.changed"
}
"com.apple.xprotect.bundle.update" => {
"Notification" => "com.apple.xprotect.bundle.update"
}
}
"com.apple.OpenDirectory.ODTrigger" => {
"Record Creation" => {
"Events" => "Add"
"Nodes" => "/Local/Default"
"RecordTypes" => "dsRecTypeStandard:Users"
"TriggerType" => "Records"
}
"Record Deletion" => {
"Events" => "Delete"
"Nodes" => "/Local/Default"
"RecordTypes" => "dsRecTypeStandard:Users"
"TriggerType" => "Records"
}
"Record Modification" => {
"Nodes" => "/Local/Default"
"RecordAttributes" => [
0 => "dsAttrTypeStandard:NFSHomeDirectory"
1 => "dsAttrTypeStandard:UniqueID"
]
"RecordTypes" => "dsRecTypeStandard:Users"
"TriggerType" => "RecordAttributes"
}
}
}
"MachServices" => {
"com.apple.sandboxd" => {
"HostSpecialPort" => 14
}
}
"POSIXSpawnType" => "Interactive"
"ProgramArguments" => [ 0 => "/usr/libexec/sandboxd" ]
"RunAtLoad" => true
}
What launchctl knows about the running job
$ launchctl print system/com.apple.sandboxd
state = running
active count = 4
minimum runtime = 10
exit timeout = 5
runs = 1
pid = 478
immediate reason = speculative
last exit code = (never exited)
environment = {
OSLogRateLimit => 64
MallocSpaceEfficient => 1
}
The binary, verified
$ ls -l /usr/libexec/sandboxd
-rwxr-xr-x 1 root wheel 1346288 Sep 24 12:40 /usr/libexec/sandboxd
$ lipo -archs /usr/libexec/sandboxd
arm64e arm64e.x1
$ codesign -dv /usr/libexec/sandboxd
Identifier=com.apple.sandboxd
Format=Mach-O universal (arm64e arm64e.x1)
Platform identifier=26
$ strings /usr/libexec/sandboxd | wc -l
6318
The first daemon in this series with no Intel slice: it ships only in arm64e and arm64e.x1, the pointer authenticated flavors, on this Apple silicon Mac. Its code directory reports platform identifier 26, the Apple platform class, and a signing date of August 12, 2026.
Reading the kernel's verdicts yourself
$ log show --last 5m --predicate 'eventMessage CONTAINS "Sandbox:"' \
--style compact
$ log show --last 1h --predicate 'process == "sandboxd"' --style compact \
| wc -l
166
The first command shows the kernel extension’s allow and deny lines, process by process. The second counts the daemon’s own paperwork. Note that reports repeat rapidly enough are coalesced into “duplicate reports” lines, so counts understate activity, honestly.
The commands
ps -A -o pid,user,time,rss,comm | grep sandboxd
man sandboxd
man 7 sandbox
man sandbox-exec
plutil -p /System/Library/LaunchDaemons/com.apple.sandboxd.plist
launchctl print system/com.apple.sandboxd
kmutil showloaded | grep -i sandbox
ls /System/Library/Sandbox/Profiles | wc -l
strings -a /usr/libexec/sandboxd | wc -l
codesign -dv /usr/libexec/sandboxd
log show --last 1h --predicate 'process == "sandboxd"' --style compact
log show --last 5m --predicate 'eventMessage CONTAINS "Sandbox:"' --style compact
Everything above was measured read only on one Mac, and the one thing the measurements cannot tell you is what any individual app’s profile says, because App Store apps carry their entitlements inside their own bundles, not in the system folder. For the system’s own 553 services, the profiles are open on disk. For everything else, the Activity Monitor Sandbox column, a setting Apple documents itself, is the closest thing the Mac gives you to watching the walls work.
Questions
What is sandboxd on Mac?
It is the user space half of the Mac's sandboxing system. A kernel extension called com.apple.security.sandbox does the actual blocking of file reads, network connections and information requests for every sandboxed app, and sandboxd handles the paperwork around those decisions: it writes the violation reports the kernel hands it, symbolicates their backtraces, keeps the compiled profiles that define each app's rules, and brokers permission upgrades between a sandboxed app and the privacy system. It runs as root from boot, held about 4 MB of memory on the Mac measured here, and had spent 50 seconds of processor time across 26 days.
Is sandboxd a virus or malware?
No. It is Apple's own code, and you can verify that yourself: the binary lives at /usr/libexec/sandboxd, and running codesign -dv on it reports the identifier com.apple.sandboxd with a platform signature, the class of signing Apple reserves for the operating system's own files. It has run continuously since boot on a healthy Mac, launchctl reports one run and no exits, and there is no known malware that imitates its name. If you want a second opinion, right click the process in Activity Monitor and choose Sample, or check the path column: anything outside /usr/libexec with this name would be worth a closer look.
Why is sandboxd using CPU or memory?
Almost always, it is not, and the measurements here are the proof: 50.56 seconds of processor time across 26 days and 8 hours, which is under two seconds a day, on a machine with browsers, chat apps and developer tools running the whole time. Its memory held at about 4 MB. When sandboxd does run hot, the daemon is not the problem, the client is: some app is generating a stream of sandbox violations or permission requests, and the kernel's own log lines name that app process by process. Read the deny lines, fix or quit the app they name, and sandboxd goes quiet with it.
Can I quit or disable sandboxd?
There is no supported way, and no good reason. The daemon vends one of the operating system's numbered host special ports, the channel the kernel and the rest of the system use to reach sandbox services, and every sandboxed app on the Mac depends on those services staying up. On the Mac measured here launchctl reported runs = 1 and last exit code = never exited, across the full 26 day uptime. Killing it would not disable sandboxing, which lives in the kernel; it would break the reporting and permission machinery on top, and launchd would restart it anyway.
What is the difference between sandboxd, App Sandbox, sandbox-exec and SIP?
Four layers, often confused. The kernel extension com.apple.security.sandbox is the enforcement engine. App Sandbox is the name of the feature apps adopt, in Xcode, by declaring entitlements; Apple's documentation calls the sandbox entitlement an App Store requirement for any app submitted to the Mac App Store. sandboxd is the daemon doing the kernel extension's user space paperwork. And sandbox-exec is a deprecated command line tool from an earlier era that could wrap any command in a sandbox profile, whose own manual now says developers should adopt App Sandbox instead. SIP, System Integrity Protection, is not part of this family at all: it protects system files from modification, while the sandbox restricts what apps can reach.
Ready? Buy Ribbon for $15, or read all the guides.