Skip to main content

On 20 November, Signal announced it would block the AI agents now built into iOS and Android from reading its screen. The reason is simple. Gemini on Android and Siri AI on iOS 27 can look at whatever is on the display and answer questions about it. A conversation open in Signal is now visible to a second reader, one Signal never integrated with and cannot audit. Signal called this “an existential threat” to app-level privacy, and asked Apple, Google and Microsoft for a documented way to opt out.

Signal is not the only app with this problem. Any product that shows sensitive data on a phone, from a banking dashboard to a patient record, now has the same second reader. So we asked: what do privacy-focused apps actually do about it today? We read the source code of 32 open-source Android apps whose whole pitch is privacy, and checked which of Android’s screen-protection APIs each one uses.

TL;DR

  • We scanned the source of 32 open-source privacy apps (messengers, password managers, authenticators, email, VPN, wallets) for every Android API that limits what an on-device assistant or capture tool can see.
  • 30 of 32 reference FLAG_SECURE, the flag that blocks the assistant, but only 11 apply it to their main screen by default. Of 11 messengers, just 2 do.
  • Exactly one app, Signal, notices when an assistant asks for its screen. Its detector is about 200 lines of timing heuristics, had to be rewritten for Android 17, and acts only after the assistant has already asked.
  • Zero of 32 call setAccessibilityDataSensitive, the Android 14 API that hides views from agents reading the screen through accessibility permissions. Bitwarden and KeePassDX get the protection anyway, through an undocumented side effect of a tapjacking flag.
  • On iOS there is no developer API at all. Signal blocks capture by borrowing a private UIKit view, and the only official per-app exclusion (iOS 27.2) belongs to the user, not to you.

The New Reader on Your Screen

Mobile assistants have been able to request screen content for years. Android’s Assist API dates from 2015, and the hook Signal now relies on, Application.OnProvideAssistDataListener, has existed since API 18 in 2013. What changed in 2026 is what sits on the other end. Gemini’s screen context and Siri AI’s onscreen awareness turn that request into a capable model that can summarise a conversation, extract figures from a statement, or act on what it reads.

For a development team this changes the threat model. Your app’s data used to leave the device only through channels you built. Now there is one you did not build, cannot see in your logs, and cannot fully switch off.

What Signal Actually Shipped

Signal’s Android client is open source, so we read the code rather than the blog post. The work lives in a class called AssistantScreenSecurityObserver, whose history starts on 8 October 2026 as an internal-only feature. It registers for the Assist API callback that fires when an assistant requests data from the foreground activity. When that happens and the user has not enabled Screen Security, it switches it on (which sets FLAG_SECURE on the window) and shows a bottom sheet explaining why.

The interesting part is everything around that callback, because the callback is not specific to assistants:

  • Recents fires it too. Opening the app switcher requests assist data. Signal ignores any request that arrives while the activity has lost window focus.
  • Screenshots fire it too. On Android 14 and later, Signal registers a screenshot callback, ignores any assist request within 3 seconds after a screenshot, and waits 2 seconds after each request in case a screenshot is reported late.
  • Users can say no. If the user turns protection back off, Signal will not ask again for 90 days.
  • It is behind a remote flag. The whole behaviour is gated on a remote config value, added on 27 October, whose default in the code is off.

The commit history tells the rest. The first version inspected the view structure being handed to the assistant. On 4 November a commit titled “Fix screen security bug on Android 17” replaced that approach with the application-level listener. On 20 November, the day of the announcement, another commit fixed the prompt appearing when users simply took a screenshot. Three revisions in six weeks, all spent inferring intent from a callback never designed for it.

Two structural limits follow from the design. First, it is reactive. The observer learns that an assistant is present from the assistant’s own request, so protection switches on in response to an access, not before it. Second, the remedy is all or nothing. FLAG_SECURE blocks the assistant, but it also blocks the user’s own screenshots and screen recordings, which is why Signal ships it off by default and asks before forcing it on.

The iOS side is more fragile still. Apple offers no public API to keep a view out of screenshots, so Signal’s ScreenshotBlocking.swift creates a UITextField, finds its internal subview by checking that the class name contains TextLayoutCanvasView, swaps in the layer of the view it wants to protect, and toggles isSecureTextEntry so UIKit’s password redaction applies to that layer. A guard fails loudly if Apple renames the private class. It works today; nothing guarantees it survives the next iOS release. On macOS, Signal says it cannot block screenshots at all.

