Big Tech's Race to Patent AI Agents That Act, and what it reveals
This watchlist tracks filings on AI agents that plan actions, control apps, parse tool calls, read images, remember past chats, listen to ambient sound, and get checked by privacy and compliance guardrails. Together they show Big Tech building assistants that act on your behalf while also policing what those agents see, hear, and do.
141 filings
· tracking since May 2026 · latest Sep 2026 · updates weekly
based on all tracked filings in this watchlist · refreshes every week
This fight is over who gets to act on your behalf, reading your screen, attending your meetings, making calls, running errands, and completing tasks without you lifting a finger. The core question is how much of your daily life an AI agent can take over before you even ask.
Google and Salesforce carry the most weight here, with Google spreading across robots, phones, and everyday tasks, while Salesforce focuses tightly on building agents that run customer service and work workflows on their own.
What’s new in AI agents that act for you
a dated entry each week this watchlist moves · older entries stay archived
Sep 17, 2026 20 filings joined
Most new filings show AI that spots a problem and fixes it without waiting to be asked. Nvidia and Google lead this week, covering everything from server failures to buggy games to slow websites.
This week's filings center on AI that listens, understands, and acts on your behalf across devices and apps. Salesforce and Google each filed twice, covering voice tasks, live data, and spoken number recognition.
This week's filings are heavily focused on AI that watches what you're doing and acts on your behalf, from attending meetings to writing your journal to fixing code. Microsoft and Google each brought in multiple filings, covering everything from slide presenting to screen reading to software that reviews its own work.
Aug 27, 2026 9 filings joined
Most of this week's filings come from Microsoft, covering AI that guides people through buildings, writes chart code, and lets plain words control network servers. The broader theme is AI that takes actions on your behalf, from reading your screen to calling outside tools.
Aug 20, 2026 6 filings joined
This week's filings show AI agents getting better at picking up skills, sharing memory with each other, and understanding the world around them through sound and conversation. Samsung and Microsoft are the most active, with Samsung filing two patents and Microsoft exploring an AI that learns by watching a person work.
Who’s filing patents in AI agents that act for you
counts from tracked filings · focus read from each company’s own filings
The battlegrounds inside AI agents that act for you
the fights inside the fight · each with its three newest filings · new filings join every week
Agents That Control Your Screen 20 filings
Google 10, Samsung 4, Apple 3
Several companies are filing patents on AI that watches what is on your screen and takes action without you clicking anything. Google, Samsung, Apple, and AMD are all working on versions of this.
Google and Amazon are filing patents on ways for physical robots and drones to take orders written or spoken in everyday language, then act on them in the real world. Nvidia is doing the same for factory machines.
Salesforce and Amazon are filing patents on systems that read old customer calls, chat logs, and support tickets to build new AI helpers automatically, so humans do not have to program them from scratch.
Agents That Check Themselves Before Acting 25 filings
Salesforce 6, Sony 3, Nvidia 3
IBM, Salesforce, Google, and OpenAI are filing patents on AI that pauses to review its own plan, flag mistakes, or ask a safety question before it does anything. The goal is to stop the agent from doing something wrong on its own.
Google, OpenAI, Apple, and Salesforce are filing patents on systems where a single instruction from a user kicks off a whole series of steps across different apps or services without the user doing anything else.
Voice and Words Turned Into Working Code 14 filings
Nvidia 3, Google 3, Microsoft 3
IBM, Microsoft, Samsung, and Google are filing patents on systems that turn plain spoken or written requests directly into software commands or code that a computer can run right away.
The filing shows how built-in automation scripts let AI agents execute app tasks directly, bypassing the fragile visual parsing that currently fails on uncooperative interfaces.
Natural language input bypasses the manual configuration step in workflow builders, letting non-technical users compose multi-step automations without learning the underlying tool's interface or logic syntax.
Continuous network monitoring replaces manual detection by maintaining a dynamic baseline of normal traffic patterns, letting AI catch degradation before it triggers traditional alerts or user-facing failures.
A unified input manager intercepts agent queries and routes them to whatever interface the user is actively using, eliminating the fragmentation that occurs when different agents are built for different apps.
AI agents that act for you already track how systems spot failures; this filing adds real-time code generation that evolves as engineers collaborate, turning static diagnostics into adaptive fixes.
Automated feedback loop: the system monitors visitor behavior, identifies underperforming elements, and generates revised copy without manual intervention, extending agent autonomy into content optimization.
Agents could auto-retrieve one-time codes from email without user intervention, removing a manual context switch that currently creates typing errors and security gaps.
Agents currently rely on preset task sequences; Nvidia's system lets them dynamically order and chain their own tool calls based on what each step produces.
Natural-language input triggers automated schema detection and data retrieval, letting planners revise resource allocations without manual reconfiguration. Moves agent task-planning from rigid templates toward fluid interpretation of user intent.
Parsing commitments from spoken language and assigning owners automatically moves agents from passive note-taking toward active task delegation based on conversational intent.
If an agent can verify its own diagnosis before acting, it removes the delay between spotting a problem and fixing it. IBM's filing shows how to wire that verification loop into the agent itself.
Sony is patenting a system where a remote AI server watches for device problems, writes its own diagnostic software on the spot, and pushes fixes to your gadget automatically, no service call, no support ticket, no manual update required.
As agents move from planning actions to monitoring outcomes, this adds automated quality assurance: AI that watches execution and reports failures without human review cycles.
Automated parsing of vulnerability disclosures into device-scanning rules eliminates the manual translation step that currently delays patch assessment across fleets, letting the AI agent run checks before security teams finish reading the advisory.
AI agents that act for you have mostly focused on software tasks, this filing extends the pattern to physical gaming, where the agent learns a player's constraints and compensates in real time.
The agent's action-planning problem expands beyond *what* to do: IBM adds a gate that evaluates whether speaking up serves the conversation's actual flow, filtering out responses that would disrupt timing or add noise to group settings.
Previous filings tracked how agents parse voice commands and control apps; this one adds a feedback loop where the agent learns from your immediate reactions, closing the wrong app becomes training data rather than a dead end.
Camera-first object recognition resolves ambiguity when voice commands reference multiple devices in a room, letting the agent identify which lamp or speaker you mean before executing the action.
Agents that see photos could walk users through troubleshooting without asking clarifying questions, bridging the gap between what image models understand and what conversational AI can act on.
Generating diagnostic code on demand sidesteps the need for developers to hand-write profiling scripts, addressing the expertise and time cost that currently blocks performance debugging.
Spelling out your account number to a phone bot, letter by letter, is one of the more frustrating parts of modern life. Google's new patent describes a voice AI that figures out those codes on its own, asking targeted follow-up questions only when it's genuinely unsure.
Managing split-screen layout when multiple apps run simultaneously requires the agent to parse context about user intent and available screen space, then execute window positioning commands without manual intervention.
Inferring user intent from context rather than literal requests. Microsoft's system researches user history and preferences before acting on vague commands, reducing the gap between stated and actual wants.
For agents to act reliably on real business state, they need current data from live systems, not cached or assumed information. Salesforce's filing puts a retrieval step before execution, ensuring agents ground decisions in actual account and customer records.
Voice agents that search multiple apps in parallel can find content faster than sequential queries, removing a friction point where users currently switch apps manually or abandon searches.
When someone walks into your home and the lights dim or the locks click, who tells them why? A new Apple patent describes a system that does exactly that, adjusting its explanation based on who just walked in.
Most AI systems lock in their priorities at training time and can't change course when things go wrong. Sony's new patent describes an agent that spots trouble ahead and shifts its own internal priorities to avoid it, all without being retrained.
A context-aware menu that materializes after screenshot capture and proposes task-specific actions based on image content. This advances the guard-rail problem by letting the system read and interpret visual data before handing control to external apps.
Agents that join meetings as proxies and filter incoming information to user-relevant summaries rather than full transcripts, narrowing what gets escalated back to the person who couldn't attend.
Device memory mining to auto-generate journal entries sidesteps the writing friction that blocks personal record-keeping, letting the agent infer what matters from existing data rather than requiring explicit user input or real-time capture.
Drawing a box around screen content triggers app suggestions and auto-fills message text, collapsing the friction between spotting something and sharing it across apps.
Where agents need to mimic specific human behavior: Sony's system learns individual play patterns to generate a replacement bot that preserves a departed player's strategy and role rather than defaulting to generic AI.
After agents that parse tool calls and control apps, this one pushes into real-time execution: an AI that reads a full slide deck, speaks it aloud, and responds live to audience questions without human intervention.
Where agents need to reason about human feedback: Google's system closes the gap between code generation and deployment by predicting reviewer objections and auto-fixing them in sequence.
Voice agents currently struggle with false triggers and wrong-context commands. Apple's approach filters which commands matter by analyzing on-screen content first, reducing misheard actions when multiple apps compete for attention.
Parsing natural language into network commands eliminates the translation gap between what engineers know and what telecom infrastructure requires, reducing command errors that currently cascade through system clusters.
Tool routing without manual mapping: OpenAI describes an AI that infers when to invoke external applications and selects the appropriate one autonomously, eliminating hardcoded tool bindings that currently require developer setup for each new integration.
Verifying robot actions before deployment requires simulating missions in digital space. Microsoft's system lets AI agents and humans co-review a virtual run-through to catch failures before real-world execution.
If agents can parse what you're looking at on screen, they gain a direct channel to trigger actions across your devices without explicit commands. Samsung's filing shows how visual recognition becomes the bridge between passive viewing and active control.
Detecting when a meeting needs someone who isn't there: Microsoft's agent monitors conversation flow to identify gaps in expertise and summons the right person in real time rather than waiting for async catch-up.
Computer vision from camera feeds requires pre-labeled building maps to localize users indoors, replacing GPS where it fails underground or behind walls.
Automating data transformation code generation removes the manual wrangling step that currently consumes most analyst time between raw data and visualization.
Agents that synthesize information from multiple sources gain a concrete method for extracting comparable attributes and generating summaries without user intervention.
Samsung is exploring a device that listens to a conversation in real time, figures out the topic and emotional tone, and automatically generates images that capture what the speakers are talking about and how they feel.
When you switch from one task to another mid-conversation with an AI assistant, it often forgets what you were just talking about. Meta has filed a patent for a system that carefully hands off only the relevant pieces of a conversation to each AI agent that needs them.
Translating natural language queries into database commands and then converting results back into readable summaries keeps the analyst in the loop rather than hiding execution behind opaque outputs.
Microsoft wants to turn a single recorded walkthrough into an on-demand AI tutor, so the next person tackling the same task can ask questions and get answers pulled directly from that footage.
Filtering commands by correlating voice input with simultaneous sensor events lets the system reject stray utterances that lack matching physical context, reducing false activations that plague current wake-word-only detection.
Ambient sound parsing feeds back into the agent's decision-making loop: the system listens to real-world announcements, reconstructs garbled audio, and surfaces clarified information the agent needs to act on your behalf.
Connecting natural language to physical actions requires robots to parse what they see and map it to executable moves. Google's filing shows how vision and instruction-following can work together without pre-coded task sequences.
Agents that can't access app APIs need another way to understand what's happening. AMD's approach embeds screen-reading and state-inference directly in hardware, letting an agent parse the visual interface itself instead of relying on exposed controls.
An AI agent that can initiate outbound calls and sustain two-way conversations without human intervention fills a major gap: agents so far mostly react to incoming requests rather than proactively reconnect on your behalf.
AI agents need to orchestrate multiple specialized tools without human handoff. This filing shows how one agent can parse a request, route text to a writer, images to a searcher, and data to a chart tool, then stitch results into a single output.
Agents could learn new tasks from text alone, eliminating the need for engineers to hand-code each workflow. This removes a major bottleneck in deploying agents to handle fresh business processes.
Generating multi-part messages from sparse voice input requires the agent to infer context and structure, not just fill templates. Google's approach chains request parsing to template selection to dynamic content generation.
Agents need a way to accept human input without executing it blindly. This filing shows the drone validating commands from a remote operator before acting, moving the safety check into the agent itself rather than relying on external compliance systems.
AI agents that must choose among thousands of actions need a way to narrow them down fast. Google's patent shows how to rank candidate moves sequentially rather than all at once, letting the agent eliminate bad options before committing to execute.
An agent that converts spoken requests into tool sequences and visual outputs, then loops feedback back through speech rather than clicking menus, narrows how much friction sits between intent and iteration.
Users could ask agents questions that require digging through their own document collections, moving beyond what the model memorized during training. This patents the search mechanism that lets agents retrieve from personal file stores rather than guessing.
Training agents on actual support transcripts lets them learn task sequences and decision patterns without manual programming, building capability directly from how your team already solved problems.
Home robots need to know where stuff actually is, not just where they last saw it. Amazon's filing adds spatial memory that tracks object locations over time, so agents can complete real-world fetch tasks without constant human correction.
Where agents need to handle unfamiliar queries, this filing shows how one might generate custom code rather than fail or guess. The system asks clarifying questions first, then writes tools to retrieve missing data when standard responses won't work.
The watchlist has shown agents needing privacy guards and compliance checks. This filing moves upstream: it focuses on how non-technical users specify what an agent should do in the first place, using conversational questioning to replace manual configuration.
Feeding sales data directly into promotion generation lets agents skip human copywriting entirely, moving the AI's role from suggesting fixes to executing the full marketing loop without intermediate approval steps.
Mapping natural language queries to specialized database schemas lets agents retrieve scientific data without training on domain-specific formats, extending their reach beyond what they memorized.
Agents need a common interface to coordinate across multiple tools. Google's filing shows how one assistant translates requests into calls each tool understands, solving the routing problem at scale.
User-defined action constraints let AI agents operate within preset boundaries during gameplay, addressing how to keep human control over which game decisions the agent can execute versus which require human judgment.
Intercepting agent tool calls before execution lets the system reject malicious or off-task actions in real time, moving compliance from audit-after-the-fact to preventive gatekeeping.
Where agents need to infer what users actually need: this filing shows how to build that inference layer by monitoring ongoing work context (meetings, emails, habits) and ranking suggested actions rather than waiting for explicit requests.
Generating executable code from text descriptions lets agents skip the syntax barrier and accept tasks written in everyday language, moving the translation burden from user to system.
Routing natural language questions to specialized agents lets factories query sensor data and failure predictions as a single conversational turn, collapsing what now requires manual log review and expert consultation.
Training AI agents on other players' behavioral data instead of the user's own creates a privacy buffer while solving the cold-start problem for new game situations an individual player hasn't yet encountered.
Within the planning layer, this filing adds a training mechanism: agents learn to simulate action chains in compressed space before committing to real moves, reducing costly trial-and-error in live environments.
Within CRM software itself, this shows how to let non-engineers assemble agents that modify data without human approval, shifting control from IT gatekeepers to business users.
If agents can schedule their own actions without leaving the chat window, users stop needing external automation tools for recurring tasks. This filing shows how to keep agents inside the conversation layer while they manage time-based work.
Autonomous scheduling and task execution without human intervention in each step addresses how agents move from reactive answering to proactive delegation across calendar, messaging, and note systems.
An agent that lets you seize control mid-action keeps humans in the loop without forcing them to restart. This solves the trust problem where you need to verify or correct the agent's decisions in real time.
An AI agent managing a second game in parallel tests whether agents can operate multiple autonomous tasks without losing state, a core requirement for agents that juggle real-world applications simultaneously.
Agents that learn factory behavior in simulation before controlling physical robots gain a safer testing ground for multi-step action sequences without real-world consequences.
Agents need to convert vague time language into calendar dates to execute delayed tasks reliably. This filing shows how to bridge that gap so instructions like "remind me after the holidays" become actionable scheduling commands instead of lost context.
Ambient voice input requires the agent to extract task intent and pull relevant context from the device without explicit user framing, which this filing shows as automatic collection and routing to the language model.
Flowchart-to-agent conversion lets business process diagrams run directly as autonomous workflows without developer implementation, compressing the path from process design to deployed agent.
An agent that can route you directly to content buried in an app removes friction from the handoff problem, when links fail to pierce through to their intended destination and force manual navigation instead.
The watchlist has focused on agents that parse tool calls and read images; this filing shows the agent deciding which tools to invoke based on visual input and learned user patterns, automating the decision layer that sits between perception and action.
Sequencing data operations automatically sidesteps the need for users to know statistical methods or tool syntax. The system maps dependencies between steps, then executes them in order while validating intermediate results.
Parsing map images as structured spatial data lets the agent build itineraries by understanding actual geography rather than collating web results, solving how to ground travel planning in visual layout instead of text.
Parsing user intent against site structure lets the agent bypass dark patterns by building a direct execution path, confirming the need for adversarial site navigation in the agent stack.
Coordinating actions across multiple apps requires Siri to parse which tool calls succeeded and failed, then report back on outcomes rather than leaving users guessing whether each handoff actually executed.
Ambient monitoring moves from passive observation to active prediction: the agent watches object trajectories and alerts you to hazards before your attention catches them.
Apps pre-register their executable actions with Google Search, letting the system invoke commands directly rather than routing users through links and app navigation layers.
Listening to spoken references during calls and auto-fetching the mentioned documents cuts the manual steps agents currently need to take when retrieving files on behalf of users.
Agents need to route requests across multiple services without human code. Nvidia's filing shows how to parse a plain-English query and map it to the right cloud API automatically.
Where agents need human judgment: Tesla's system moves the diagnostic filter upstream, letting the car decide what's worth reporting to service before a human ever enters the loop.
Your AI assistant can understand "check my flight" but can't phone the airline. Amazon's patent solves the translation layer that converts that intent into an actual API call.
Right now, when one app wants to talk to another, a developer has to write exact, unforgiving instructions in a specific format. Google is patenting a system that lets apps just describe what they want, and an AI figures out the rest.
Within the agent planning layer, this filing shows how to generate complete task maps upfront rather than step-by-step. The action graph approach lets agents evaluate alternative paths before committing to actions, reducing errors when controlling apps.
The watchlist tracks how agents parse tool calls and control apps. This filing shows agents can now synthesize UI components by reading plain requests, then assemble live data feeds into custom layouts without pre-built templates.
Ambient sound capture in group settings confirms the watchlist's direction toward agents that monitor multiple concurrent speakers rather than wait for explicit user queries to trigger searches.
Config files let non-programmers define when AI agents should run and what they should do with results, removing the coding barrier between user intent and multi-step automation workflows.
Where agents need to parse what's happening on screen in real time, Samsung adds automatic object recognition in video frames. This lets an agent watching ambient content identify search targets without waiting for explicit descriptions from the user.
The timeline so far shows AI agents moving from understanding requests to executing them. This filing shows they first need to extract the actual request from messy human communication, parsing intent before an agent can act on it.
Getting an AI to search through fragmented customer history across multiple channels and formats solves a basic blocker: agents can't act on incomplete context. Without this assembly work automated, AI stays locked out of real customer service decisions.
The watchlist needs agents that extract consensus from group chats and execute the resulting decisions. This filing shows how to parse multi-party conversations for agreement signals, then route actions to the right apps.
Where agents need guardrails before executing: Samsung maps preconditions like device state and data availability upfront, catching dead-end requests before the assistant wastes cycles trying to fulfill them.
When autonomous vehicles hit edge cases, the filing shows AI chat systems as an alternative to human remote operators, letting the car query for guidance and keep moving rather than freeze.
Robots need to run basic navigation constantly while swapping in specialized skills for specific tasks. Amazon's approach layers a fixed movement controller under interchangeable task modules, so a robot can grab objects without forgetting how to walk.
Mining past support chats to auto-generate task workflows cuts the manual labor of coding agent instructions, letting the system learn execution patterns from what actually worked before.
Within the agents watchlist, this filing shows how to collapse multi-step workflows into a single input stream, pointing and speaking at once so the AI can bind what you see to what you want, then route to the right app without intermediate steps.
A deliberately error-prone AI trains a second AI to spot mistakes before output reaches users, solving the confidence problem where agents deliver plausible-sounding wrong information in enterprise workflows.
Your support agent gets a ready-made action plan instead of searching docs or guessing. The real gain: the AI marks which steps it invented versus which came straight from company policy, so agents can spot and fix bad suggestions before executing them.
Where agents improvise solutions, this filing shows AI generating a structured resolution plan upfront. Moves the assistant from reactive helper to planner that sketches the path before human hands touch the case.
Keeping AI assistants from inventing answers requires training them to spot unanswerable questions before they confabulate. Salesforce's system flags gaps in available data so agents can defer to humans instead of acting on made-up information.
Running multiple competing viewpoints through one model before committing to action reduces the risk that an AI agent will execute flawed plans, a key requirement if these systems are meant to autonomously handle real customer problems.
Your AI agent could complete multi-app workflows without human inspection, since the system catches its own connection errors before data flows break things downstream.
Predicting speech intent from ambient sound alone removes the need for wake words, letting agents respond to natural conversation without explicit activation signals.
Getting an AI to reliably identify and interact with UI elements across different apps requires mapping what's clickable on screen in real time, which this patent addresses through numbered annotation.
Automatically executing actions tied to message replies collapses the gap between composing a response and acting on its implications, letting AI infer and perform the logical next steps without separate user commands.
Your support agent gets answers surfaced while the customer is still typing, cutting the search-and-paste step entirely. That shrinks the gap between understanding what someone needs and acting on it.
Your agent needs to know which buttons to click and which fields to fill on unfamiliar websites. Google's approach lets the browser itself figure out what's clickable and what matters, so you don't have to pre-teach it every site you visit.
Where agents need to move from understanding requests to executing them, this filing solves the mechanical problem of translating natural language commands into specific app interactions by having the AI visually parse and sequentially navigate UI elements.
Users can't act on AI recommendations without knowing the reasoning behind them. This filing proposes making that reasoning visible in plain language so people can verify whether the AI actually understood their situation correctly.
Real-time tone shifts based on conversational cues let agents match user state without explicit commands, moving assistants from static personas toward dynamic responsiveness that reads frustration or impatience and adjusts output accordingly.
Where agents need grounding: this patent solves the reference problem that keeps voice commands generic. An AI that knows what's on screen can act on spoken commands that point to specific objects without requiring users to name them explicitly.
Your agent could infer what you need from overheard conversation and offer ready-made actions, skipping the step where you figure out what app to open or command to give.
A monitoring agent runs parallel to deployed assistants, detecting policy violations in real time and revoking their access to sensitive data or functions before damage occurs. This moves compliance from post-deployment audits into active runtime enforcement.
Your agents can now run unsupervised at scale: Salesforce's system lets a compliance-focused AI monitor and halt other agents in real time, rather than waiting for human audits after decisions are made.
The watchlist so far assumes agents need permission and oversight to act safely. This patent flips that: it stops agents from even receiving sensitive data in the first place, building a filter layer before the agent sees what you said.
Smart speakers currently can't distinguish direct speech from room echoes. Amazon's system maps physical objects in a space, then uses that geometry to filter out reflections and pinpoint where sound actually originated.
Storing conversations as retrievable chunks lets agents reference months of prior context without reloading entire chat histories, making multi-session tasks like trip planning actually continuous rather than perpetually restarted.
When an AI needs to act, it first has to plan what to do. Google's patent makes that planning step visible and trainable, so the system can learn better reasoning before it touches any tool.
A routing layer that separates intent-parsing from execution lets each app-specific agent operate independently, reducing the complexity of building a single AI that knows how to control dozens of different interfaces.
Agents with better judgment about which tasks to attempt reduces failed executions when AI moves from answering questions to actually executing commands on your behalf.
Shared devices need AI that weighs multiple people's needs instead of defaulting to the asker or splitting the difference. Google's patent adds a detection layer that identifies who's present and what they prefer, then adjusts recommendations accordingly.
Questions readers ask
Are these AI agent patents already in products?
Not necessarily. A patent filing describes an invention a company wants to protect, not a shipped feature. Some ideas in this watchlist, like app control layers or ambient listening, may show up in products later, get shelved, or never leave the lab. The filings tell us where engineering effort is going, not what you'll use next year.
Why does Google have so many patents in this AI agent watchlist?
Google files the most patents in this collection, covering intent detection, app control, prompt filtering, tool-call reasoning, image understanding, and memory. That spread suggests Google is building out a full stack for its assistants rather than one feature. It does not mean Google's approach will win, only that its patent output on this topic is currently the densest.
What problems are these patents trying to solve?
The recurring problems are figuring out what a user actually wants, deciding which app or tool to call, keeping a filtered and accurate prompt, recalling past interactions, and reacting to what a camera or microphone picks up. Amazon and Salesforce filings add privacy checks and compliance guardrails on top, since an assistant that acts needs limits on what it can do.
How do guardrail patents fit into this AI agent race?
Salesforce's guardrail patents describe one AI agent watching others for compliance violations and blocking a rogue deployment before it causes harm. Paired with Amazon's privacy monitor for Alexa skills, they show that as assistants gain the ability to act, companies are also patenting ways to supervise and shut down agents that misbehave.
Want this weekly breakdown for a company we don't cover?
Patentlyze Pro →
The weekly email: the best of Big Tech's filings, in plain English. Free.