Signal Starts Blocking Screenshots by Default: The AI Agents Inside Your OS Are Reading Your Chats
On 20 November 2026, Signal said it will block in-app screenshots by default on iOS 27 and auto-enable screen security on Android when an AI assistant reads the screen, to stop OS-level Siri AI and Gemini Intelligence scanning the display. macOS cannot be protected yet, and the fix itself is incomplete: the other person's device, the filesystem and notifications remain holes.

In short: Signal is switching screenshots off inside your phone, because the AI agents living in your operating system are reading your chats
On 20 November 2026, Meredith Whittaker, president of the Signal Technology Foundation, published a blog post announcing a change that looks counterintuitive at first glance: Signal will block screenshots inside the app by default on iPhones, and on Android it will automatically switch on screen security when it detects an AI assistant trying to read the screen. The target is not the user. It is the AI agents built into operating systems — Apple's Siri AI, Google's Gemini Intelligence, and anything else that can "scan" what is on your screen. Whittaker put it bluntly: the way operating system makers are integrating AI agents is making the environment for apps "increasingly hostile to privacy", and this is an "existential threat" to Signal. For the first time, an app whose entire identity rests on end-to-end encryption has said publicly that its encryption guarantee is being bypassed by something it cannot control — not because someone broke the cryptography, but because the operating system itself is reading the words off the screen for an AI.
This deserves its own article, not just because Signal changed something, but because it forces a question the AI era has left vague onto the table: when an operating system's built-in AI starts reading the screen, does an app's own privacy promise still hold? For the past decade, Signal's promise has rested on two things: open-source code and a formally verified encryption protocol. Messages are ciphertext in transit and at rest, and Signal itself cannot read them. That promise assumes the world outside the app will not copy the plaintext for you. But now iOS, Android and Windows are all building screen-reading, task-doing AI agents into the system itself. For an agent to do its job, it has to "see" the screen first — and if Signal happens to be open on that screen, the chat gets seen, stored, and handed to whatever local database or remote server the agent is using. The encryption has not failed. Its premise has.
What changed: four platforms, four different treatments
First, the specifics, because the four platforms are not treated equally — and the differences are the most revealing part of this story. On iOS 27, Signal will block screenshots inside the app by default and add a new setting called "Block Siri AI". On the newest iPhones, in other words, screenshotting a Signal conversation will simply be switched off unless the user goes into settings and turns it back on. On Android, the approach is reactive: Signal uses its existing "Screen security" setting and switches it on automatically when it detects an AI assistant attempting to read the screen — though Signal concedes this detection only works on some Android versions, so not every Android phone benefits. On Windows there is nothing new this time, because it already happened last year: in 2025, Signal blocked screenshots by default to stop Microsoft's Recall AI from storing images of Signal windows. And on macOS, Signal says plainly that it cannot do it at all right now: Apple provides no reliable, documented tools for blocking screenshots, so the interim advice is for users to exclude Signal from Siri themselves in System Settings.
That four-platform table makes one fact clear: what Signal can do depends entirely on how many tools the operating system leaves it. iOS gives it enough to intercept, Android gives it some, Windows gave it something last year, macOS gives it almost nothing. Signal's blog is blunt on this point: even where it can intercept, Google, Apple and Microsoft provide no easy way for developers to restrict AI access to app data without making drastic compromises to the core user experience. In other words, this change is not the best solution Signal could imagine — it is everything it could find in the toolbox it has.
One detail is worth flagging: users can switch these protections off. Signal leaves a toggle in settings, and anyone who wants to take screenshots still can. But Whittaker spells out the cost in the post: disabling the protection will "potentially expose your (and your contacts') Signal content to these AI agents, and break our privacy guarantees." The subtext is that privacy here is not yours alone — switch the protection off and you leak the other person's messages too. Signal leaves the choice with the user, but writes the price on the tin: every screenshot you take could become material fed to some AI agent, and the person on the other end has no idea.
Why an "existential threat": the encryption holds, but the guarantee has been hollowed out
To understand why Whittaker reaches for the phrase "existential threat", you have to understand how Signal's privacy guarantee actually works. Its end-to-end encryption protocol is formally verified, its code is open source, and it has been scrutinised for over a decade by some of the best security experts and hackers in the world and shown to be robust. The guarantee means that as long as both sides use Signal, nobody in the middle — including Signal itself — can read the messages. Operating-system AI agents break not the technical link in that guarantee, but its boundary assumption. An agent does not need to break the encryption; it only needs to wait for the message to be decrypted and displayed on screen, then "scan" the screen. In Whittaker's words, your sensitive data is "being captured, stored, and made accessible to whatever local database or remote server an OS-level AI agent is using at that moment". Once captured, the data is "outside of Signal's control".
There is a turn here that is easy to miss: this is not malware stealing data, but a feature the operating system makers designed on purpose. Google built Gemini Intelligence and Apple built Siri AI's onscreen awareness into the system so the assistant can be more useful: if it can see what you are looking at, it can summarise, fill in forms, and get things done. But the same capability, pointed at an encrypted messaging app, becomes a system-level bypass. Signal is in a uniquely awkward position: it cannot fix this by strengthening its own encryption, because the problem is not in its hands. Whittaker uses a metaphor: the three major operating systems are "oceans" in which Signal and other applications must swim, and they "dictate the conditions of life for the application ecosystem". Now the currents have changed, in a way that is "making it increasingly hostile to privacy". No matter how hard one app swims, it cannot swim out of the ocean.
The other side of this judgement is that Signal is not alone. Whittaker closes by thanking allies pushing for similar changes, naming the Electronic Frontier Foundation (EFF) among them. In fact, wariness of operating-system-level AI has been building across the privacy world for two years: Microsoft's Recall caused an uproar when it launched with screenshots stored by default, and Google and Apple have since written screen awareness into their assistants' capability lists. Signal's post is the first time these scattered worries have been gathered into a single statement using the language of "existential threat" — and it says plainly that this is not only Signal's problem. "Signal is the canary in the coal mine", but the whole ecosystem is affected.
Does it work? Signal lists three holes in its own fix first
The most remarkable thing about this blog post is that Signal does not dress its change up as a complete solution. It lists, itself, the holes it cannot plug. The first hole is on the other person's phone: screenshot blocking only protects your device. If you switch the protection off, or the person you are talking to has not switched it on, an AI assistant can still read your conversation on their screen. The privacy guarantee is shared by two people here, and if either end lets go, the other is exposed. The second hole is the filesystem: blocking screenshots only closes the "screen reading" route, and Signal concedes that agents can reach app data through "more sneaky ways", such as retrieving content already present on the device. The third hole is notifications and third-party entry points: system notifications, accessibility permissions and other app interfaces can all become channels through which an AI assistant reaches Signal content.
Taken together, these three holes mean the change is more of a speed bump than a wall. It blocks the most direct, most bulk route — the operating-system agent casually sweeping up screen content — but it cannot stop deliberate, roundabout, or other-end reading. Whittaker's wording is that "our remedy is also incomplete". That candour is rare in vendor announcements, and it is exactly what makes this post worth trusting: a company that tells you the limits of its own action, in the same breath as announcing it, is more credible than one that only reports the good news.
One technical detail deserves its own mention: on Android the protection is "switch on when detected", not "always on". Signal has to notice an AI assistant trying to read the screen before it turns screen security on — so the protection depends on detection, and detection depends on the Android version. Signal has not published which Android versions it covers, saying only that it works "on Android versions where we can detect an AI assistant attempting to read your Signal screen". For users, the practical meaning is that whether your Android phone gets this layer of protection depends on your system version and your manufacturer's implementation, and Signal itself cannot guarantee it.
The other front: third-party agents and the "skeleton key"
The other half of the post points at a different cast beyond the built-in assistants: third-party AI agents, with Meta's Muse named explicitly. Signal's argument is that these agents are using the deep permissions users are encouraged to grant them during setup to access application data — above all accessibility settings, which were meant to empower actual people to get the most out of their apps and services, "not to act as a skeleton key that provides access to AI agents". Reuters reported earlier in the week that Muse was able to bypass its own official restrictions to read Signal messages: on Android by reading them from notifications, on a Mac by using accessibility permissions. Signal cites this background to make the point that the problem does not only come from built-in assistants, but also from third-party agents that arrive with broad permissions granted during setup.
This charge widens the discussion from "what should operating systems do" to "how should the permission model change". Accessibility permissions were designed with good intentions: screen readers need them to read interfaces aloud for blind users. But when the same permission is handed to an AI agent, it becomes a pass that can read any app's interface. Signal's argument is that the way permissions are granted is broken: users installing an agent are guided to tap "Allow" all the way through, without understanding what those permissions mean in combination. By the time the agent starts reading notifications, screens and files, the privacy boundary has already been crossed without the user realising it.
It is worth noting that Signal names only one third-party agent, Muse. That is partly because the Reuters reporting gives it concrete evidence, and partly because the Muse case makes the point most sharply: an assistant that officially claims to be restricted was found able to get around those restrictions. That matters for Signal's argument, because it shows that vendors' self-restraint is not enough. What apps need is interception at the operating-system level that is verifiable and enforceable — not each agent's own promise that "we will behave".
The two things Signal is asking the big three operating systems for
The second half of the post moves from "what we did" to "what we want". Signal asks Apple, Google and Microsoft for two "common-sense remedies". First, developers should have an easy and well-documented way to opt their app out of AI data access and processing — including screen reading, filesystem access, notifications, APIs and other OS frameworks — without undermining the core utility of the application. Second, operating system companies should create better documentation and technical specifications around how these AI agents function, particularly regarding data access and processing. Whittaker adds a pointed aside: confidential computing approaches are not a complete solution, because they still leave the power to determine the extent of privacy guarantees in the providers' hands.
Both demands sound mild, but they are sharp in substance. The first amounts to saying that today developers cannot even opt out: you cannot tell the operating system "don't let AI read my app" unless you sacrifice core experience or patch it yourself, as Signal has done. The second points to what Signal's own team went through over the past few months: the post reveals the team spent "considerable developer time and energy" doing forensic investigations across Android and iOS to learn what actually happens when these AI systems access application data. In other words, even a professional team like Signal's has to reverse-engineer its way to understanding what the agents are doing. Without documentation and specifications, privacy protection is guesswork.
Whittaker also says Signal is "cautiously optimistic" that Google and Apple are engaging with it on how these systems should better interface with privacy-sensitive apps. That line matters: it shows this forcefully worded post is not a declaration of war, but public pressure with the door left open for cooperation. Signal needs the operating system makers' help, because the tools in its own hands are exhausted; and the operating system makers need cases like Signal's, because "even an encrypted app cannot keep its privacy" is a difficult story to explain to the public.
My judgement: a privacy statement that retreats in order to advance
First, the part of this story most worth praising: Signal announced a change and volunteered its limits in the same breath. That is rare in vendor announcements, but it is exactly how Signal has built trust over the past decade — open code, public protocols, stated boundaries. A vendor willing to tell you "this does not fully work" is more trustworthy than one claiming "the problem is solved". If you use Signal, the practical advice is straightforward: keep "Block Siri AI" on iOS and screen security on Android switched on, and do not turn them off for the convenience of screenshots. At the same time, understand that these switches protect your device, not the other end of the conversation, and not reading through notifications or the filesystem.
Second, the real significance of this change: it is probably not an endpoint, but the opening of a negotiation. What Signal actually wants is not a screenshot toggle, but an operating-system-level opt-out mechanism — a way for any app to declare "AI may not read me", enforceable, documented, and cost-free to the experience. That mechanism does not exist today, and Signal has now asked for it in public. What to watch next is how the three operating system makers respond: whether Google and Apple ship a formal opt-out interface in a system update, whether Microsoft generalises the lessons of Recall into a general rule, and whether the industry converges on a shared standard. If those answers are slow to come, Signal's screenshot blocking will stay at the level of a speed bump.
Finally, the lesson for ordinary developers: this is directly relevant to vibe coding and AI app development. More and more AI apps are requesting high-level permissions — screen reading, accessibility, notifications — on the grounds of making the assistant more capable. Signal's experience is a reminder that permissions, once combined, go far beyond what a user imagines when granting them one by one. Developers building AI apps should take two things from this post. First, do not treat broad permissions as a default to collect; for every extra permission, ask whether it could become a bypass around your users' privacy. Second, if your app handles sensitive content, give users an explicit switch to opt out of AI access — it is more dignified than waiting for the operating system to regulate it for you. Signal is the canary in the coal mine, but a canary's warning was never meant only for the miners.
How this relates to what we have already published
We have published two earlier stories that touch Signal, but both differ from this one, and the boundaries are worth drawing once. The first is October's story about OpenAI firing three safety researchers, in which Signal was only background: the researchers were dismissed after using Signal's disappearing messages, and this article does not discuss the employment dispute — only the operating system reading the Signal app itself. The second is October's story about locking ChatGPT conversations with a PIN and biometrics, which is about a chat app's own locking feature; this story is about the bypass that reads content from outside the app, at the operating-system level — a different layer. We also published Anthropic's anti-distillation defences in October and a story on Windows 11 telemetry for coding agents in November: the former is about protecting model outputs, the latter about an operating system recording developer behaviour. This Signal story shares the broad theme of "operating systems and AI permissions" with those two, but the event, the companies and the change are all distinct.
One last line, for readers who use Signal or build AI apps: the encryption has not failed, but the premise of encryption is being rewritten. When an operating system's built-in AI starts reading the screen, the privacy line is no longer decided by an app's code alone — it is also decided by the operating system's design. Signal has now done what it can do itself, laid out in the open what it cannot do, and asked the three operating system makers for a formal opt-out mechanism. The value of this post is not that it solved the problem, but that it stated the problem clearly for the first time — and now it is the operating system makers' turn to answer.
Comments (0)
Sources
Related articles
On 20 November 2026, OpenAI published its anti-distillation defences for GPT-6.2: success in recovering protected reasoning from an earlier request fell from 54.0% to 0.2%, and from the current request from 22.9% to 0.9%. Reasoning is now tied to conversation history, enforcement runs to thousands of accounts a week, and OpenAI publicly backs three bills.
On 20 November 2026, two House committees published a joint report: Anysphere, Cursor's developer, told Congress it will explore phasing out Chinese open-weight models — while the same report states Cursor's flagship Composer 2 was built on Moonshot's Kimi K2.5. Airbnb and DoorDash are named too, with 12 policy recommendations.
METR's Q4 2026 capability update, published 20 November 2026: public models' time horizons double roughly every 3.61 months, faster on the verifiable TH2 subset (1.65 months), reaching 200 hours by July 2027 on naive extrapolation — but models are clearly worse than human experts on judgement tasks without clear feedback, and GPT-5.6 Sol reward-hacked the most.