# CommCenter, the phone company inside a Mac with no phone

> CommCenter relays phone calls through your iPhone, and it is the name behind the login keychain prompt. Measured: an SMS scoreboard stuck at zero since day one.

Source: https://www.ribbonmac.com/guides/commcenter-mac · Updated 2026-11-17

The prompt stops people mid-thought. CommCenter wants to use the login keychain. A window wants a password, the name sounds like a telecom, the Mac in question has no SIM card and no modem, and the honest first instinct is suspicion. This page is the measured answer: what CommCenter is, why a Mac with no radio runs it, what it wants from your keychain, and what it does all day when nobody calls.

Everything below was measured the way this series measures: on a MacBook Pro running macOS 27.0.1 on Apple silicon, 28 days past its last boot, read only, nothing installed, no setting changed.

## The receipts

`ps` finds one process, and its identity is already a small surprise:

```
chethankumar  23151  PPID 1  RSS 6912K  up 20:46  CPU 0:01.72  0.0%
  /System/Library/Frameworks/CoreTelephony.framework/Support/CommCenter -L
```

It runs as you, not root. Its parent is launchd. Its whole argument list is a single letter, `L`. And it lives not in a daemon folder but inside CoreTelephony, the framework iPhone developers use to read signal strength and carrier info. That placement is the story of the entire process: this is iPhone code, running on the Mac, waiting for phone work.

The binary behind it is 33,144,176 bytes, triple architecture, signed `Identifier=com.apple.CommCenter`, `Platform identifier=26`, built 24 September at 12:40, the same build minute this series measured on contactsd, appstoreagent and tccd. It is the largest binary measured in this series, 70 percent bigger than appstoreagent, and the reason is in the next section: it carries an entire phone stack.

## The manual finally answers

Most daemons in this series have no manual at all, or a single unhelpful sentence. CommCenter has a real one, and it settles the biggest question in one line. `CommCenter(8)`, dated March 31, 2017:

> CommCenter provides functionality to allow the Mac to make and receive phone calls.

There is a companion page too, `CommCenterRootHelper(8)`, dated April 11, 2017, for the privileged helper that was not even running on the measured Mac: "Helper to CommCenter(8)". Both pages end with the same three words as every daemon manual in this series, should not be directly invoked, and both link to one Apple support article as their only reference. That link now returns a page-not-found. The manual that defines the daemon points at a web page Apple has retired, which is the division of labour this series keeps finding: the machinery gets one sentence from 2017, and the feature gets the marketing.

So: the Mac can place phone calls. Real ones, cellular ones, the number dialled from your iPhone's plan. Click a phone number in Contacts, Calendar, FaceTime or Safari on the Mac and the call goes out through the phone in your pocket, which is why the process exists on a machine with no radio of its own. That call rides the network, Wi-Fi or the same Apple Account handshake, no cable in sight. When a phone does arrive on a cable, the conversation runs through a different tenant entirely: [usbmuxd](https://www.ribbonmac.com/guides/usbmuxd-mac), the USB multiplexer every plugged-in iPhone exchange goes through, and the quietest daemon this series has measured.

## The exemption list

The launch file explains who runs this thing. It is `/System/Library/LaunchAgents/com.apple.CommCenter-osx.plist`, and the `-osx` suffix is the giveaway: this is the macOS variant of the iPhone's own CommCenter, the process that talks to the baseband on every iOS device ever made.

Inside the plist is a key called `LimitLoadFromHardware` with a list of 39 Mac models: iMac7,1, iMac8,1, on through the MacBook Airs and Pros and minis of the late 2000s, ending at MacPro5,1. The oldest is from 2007. The newest is from 2010. And `launchd.plist(5)`, the manual for the system that starts every process on a Mac, defines the key exactly: with this key, the job "will not load" on the listed hardware.

Read plainly: Apple exempted every Mac too old to relay calls through an iPhone, and every Mac newer than 2010, Intel or Apple silicon, Wi-Fi radio or no radio, runs CommCenter at login. The feature list is effectively the hardware list. If your Mac is from this decade, this daemon starts on it, which is why millions of people who have never once placed a call from their MacBook own a phone daemon in Activity Monitor.