What We Scanned

We took 32 actively maintained open-source Android apps that people choose for privacy: 11 messengers, 7 password manager, authenticator and key apps, 4 email clients, and 10 VPN, browser, storage, documentation and wallet apps. For each, we streamed the default branch as of 21 November 2026 and searched every Kotlin, Java, XML, Dart and TypeScript source file for the APIs that matter:

  • FLAG_SECURE: blocks screenshots, recordings, non-secure displays and, per Android’s own documentation, the assistant.
  • setRecentsScreenshotEnabled (API 33): keeps the app’s thumbnail out of the recents screen.
  • registerScreenCaptureCallback (API 34): tells the app a screenshot was taken.
  • OnProvideAssistDataListener / onProvideAssistData: the hook that reveals an assistant request.
  • setAccessibilityDataSensitive (API 34): restricts a view to accessibility services that declare themselves genuine accessibility tools.
  • setContentSensitivity (API 35): hides a view during screen sharing and recording only, so it would not stop an assistant even if adopted.

The Results

A source reference is not runtime behaviour, so for every hit we read the surrounding code and the preference defaults, and classified what a fresh release install does on the app’s main screen (the conversation list, vault, inbox or wallet).

Main screen on a fresh install Apps Which
Protected by default 11 Molly, SimpleX, Bitwarden, Proton Pass, KeePassDX, Aegis, 2FAS, FreeOTP, Tella, Monerujo, Ente Auth
Off by default, user can turn it on 10 Signal, Wire, Threema, Delta Chat, Nextcloud Talk, Conversations, Proton Mail, FairEmail, Orbot, Nextcloud Files (via app lock)
Only specific sensitive screens 6 Telegram, OpenKeychain, Thunderbird, WireGuard, DuckDuckGo, Unstoppable Wallet
No main-screen protection found 5 Session, Element X, Tuta, Proton Drive, Proton VPN
API Apps using it (of 32)
FLAG_SECURE referenced anywhere 30
setRecentsScreenshotEnabled 4
Assist request listener 1 (Signal)
registerScreenCaptureCallback 1 (Signal)
setAccessibilityDataSensitive / accessibilityDataSensitive 0
setContentSensitivity 0

The control is everywhere. The default is not.

Thirty of the 32 apps reference FLAG_SECURE, so on paper the industry knows the answer. What matters is the default, and it splits sharply by category. Password managers and authenticators protect their main screen out of the box: six of the seven in our sample set the flag on a fresh release install, and the seventh, OpenKeychain, secures only its passphrase dialog. Their users expect screenshots to fail anyway.

Messengers are the opposite. Of the 11 messengers, only two (Molly and SimpleX) protect the conversation screen by default. Signal, Wire, Threema, Delta Chat, Nextcloud Talk and Conversations all ship the protection switched off. Telegram protects secret chats and chats where the sender has restricted saving, but not ordinary ones. Session adds the flag only when the app goes to the background, which hides the recents thumbnail but leaves the open conversation readable. Element X has no screenshot setting at all. On Android 13 and later its PIN lock only hides the recents thumbnail. Molly, a fork of Signal, is the clearest illustration of the trade-off: same codebase, same setting, opposite default.

Email follows the messenger pattern. Proton Mail, FairEmail and Thunderbird all leave the inbox readable by default, although Proton Mail always secures its login and two-factor screens. Several apps also tie protection to app lock rather than offering it on its own (Threema, Nextcloud Talk, Nextcloud Files, and Telegram’s passcode), which means a user who wants the assistant blocked has to accept a PIN prompt as well.

Two caveats keep this fair. Defaults are build-dependent: Bitwarden, Aegis, 2FAS, Proton Pass, Monerujo and Ente only block capture in release builds, and we classified those. And Proton VPN and Proton Drive may secure some password dialogs through a shared Proton library that we did not inspect in the built apps.

One detector in 32

Signal is the only app that listens for assistant requests at all. Even Molly, the hardened fork of Signal, does not have the observer on its default branch yet. Every other app treats the assistant like a screenshot: the window is either secure or fully readable.

Nobody calls the API built for the other half of the problem

Signal’s post makes a second point that got less attention. Third-party agents (Signal names Meta’s Muse) are reading app data through accessibility permissions that users grant during setup, which Signal calls “a skeleton key.” FLAG_SECURE does nothing here, because it governs capture, not the accessibility node tree. Android 14 added a direct answer: setAccessibilityDataSensitive(ACCESSIBILITY_DATA_SENSITIVE_YES) limits a view to accessibility services that declare isAccessibilityTool, the flag meant for genuine assistive technology such as screen readers.

