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.
212 filings
· tracking since May 2026 · latest Nov 2026 · updates weekly
based on all tracked filings in this watchlist · refreshes every week
This fight is over who builds the software layer that lets an AI take real actions on your behalf, whether that means booking appointments, fixing servers, running meetings, or controlling apps.
Google and Salesforce carry the most weight here, with Google leaning into AI that acts across devices and apps and Salesforce pushing AI that reads your work and builds custom agents to handle it.
What’s new in AI agents that act for you
a dated entry each week this watchlist moves · older entries stay archived
Nov 5, 2026 10 filings joined
Microsoft leads this week with four filings, mostly around AI that builds, fixes, and manages apps on your behalf. Google and Samsung also filed, focusing on assistants that handle calls, messages, and phone tasks without you lifting a finger.
This week's filings focus on AI that understands plain speech and acts on your behalf across devices, apps, and smart home tools. Google and Microsoft each added two filings, covering everything from robot dogs to website navigation.
This week's filings center on AI that takes action on your behalf, from building apps to running searches to coaching workers. Google and Adobe each added two filings, with Microsoft also filing twice.
Google leads this week with five filings covering robots, TV control, app shortcuts, news analysis, and plain-English robot commands. Samsung and Apple add home repair and phone-answering agents, pushing the week firmly toward AI that takes actions on your behalf.
Google leads this week with five filings covering voice commands, photo research, and step-by-step planning. Microsoft adds three filings focused on reading the screen to help users, while IBM and Sony each filed one.
Microsoft leads this week with six filings covering security, meeting help, screen reading, and building AI workers from plain instructions. The overall push is toward AI that takes action on your behalf without you having to ask or code anything.
Google leads this week with six filings covering AI that reads your screen, listens around you, and acts before you ask. The common thread: AI that watches what you do and steps in on your behalf.
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
These filings cover ways for physical robots, drones and factory machines to take orders written or spoken in everyday language, then act on them in the real world.
These filings describe 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 41 filings
Microsoft 9, Salesforce 7, Samsung 4
These filings cover 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.
These filings cover 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.
Runtime diagnostics that let an AI agent trace failures across multiple services without manual log parsing confirms the guard-rail need: agents must validate their own tool calls and understand cross-system dependencies before acting.
Moves the agent from app control into voice calls: the system screens incoming calls, transcribes the conversation in real time, and presents you with tap-selectable responses instead of requiring you to speak.
Agent planning gets a staged checkpoint: Microsoft's AI breaks app creation into sequential steps with human approval gates, rather than generating full code at once.
Prior filings showed agents need to parse tool calls and control apps; this one adds voice synthesis that adapts tone based on conversation length, so the agent sounds increasingly assertive as it navigates customer service on your behalf.
An AI agent with its dedicated email identity can filter and respond to incoming messages without human review, using a self-description you provide to decide what it answers versus forwards to you.
Runtime app capability discovery lets the assistant match spoken requests to whatever functions apps expose, rather than relying on pre-built integrations for each command-app pair.
When training web-using agents, noisy examples drag down performance. Salesforce proposes filtering bad demonstrations during training so agents learn from successful attempts only, reducing reliance on costly expert data.
AI assistants that discover and catalog available tools automatically rather than relying on developer-configured registries could expand what helper apps get integrated into agent workflows without requiring setup work for each new tool.
A digital ID directory that includes robots and AI agents alongside human workers lets coordinators assign specific permissions to each participant, whether software or hardware, based on their role in a shared operation.
Screen reading and button mapping let voice commands reach legacy apps that lack native voice interfaces, filling the gap where developers never built that support in.
Grounding vague commands in context: the patent shows how an agent interprets loose requests like "make it comfortable" by consulting weather data and user history before executing home controls, rather than requiring preset rules for each device.
Tool gaps force most AI agents into loops or surrender. Adobe's filing describes an agent that generates missing functions on demand, expanding its own capability set when predefined tools won't solve the task.
Coordinating tool calls across virtual worlds: IBM's approach lets a purchase decision in one environment trigger a loan advisor to appear in another without the user leaving or re-authenticating.
AI agents need to know which tools actually exist before parsing a vague request into code. IBM's filing adds a pre-step that feeds the agent your real tool inventory, cutting down guesswork on what commands are available.
If your voice command names an app, the assistant uses it; otherwise it defaults to what's on screen or picks a fallback. That solves the routing problem when multiple apps could handle the same task.
If an agent can read plain labels instead of parsing pixels, it moves faster and costs less per action, making delegated tasks more practical at scale.
Building custom home automation rules through visual menu selection reduces friction for users who need conditional logic beyond preset options. The patent emphasizes testing rules before activation, lowering the risk of unintended device behavior.
Knowing what wearables you already have on, the AI recommends which connected devices to add based on your scheduled activity. Extends the agent's ability to parse physical state and optimize tool selection.
Reducing computational cost of web navigation. Instead of screenshot-and-query cycles, pre-built site maps let agents know button locations upfront, cutting the back-and-forth with large language models that currently runs on every step.
If an agent can't write raw motor commands, a scorecard layer lets the robot itself interpret what "stand on two feet" means. Solves the mismatch between language models and robot-specific hardware.
Within the guard-checking layer: Microsoft proposes letting security teams pose plain-English questions across multiple databases without learning each system's query syntax, reducing the friction when analysts need to hunt for breach evidence fast.
Exposing intermediate reasoning steps in real time lets users distinguish between a frozen interface and genuine computation, building confidence during long agent workflows that involve image analysis, web search, or code execution.
Prior filings showed agents need to parse which tool fits each request; this one adds a filtering layer that narrows the candidate pool before selection happens, reducing both latency and decision errors in tool routing.
Parsing natural language into executable workflows addresses the app-control layer, with built-in validation against the tool's own constraints rather than generic guardrails.
AI agents building temporary UIs in response to requests plugs a gap in the control-apps segment, converting text answers into interactive screens that disappear after use, rather than forcing users to parse instructions or navigate to external tools.
As agents learn to parse and act on tool calls, Adobe's filing adds a layer for pinpointing document elements by description alone, bridging natural language intent to the specific PDF objects an agent needs to modify.
Extracting component structure from sketches lets an AI generate deployment-ready architecture without hand-coding the wiring between services, moving the planning step upstream from specialist to sketch-to-code pipeline.
Requiring the AI to generate a visual plan, screens, data flows, layout sketches, before code generation lets users spot missing pieces or logic errors upfront instead of debugging after the app is half-built.
Most AI agent patents focus on executing existing tasks; this one attacks the plumbing problem before agents even start, automating the data discovery and preparation that currently consumes hours of manual work for each model build.
Adds real-time guidance during patient intake, using the chart state to prompt next questions and catch inconsistencies, reducing nurse cognitive load and chart gaps.
Computer vision lets the assistant infer context from your environment instead of asking clarifying questions. Reduces the gap between what you request and what you can actually execute.
Computer vision processing identifies content type from screenshots and routes data to matching apps, automating tool selection based on what the phone reads rather than requiring users to pick the right destination.
Automated plan enumeration lets the system generate multiple decomposition strategies and rank them by step count, removing manual optimization work from agents that break complex requests into subtasks.
Agent coordination across app boundaries has relied on manual context-switching; Google's filing proposes learning user sequences to compress multi-app workflows into single actions, reducing friction between tools that handle different steps of one task.
AI agents proposing actions now face reality checks: Google's patent grounds suggestions in what a specific robot can actually perform with its hardware and environment.
Google sketches out how an AI agent could parse news events and model business impact, bridging the research phase where agents need to synthesize external information before acting on company strategy.
Agent planning here moves from tool-calling to code generation: the AI compiles natural language into executable programs rather than selecting from fixed action menus, letting robots handle novel combinations of their capabilities.
As agents move from controlling apps to managing physical devices, Samsung's approach extends action-taking into augmented space, letting users manipulate home appliances through virtual representations without removing their headsets.
Permission gates let the agent act on routine calls without blanket access to your calendar or contacts, keeping scope narrow to pre-approved task types.
If agents can listen for spoken cues and auto-edit raw feeds into watchable clips, users get usable outputs instead of hours of unwatchable footage. This pins down how agents parse ambient audio to decide which moments matter and which to discard.
Most AI agents learn from written instructions or images; this one learns from live demonstrations a human operator performs, then generalizes that physical routine into autonomous control. Shifts the training bottleneck from documentation to observation.
As agents move beyond tool-calling into multi-step research, Google's filing shows how to handle the planning layer: decompose a question into subtopics, query each separately, then synthesize results into a coherent report.
Long-press menus showing voice-activated quick actions let users bypass memorizing assistant syntax and typing while hands are occupied, solving friction points between ambient listening and structured tool use.
Previous agents mostly parse tool calls after taking action; Google's approach grounds the plan in visual context first, then generates human-readable steps that a robot can actually execute.
AI agents need better ways to pick the right tool and execute tasks without exposing credentials. IBM's patent proposes generating custom tools per request instead of choosing from a pre-built library, keeping login details compartmentalized.
Agents need to translate vague user intent into concrete configuration choices. Sony's filing shows how natural language requests map to buried console settings, moving past the assumption that users should navigate menus themselves.
As AI agents move from chat to actually reading web pages, this filing addresses the noise problem: stripping layout markup, ads, and visual formatting so agents parse only semantic content that matters for tool documentation.
Separating screen-reading into a dedicated agent prevents conversation context from getting cluttered when the primary assistant needs to reference open windows or content currently visible to the user.
Within the agent-action watchlist, this shows how vision parsing can drive autonomous testing workflows, the AI reads screen state to choose next moves rather than relying on game API access or predefined scripts.
Where agents need to move past single-shot image analysis: Google's filing shows an AI that treats visual questions as multi-step research tasks, searching and validating answers rather than relying on the model's training data alone.
Where agents need to act without explicit commands, this filing shows how to detect intent from passive user behavior, pausing or hovering, rather than waiting for a user request to trigger the agent's next move.
Within the planning layer: agents now skip the developer entirely and generate multi-step workflows from plain language, moving execution from human-designed pipelines to AI-orchestrated ones.
Within agent coordination, this filing shows how multiple AIs can partition a complex task: one routes security incidents to the right responder, another generates fixes, and a third validates outcomes, all without human intervention to sequence the steps.
Automatic decomposition of user requests into specialized agent roles removes the need for manual workflow design, letting non-technical users orchestrate multi-step AI operations through conversation alone.
As agents move from single-turn tasks to multi-turn customer conversations, this filing shows how to generate training data automatically instead of hiring humans to script thousands of examples by hand.
Self-evaluation between action steps lets the AI adjust its plan mid-execution rather than committing to a full sequence upfront, useful when robots encounter unexpected physical states that deviate from initial assumptions.
After early AI agents that execute explicit commands, Sony adds inference: a companion that learns your playstyle from observation alone, eliminating manual tuning between sessions.
Within the agent-control pipeline, this covers the parsing step: converting unstructured threat text into executable network commands without human intermediation.
Moves from reactive note-taking to proactive meeting control: the agent now plans structure, moderates conversation, and synthesizes outcomes without human intervention at each step.
Predicting task duration before execution lets agents communicate expected wait times upfront, addressing the silence problem when multi-step actions need backend processing or tool calls.
After tools and image parsing, the focus shifts to multi-step task execution: AI that sees your screen state, decides what action comes next, and loops until completion without human intervention between steps.
Continuous image monitoring lets the assistant watch a live camera feed and trigger capture when conditions match a user's spoken instruction, pushing real-time visual parsing into the agent's decision loop.
Agents coordinate across system monitoring, log analysis, and deployment history to diagnose failures without human intervention, filling the gap between detection and root cause.
Where agents need to bootstrap research without human query formulation, Google's filing shows how to auto-generate clarifying questions and locate source documents, moving agents from answering known queries to independently scoping unfamiliar domains.
Splitting routine actions from ones that need approval lets the phone learn which decisions it can make alone. Samsung's system watches habit patterns to shrink the number of permission requests, freeing compliance checks for genuinely novel or risky moves.
Ambient audio detection feeds search suggestions directly into the query box, letting agents infer user intent from background sound rather than waiting for explicit commands or typed queries.
Pre-staging action recommendations from conversational context lets the assistant move faster than explicit user requests, reducing the round-trip delay that normally separates intent detection from execution.
Agent infers user intent from input examples rather than explicit instructions, reducing the command parsing burden when directing spreadsheet operations through a tool.
Agent monitors emails and web pages to extract purchase details and compare prices, extending the toolset for real-time deal detection across communication channels.
As agents move beyond executing discrete tasks, this filing covers detecting when an unstructured group problem needs active facilitation and automating the session structure itself.
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.
Salesforce's filing helps people with no coding background tell an AI agent what to do, by asking them questions instead of making them fill in settings.
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.
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.
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.
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.
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.
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.