## The scoreboard that reads zero

What does a phone daemon do on a Mac with no phone? Its preferences folder answers with a straight face. CommCenter keeps a property list of counters, `com.apple.CommCenter.counts.plist`, and the register of things it counts is a phone bill:

```
CellularBytesRecved      value 0
CellularBytesSent        value 0
MOMMSSendSuccessfulCount value 0
MOMMSSendFailedCount     value 0
MTMMSRecvSuccessfulCount value 0
MTSMSRecvFailedCount     value 0
VVMNotificationsRecvedCount value 0
```

Mobile-originated MMS. Mobile-terminated SMS. Visual voicemail notifications. Cellular bytes sent and received. Every row reads zero, and every row carries the same start timestamp, which decodes to 19 September, the evening this particular Mac was taken out of its box and set up. For two months the daemon has kept a scoreboard of phone activity on a machine that has made zero calls, and the scoreboard faithfully says zero. A sibling file called `com.apple.commcenter.data.plist` is 55 bytes long and contains exactly one key, `pw_ver`, a password version number, a detail that matters in the keychain section below.

This is the honest picture of CommCenter on most Macs: not a worker but a standby, keeping its ledger current, at a cost the ledger section below puts at two seconds a day.

## What it wants from your keychain

Here is the answer the search traffic is really asking for. The prompt, CommCenter wants to use the login keychain, appears because the call relay keeps credentials in your login keychain, and the daemon needs them unlocked to do its job. The proof is in the binary's own strings: CommCenter carries a class named `KeychainObserver` with methods `readFromKeychain`, `saveToKeychain`, `clearKeychain` and `getKeysFromKeychainByLabelAndKeyPrefix`, 41 keychain-related strings in total. This daemon reads and writes keychain items as a core function, not an accident.

The prompt itself is the Mac's security model working, and its trigger is almost always a password change. The login keychain's password is set when the account is created, and if your account password later changes outside the normal flow, the keychain keeps the old one. From then on, every process with an item in the login keychain has to ask, and ask with the old password. CommCenter asks early because it starts at login and reads its credentials right away.

Three ways out, in order of preference. Type the old password once and click Always Allow; the daemon is satisfied and the prompt stops for it. Open Keychain Access, select login under Default Keychains, choose Change Password from the Edit menu, and set the keychain's password to your current account password, which fixes the prompt for every app at once. Or, if the old password is gone from memory, reset your default keychains from the Keychain Access menu, understanding that this erases the passwords the keychain had saved for you. The first route costs ten seconds and nothing else.

And the `pw_ver` key found above fits here: the daemon tracks a password version in its own preferences, one of the quiet bookkeeping keys that let it notice when the credentials world changed underneath it.

## A phone stack in 24,000 strings

The binary's strings read like a parts catalogue for a device this Mac is not. Of 24,033 strings in the arm64e slice, nearly two thousand match carrier, IMS or calling vocabulary. There is `Wi-Fi Calling`, with a log line ready for it, "WiFi calling feature mask changed". There is an entire SIM subsystem: `SimSlot` types, an `isim_files_status` property, and, under the codename Vinyl, a handler whose full mangled name includes `setVirtualSimMode:withDualSim:completion`, the eSIM and dual SIM machinery of modern iPhones, shipped to every Mac.

There are codenames this series has met before. Thumper appears as `thumper_handoff_allowed` and `broadcastThumperInvitation`, the machinery that hands a call session between devices, and one of the daemon's six Mach service doors is named `com.apple.private.alloy.thumper.keys-idswake`, the same alloy family [the identityservicesd page](https://www.ribbonmac.com/guides/identityservicesd-mac) found carrying iMessage wake-ups. The other doors include `com.apple.commcenter.coretelephony.xpc`, the door apps knock on to ask about telephony state, `com.apple.commcenter.oswatchdog`, and `com.apple.aps.CommCenter`, the push door, because an incoming call arrives on the Mac as a push, carried by [apsd](https://www.ribbonmac.com/guides/apsd-mac), the daemon this series measured holding one permanent connection to Apple's servers. When your iPhone rings and your Mac shows the call too, the path is: push to apsd, handoff to CommCenter, banner on screen.

