AI Agents Are Reading Your Titles in Real Time

AI agents don't need to join your Zoom call to know what's happening in it. They read your window titles.

This isn't a vulnerability in Zoom or Teams. It's just how operating systems work. Every window has a title. Any process with basic permissions can read those titles through standard Windows APIs. And it turns out, video conferencing apps generate some of the most valuable titles on your entire system.

We discovered this while building NoCapture. We were originally focused on blocking screen capture for privacy during meetings. But users kept reporting something weird: even when their screen was cloaked, scrapers were still extracting meeting IDs, participant names, and document titles from the window metadata itself. The capture was blocked, but the story was still being told through the title bar.

So we built title masking. And honestly, the more we researched what titles actually leak, the worse it got.

What Your Meeting App Is Broadcasting Through Its Title

When you join a call, your conferencing app updates its window title continuously. It feels harmless. It's not.

Zoom titles look like this:

• "Zoom Meeting ID: 123-456-7890"
• "Zoom - John Smith's Personal Meeting Room"
• "Zoom - Weekly Standup ([email protected])"
• "Zoom - Sharing Screen: Q3_Financials.xlsx"

Teams titles:

• "Weekly Review | John Smith | Microsoft Teams"
• "Chat | Jane Doe | Microsoft Teams"
• "Call with Jane Doe and 3 others | Microsoft Teams"
• "Recording... | Weekly Review | Microsoft Teams"

Google Meet:

• "Weekly Standup (123-456-789) - Google Meet"
• "meet.google.com/abc-defg-hij"
• "Presenting: Q3 Review - Google Slides - Google Meet"

Slack and Discord:

• "Huddle: #general - Slack"
• "Stage: Product Launch - Discord"

Each title updates in real-time as the meeting state changes. A scraper polling every 500 milliseconds builds a complete timeline: who joined, what was shared, when recording started, what documents were presented. All without ever touching your network.

How Scrapers Actually Harvest This

The technical mechanism is stupidly simple. Windows provides EnumWindows and GetWindowText APIs. Any process can list all top-level windows and read their titles. Task managers use these. Accessibility tools use these. So do scrapers.

EnumWindows(callback, 0);
// For each window:
//   GetWindowText(hwnd, buffer, 256);
//   → "Zoom Meeting ID: 123-456-7890"

That's it. No special permissions. No antivirus flags. Not considered malicious behavior by any EDR system because it's literally how task managers work.

Accessibility APIs are even richer. Windows UI Automation reveals window class names, control hierarchies, value properties, and event notifications when titles change. These are designed for screen readers. Scrapers use the exact same calls with the exact same permissions.

Advanced ones attach to the process memory directly. Electron apps like Slack, Discord, and Teams keep complete application state in the JavaScript heap. If you can read that memory, you have participant lists, message histories, shared file references. This requires elevated privileges, but it's achievable through legitimate debugging APIs.

We wrote about the full technical picture in our breakdown of screen capture APIs and the desktop extraction crisis. The short version: if it renders on your screen, something can read it. Titles are just the easiest target.

What a 30-Minute Meeting Title Stream Reveals

A scraper watching your titles for half an hour can build:

A meeting intelligence profile. The title sequence from one call might show:

• "Zoom - Q3 Financial Review" → meeting topic
• "Zoom - John Smith (CEO)" → participant identity and role
• "Zoom - Sharing Screen: Budget_v3.xlsx" → exact document and version
• "Zoom - Recording Started" → meeting is being recorded
• "Zoom - Jane Doe joined" → additional participant
• "Zoom - Sharing Screen: Termination_List.pdf" → sensitive HR document

An organizational network map. Across multiple meetings over days or weeks:

• Who meets with whom, how often, for how long
• What subjects are discussed in which groups
• Which files are shared and by whom
• Who initiates meetings vs who joins last
• Recurring patterns that predict future meetings

Competitive intelligence. Titles like "Product Launch — March 15" reveal go-to-market schedules. Titles containing competitor names indicate active negotiations. "Exit Interview — [Name]" reveals attrition before it's announced.

And this is just from titles. We're not even talking about screen capture yet. We covered how screen sharing itself leaks even more in our guide to meeting privacy.

The Meeting Link Problem

Titles often contain direct meeting links:

• zoom.us/j/1234567890
• teams.microsoft.com/l/meetup-join/...
• meet.google.com/abc-defg-hij

A scraper extracts these, validates if the meeting is still active, checks if waiting rooms or passwords are enabled, and attempts to join as a guest with a randomized name. Even meetings with waiting rooms are vulnerable — scrapers spoof legitimate participant names extracted from previous meeting titles, or join immediately after a real participant to reduce scrutiny.