None of the 32 apps calls it, in code or in layout XML. Four get some of its effect anyway, through a side door. In the Android 14 platform source, a view left on the default setting is treated as accessibility-sensitive if it sets filterTouchesWhenObscured, the long-standing defence against tapjacking overlays, and that sensitivity is inherited by every child view. The public attribute documentation does not mention this; we found it in a source comment in View.java. Bitwarden sets the flag on its whole window, so its vault is covered on Android 14 and later. KeePassDX sets it on 23 layouts, including the group and entry screens. OpenKeychain sets it on three dialog layouts and Proton VPN on one confirmation screen. No messenger in the sample sets it anywhere.

This defence also depends on Google Play policing which services may claim to be accessibility tools, so it is not watertight. It is still the only platform control aimed at these agents, and nobody in our sample sets it explicitly.

The Platforms Have Left This to Users

Android’s assistant documentation is blunt about the developer’s position: “There is no global (app-level) mechanism to exclude all views from the assistant.” You must set FLAG_SECURE on every window, “including dialogs.” Miss one bottom sheet and that sheet is readable.

Apple’s answer arrived in iOS 27.2 as a user setting. Under Settings, Siri, Excluded Apps, a user can stop Siri AI from accessing a named app, which the EFF tested and confirmed blocks onscreen awareness inside Signal. That is a real improvement, but notice who holds the switch. An app cannot declare itself excluded, cannot query whether it is excluded, and cannot ask the user to exclude it except through its own onboarding copy. On Android, the EFF notes, Gemini’s screen context still cannot be switched off per app at all.

What We Recommend

None of this needs a platform change to start. For any app that shows data your users would not paste into a chatbot themselves:

  1. Classify screens, not the app. List the screens that show regulated or secret data: credentials, recovery codes, health or financial records, private messages. Apply FLAG_SECURE to those windows by default, including every dialog and bottom sheet they open, and leave the rest alone so users keep their screenshots.
  2. Set accessibilityDataSensitive explicitly on the same views. It costs one line per view on Android 14 and later, screen readers that declare themselves accessibility tools keep working, and it is the only control aimed at accessibility-based agents. Do not rely on the filterTouchesWhenObscured side effect: it is undocumented, and an explicit value states your intent in code review.
  3. Turn off the recents thumbnail with setRecentsScreenshotEnabled(false) on those activities. Only 4 of our 32 apps do.
  4. Audit what you volunteer. If you implement onProvideAssistContent or Gemini app integrations, check that sensitive screens provide nothing. Then check notifications: the EFF points out that Gemini can read them, so message bodies and codes belong behind VISIBILITY_PRIVATE or out of the notification entirely.
  5. Test it with the real assistant. Before each release, open your most sensitive screen, invoke Gemini or Siri and ask what is on the screen. It takes two minutes.
  6. Treat the iOS workaround as a risk decision. The UITextField layer trick depends on private UIKit internals and could break or trigger review issues. If you adopt it, wrap it in a guard like Signal’s, test it on every iOS beta, and remember that Signal’s code is AGPL-3.0: borrow the pattern, not the file. Either way, tell users that Excluded Apps exists.

There is a fair counter-argument. Plenty of users want the assistant to read their screen, and an app that silently blocks screenshots on every screen will annoy them. Signal’s design accepts this: protection is off by default, the user is told when it is switched on, and they can undo it. The goal is not to block everything. It is that the decision about your most sensitive screens is made deliberately by your team, not defaulted to whatever the operating system’s AI decides to read.

Need a Second Pair of Eyes?

REPTILEHAUS builds and audits mobile and web applications for teams that handle sensitive data, and our AI and security work increasingly starts with exactly this question: what can the agents around your product see? If you want a screen-by-screen review of your app’s exposure to on-device assistants, or help designing AI features that respect those boundaries, get in touch.

Related reading: Age Assurance Is Moving Into the OS and Android 17 Added New APIs. Only Pixels Have Them Until December.

Method note: static scan of each project’s default branch on 21 November 2026, covering Kotlin, Java, XML, Dart, TypeScript and build files, excluding files over 3 MB. A source reference shows intent, not behaviour on every device; shipped builds can lag the default branch.

📷 Photo by Yuriy Vertikov on Unsplash