## The watchman habits

CommCenter's log is quiet but insistent: 83 lines in half an hour, three refrains. The loudest is a minute-by-minute roll call, `Application exited`, one line per process that quits on the Mac, from the AppActObserver subsystem. The daemon watches what launches and what leaves, the way a receptionist tracks who is in the building.

Every few minutes it states the network truth as it sees it:

```
On WiFi: true On Cellular: false On Ethernet: false
```

And once every five minutes it tries the push door and fails, on the measured Mac, with a trio of lines worth quoting whole:

```
Bad response from apsd
Daemon connection did not succeed. Is apsd running?
Will attempt reconnect in 300.000000 seconds
```

The funny part is that apsd was running the whole time. The retry loop is not a fault; it is the daemon's own conservatism about one connection among its six doors, logging its doubt every five minutes and never troubling anyone. If you ever read CommCenter logs and see that line, nothing is broken.

## The dead man's switch that is off

The launch file grants one more good detail. Its KeepAlive rule says: stay alive if crashed, and stay alive while a certain file exists, `/tmp/CommCenter.KeepAlive.Enabled`. On the measured Mac, that file does not exist. The switch that would hold the daemon in memory permanently is off, and yet the process ran unbroken for over 20 hours, because its clients keep knocking on its Mach doors and each knock is reason enough to stay.

The system, meanwhile, recycles it deliberately: `EnablePressuredExit` is set, and the launch database shows 80 runs in 28 days, about three fresh copies a day, with the last exit reason reading `JETSAM_REASON_MEMORY_IDLE_EXIT`, the same purposeful memory reclaim this series found on suggestd and apsd. Memory fell from 6.9 MB to 5.6 MB between two samples taken while writing this page. A daemon the system can evict and relaunch at will, three times a day, without anyone noticing a single missed function, is the system working as designed.

## The quiet ledger

One second and 72 hundredths of processor time, over 20 hours and 46 minutes of life. That is about two seconds a day, level with installd's couple of seconds as the cheapest measured in this series, under appstoreagent's five, far under tccd's four daily minutes, in another league entirely from [logd](https://www.ribbonmac.com/guides/logd-mac) and its nine. Zero crash reports in 28 days. No high CPU search family exists for CommCenter at all, an absence this series has learned to respect: daemons that cause pain acquire complaint vocabulary, and this one has none.

The full cost of the phone company inside your Mac, standing by for calls that may never come, is two seconds a day and six megabytes that shrink.

## What Apple says, and does not

The user facing page for the feature is called Receive phone calls and text messages on your Mac, and its first sentence is the cleanest description of the architecture anywhere in Apple's documentation: "You can relay phone calls and text messages through your iPhone to your Mac, so it's easy to stay in touch no matter which device you're on."

The requirements are the recipe this article has been reverse engineering: both devices on the same Wi-Fi network, the same Apple Account, your phone number turned on in FaceTime settings, and on the iPhone, Calls on Other Devices switched on. The page even covers the dual SIM case, noting a relayed call uses your default voice line, and puts the two devices within 10 metres of one another. Across all 268 kilobytes of that page, the word CommCenter appears zero times. Apple documents the relay, never the relay operator, and the manual that names the operator links to a support page that no longer exists. Between those two silences sits this daemon, on every Mac since 2011, asking for your keychain.

## The short version

CommCenter is the Mac's phone call daemon: a 33 MB iPhone-inherited binary inside the CoreTelephony framework, running as your user from a launch file whose exemption list names every Mac older than 2011, keeping a scoreboard of SMS and MMS counters that on most Macs has read zero since setup day. It relays calls through your iPhone over the same push and identity plumbing as iMessage, [apsd](https://www.ribbonmac.com/guides/apsd-mac) carrying the knock and [identityservicesd](https://www.ribbonmac.com/guides/identityservicesd-mac) vouching for the account, and its keychain prompt means only that its credentials are locked behind an old password; Always Allow once, or align the login keychain's password in Keychain Access. It costs two seconds of processor time a day, relaunches itself invisibly three times a day, and cannot usefully be quit, disabled or edited. It is not a virus, it is not broken, and on a Mac that never pairs with a phone, it is the world's most patient receptionist.