Recurring meeting links are especially bad. The same link gets reused weekly, making it predictable. Once a scraper has it, they can attempt to join every future instance.

Why Your Existing Defenses Don't Help

Organizations have spent a lot on meeting security. They're defending the wrong surface.

Meeting passwords and waiting rooms protect against unauthorized guests joining via links. They do nothing against window title scraping, which happens entirely outside the meeting. The attacker never attempts to join. They just read the titles from your local machine.

End-to-end encryption secures the wire. It does not protect against local window title extraction, which occurs before encryption ever happens. E2EE secures the network, not the endpoint.

DLP and CASB solutions monitor network egress for data exfiltration. They don't monitor local API calls reading window titles. The data never leaves through the network channel they're watching.

EDR and antivirus flag malware and known threat signatures. Reading window titles is normal behavior. Task managers do it. Accessibility tools do it. Legitimate software does it constantly. EDR won't flag a process for calling GetWindowText because that would break half the apps on your system.

This is why we argue that manual hiding and traditional security tools are fundamentally insufficient. The attack surface isn't the network. It's the OS itself.

The Screen Sharing Title Leak

This part is particularly bad because people think they're being careful.

When you share a document, the conferencing app often updates the window title to include the filename:

• "Sharing: Acquisition_Target_Analysis.docx"
• "Sharing: Layoff_Plan_Q3.xlsx"
• "Sharing: Client_Contract_Draft_v2.pdf"
• "Sharing: [Competitor]_Pricing_Strategy.pptx"

Even when you're not actively sharing, the sequence of window titles during a meeting tells a story:

1. "Zoom - Weekly Review" → meeting starts
2. "Excel - Q3_Budget.xlsx" → presenter opens budget
3. "PowerPoint - Q3_Review_Deck.pptx" → presenter switches to deck
4. "Chrome - Salesforce" → presenter checks CRM during Q&A
5. "Slack - #leadership" → presenter receives urgent message

Each transition is timestamped. The scraper doesn't need to see your screen to know your workflow. The titles are enough.

I should mention — this isn't hypothetical. We tested this ourselves during development. We wrote a 50-line Python script using only built-in Windows APIs. In 30 minutes of observation, we reconstructed the full meeting timeline of a simulated sales call: topic, participants, documents shared, CRM checks, Slack interruptions. No network access. No meeting join. Just window titles.

What NoCapture Actually Does

Title masking intercepts window title updates before they reach the OS window manager:

• "Zoom Meeting ID: 123-456-7890" → "Zoom"
• "Weekly Review | John Smith | Microsoft Teams" → "Microsoft Teams"
• "meet.google.com/abc-defg-hij" → "Google Chrome"

The app functions normally. You see the full title on your local display. Any process querying window titles — scrapers, task managers, whatever — gets only the sanitized version.

Beyond titles, we also sanitize:

• Process names — genericized so scrapers can't fingerprint which conferencing app is running
• Window class names — masked to prevent app identification
• Taskbar tooltips — suppressed to prevent hover-based extraction
• Alt+Tab previews — cloaked windows excluded from switcher thumbnails

The rules are persistent. Set them once, they apply automatically when the app launches, survive reboots, and can be time-based or profile-based. We detailed the full workflow in our guide to hiding apps without breaking your workflow.

For Teams and Organizations

If you're handling sensitive meetings, this matters more.

Policy deployment through MDM pushes NoCapture rules to all corporate devices. Pre-configured masks for Zoom, Teams, Meet, Slack, Discord. Audit logging tracks which rules are active.

Per-role configs make sense because different roles leak different things:

• Executives: maximum masking — everything genericized during meetings
• Sales: client call profiles — mask internal tools, keep presentation apps visible
• Engineering: standup profiles — mask internal repos, keep code editors visible
• HR: interview profiles — mask internal systems, keep video app visible

Compliance integration ensures recording notifications stay visible to participants, data minimization logs demonstrate only necessary metadata is exposed, and incident response can tighten rules in real-time if a scraper is detected.

The Actual Bottom Line

AI scrapers learned that the easiest way to surveil a meeting is to never join it. Window titles provide a continuous, structured, real-time feed of meeting intelligence that's invisible to network security tools and completely outside the scope of meeting passwords, waiting rooms, and end-to-end encryption.

The defense isn't more meeting security. It's less metadata exposure. When your conferencing app can't reveal what you're discussing, who you're meeting with, or what you're sharing, scrapers lose their most valuable data source.

Your meeting content might be encrypted. Your meeting metadata probably isn't. NoCapture fixes that at the source — not by changing how you meet, but by changing what the OS allows other processes to see.

---

NoCapture masks window titles, process names, and application metadata for Zoom, Teams, Meet, Slack, Discord, and 50+ other applications. Set rules once. Every meeting is protected automatically.