## FAQ

### What is CommCenter on my Mac?

It is the daemon that lets a Mac make and receive phone calls by relaying them through your iPhone. Its manual page, CommCenter(8), dated March 2017, says it in one line: CommCenter provides functionality to allow the Mac to make and receive phone calls. On a Mac paired with an iPhone on the same network and the same Apple Account, clicking a phone number in Contacts or FaceTime places a real cellular call, and this is the process underneath. It runs as your user account, not root, from the CoreTelephony framework, launched by launchd with a single argument, the letter L. It is signed by Apple inside the sealed system volume and is not malware, and there is nothing to remove.

### Why does CommCenter want to use my login keychain?

Because the call relay keeps its identity material in the login keychain, and the keychain is locked. The binary carries a class named KeychainObserver with methods for reading, saving and clearing keychain items; when it needs its credentials and the keychain's password no longer matches your account password, macOS asks on the daemon's behalf, and the password it wants is your old one, the one the keychain still remembers. The fix is to type the old password once and click Always Allow, or to open Keychain Access, select the login keychain and use Change Password to align it with your current account password. If the old password is lost entirely, Keychain Access can reset the default keychains, which erases saved passwords, so try the first two routes first. The prompt is annoying, not dangerous.

### My Mac has no cellular. Why is CommCenter running?

Because every Mac newer than 2010 loads it. The launch file, com.apple.CommCenter-osx.plist, carries an exemption list of exactly 39 Intel models, iMac7,1 from 2007 through MacPro5,1 from 2010, and launchd's own manual defines that key as hardware where the job will not load. Those were the Macs too old for iPhone call relaying. Everything since, including every Apple silicon Mac, runs the daemon whether or not a phone is ever paired. On the measured Mac its phone counters, cellular bytes, sent and received SMS and MMS, visual voicemail notifications, all read zero, and have read zero since the evening the machine was first set up. It idles at about two seconds of processor time a day, which is the cost of standing ready for calls that never come.

### Is CommCenter a virus?

No. The signature receipts are checkable in a second: codesign on the binary reports Identifier=com.apple.CommCenter and Platform identifier=26, meaning it is Apple platform code, and it lives inside the sealed system volume, which nothing can write to without breaking the seal the Mac verifies at boot. Its parent process is launchd, pid 1, and its path is inside the CoreTelephony framework in System. Malware can name itself anything, but it cannot put itself on the sealed volume, and the searches that pair CommCenter with the word virus are fear searches, the kind this series has met on apsd and cloudd. If you want to double check, Activity Monitor's process list shows the full path for any process, and a real one will match the path in this article.

### Can I quit CommCenter, and why is it using CPU?

Quitting it buys nothing, because launchd brings it straight back; the measured Mac relaunched it 80 times in 28 days without anyone noticing, since the system reclaims idle copies on purpose through the pressured exit mechanism and the next client knock starts a fresh one. As for CPU, in more than 20 hours of continuous running the daemon had accumulated 1.72 seconds of processor time, about two seconds a day, as cheap as any daemon measured in this series. There is no high CPU question with real search volume behind it, and that absence is itself the answer: a daemon this cheap does not generate complaint threads. If the column ever jumps, the cause is almost certainly a client, a call being placed or the phone relaying being reconfigured, not the daemon itself.

### What is CommCenterRootHelper, and what is com.apple.CommCenter.fine-grained?

CommCenterRootHelper is the daemon's privileged companion, with its own manual page, CommCenterRootHelper(8), from April 2017, that says it helps CommCenter provide the phone call functionality and, like everything in this family, should not be directly invoked. On the measured Mac it was not running at all; it is summoned only when something needs root, which for call relaying is rare. com.apple.CommCenter.fine-grained is a string inside the CommCenter binary that turns up in searches and in people's launchd dumps, and Apple publishes nothing about it beyond that; it is part of the control surface the binary exposes to the rest of the system, not a separate program, and it needs nothing from you.
