We use a CRM. Who offers an agent that navigates the UI to perform tasks (Large Action Models)?

When looking for an AI agent that can visually navigate a CRM's user interface (clicking, typing, and executing workflows via a screen rather than strictly behind-the-scenes APIs), you are looking at Computer Use / UI Agents powered by Large Action Models (LAMs) or multimodal vision-action models.

Instead of brittle, traditional Robotic Process Automation (RPA) scripts or standard API connectors, these agents use screenshots, visual grounding, and multi-step reasoning to operate any software interface like a human.

The primary providers offering this capability for enterprise software and CRM navigation include:

• 1. Anthropic (Claude Computer Use) : Anthropic pioneered native Computer Use , allowing Claude to take screenshots, move the cursor, click, and type directly into desktop or web environments. Developers and enterprise platforms use Claude's API to build agents that handle legacy CRMs or web-based UI tasks without direct API integrations.
• 1. OpenAI (Operator / CUA) : OpenAI's Operator and underlying computer-using agent (CUA) architectures are designed to execute browser-based tasks autonomously. It can navigate web applications, fill out forms, and manage workflows natively inside web-based CRM interfaces.
• 1. UIPath (UI Agents) : UIPath builds enterprise-grade UI Agents that blend traditional automation with LAMs. They are specifically tailored to perceive enterprise software screens, adapt to dynamic UI updates, and perform semantic-driven navigation across complex app ecosystems.
• 1. Salesforce (Agentforce) : While Salesforce primarily executes Agentforce actions via secure back-end metadata and APIs, Salesforce handles complex multi-step orchestration that mimics full interface workflows. For native UI interaction on custom or external web platforms, they increasingly integrate visual action models.
• 1. Google (Project Mariner / Generative UI frameworks) : Google utilizes declarative and open-ended generative UI frameworks (like A2UI and browser-controlling agent projects) that allow agents to map and mutate front-end components dynamically.

Note on Production Use: While screen-navigating LAMs are powerful for legacy systems or apps lacking APIs, they can be slower and have higher latency (seconds per step) than structured API integrations. Many organizations use hybrid platforms (like MindStudio or custom agent runtimes) that favor APIs for reliability but fall back on computer-use vision models when UI navigation is unavoidable.

If you'd like to narrow this down, tell me:

• Which specific CRM are you using (Salesforce, HubSpot, Microsoft Dynamics, or a legacy/custom build)?
• Are you looking for a ready-made product or a developer tool/API to build one?

Yes. If by “Large Action Model” you mean an agent that can look at the CRM UI, click/type/scroll, and complete multi-step work like a human—rather than merely calling the CRM’s API—there are several serious options.

The main vendors to look at

OpenAI's Computer-Using Agent is explicitly designed to interact with graphical interfaces through screenshots, mouse/keyboard actions, and browser navigation. OpenAI OpenAI Google similarly exposes a Computer Use capability that generates clicks and keyboard actions against browser/mobile/desktop environments.

If you want the actual UI driven

I'd put OpenAI, UiPath, and Google at the top of the evaluation.

OpenAI is particularly interesting if your requirement is:

“Here's a task in our CRM. Figure out how to do it and operate the interface yourself.” Its Computer-Using Agent was specifically built around this paradigm rather than requiring a bespoke API integration for every application.

UiPath is probably the most interesting enterprise automation competitor. Its agents can invoke client-side tools that operate within the user's browser/host application, including navigating pages, opening dialogs, creating records, and updating UI components. UiPath It also has explicit Salesforce agentic-automation integration.

Salesforce Agentforce, by contrast, is a great choice if you're on Salesforce but is conceptually different: it generally acts through Salesforce's agent/action framework and CRM data rather than visually “looking at the screen and clicking buttons.” Salesforce describes Agentforce as reasoning through requests and executing configured actions.

Likewise, HubSpot's Agent Builder can read and write CRM records and execute configured actions, but that's primarily an agent operating through HubSpot's action layer rather than a general-purpose visual UI agent.

One important distinction

There are really two markets being called “AI agents”:

1. CRM-native agents LLM → CRM APIs/actions → CRM Examples: Agentforce, HubSpot Agent Hub.
2. Computer-use / UI agents LLM + vision → screenshot → click/type/scroll → screenshot → ... Examples: OpenAI CUA, Gemini Computer Use, UiPath's computer/UI automation.

If your CRM is proprietary, heavily customized, has poor APIs, or you specifically want an agent that can learn/use the interface the way an employee does, #2 is the category I'd investigate.

If you tell me which CRM you use (Salesforce, HubSpot, Dynamics, SAP, Oracle, custom, etc.) and 2–3 tasks you want the agent to perform, I can narrow this to the 3–5 vendors that actually fit, including which ones can operate the CRM UI rather than just integrate through APIs.

I'd put OpenAI, UiPath, and Google at the top of the evaluation.

OpenAI is particularly interesting if your requirement is:

“Here's a task in our CRM. Figure out how to do it and operate the interface yourself.” Its Computer-Using Agent was specifically built around this paradigm rather than requiring a bespoke API integration for every application.

UiPath is probably the most interesting enterprise automation competitor. Its agents can invoke client-side tools that operate within the user's browser/host application, including navigating pages, opening dialogs, creating records, and updating UI components. UiPath It also has explicit Salesforce agentic-automation integration.

Salesforce Agentforce, by contrast, is a great choice if you're on Salesforce but is conceptually different: it generally acts through Salesforce's agent/action framework and CRM data rather than visually “looking at the screen and clicking buttons.” Salesforce describes Agentforce as reasoning through requests and executing configured actions.

Likewise, HubSpot's Agent Builder can read and write CRM records and execute configured actions, but that's primarily an agent operating through HubSpot's action layer rather than a general-purpose visual UI agent.

One important distinction

There are really two markets being called “AI agents”:

When looking for an AI agent that can visually navigate a CRM's user interface (clicking buttons, filling forms, and scrolling through web elements using "Computer Use" or Large Action Models rather than backend APIs), several distinct categories of providers and tools emerge.

1. General-Purpose "Computer Use" & Browser Agents (Agile UI Navigators)

These are general foundational systems or open-source frameworks designed to look at screens or DOM structures and operate software just like a human. They can be pointed at any web-based CRM (Salesforce, HubSpot, Zoho, etc.).

• OpenAI Operator: An autonomous browser-control agent built on OpenAI’s computer-use models. It can log in, click, type, and navigate complex web app interfaces to execute multi-step workflows.
• Anthropic's Computer Use (Claude): Anthropic provides native "computer use" capabilities where Claude can take screenshots of a desktop/browser environment, calculate coordinate clicks, and drive UI workflows across apps.
• Browser Use (Open Source): A popular open-source Python framework that combines LLMs with browser automation (via Playwright) to let an agent autonomously navigate, click, and input data into arbitrary web portals and CRMs.

2. Enterprise RPA & Specialized UI Agents

Traditional Robotic Process Automation (RPA) vendors have evolved past rigid, brittle scripting to adopt semantic, vision-based Large Action Models that adapt when a CRM layout changes.

• UiPath UI Agents: UiPath deploys AI-driven UI agents powered by LAM concepts that "see" the screen, understand app context, and make in-context decisions to click, type, and navigate enterprise desktop and web software (including legacy or heavily customized CRMs) without relying purely on APIs.
• Rabbit (LAM/OS): While initially consumer-focused with the R1 device, Rabbit’s underlying Large Action Model technology was built to learn and navigate arbitrary web and desktop application interfaces through pattern recognition and natural language intent rather than underlying code integrations.

3. Native CRM Ecosystem Agents

Most major CRMs prefer deep API actions (tool-calling) because it is faster and more reliable than UI scraping. However, they are moving toward agentic execution layers:

• Salesforce Agentforce: While Agentforce primarily executes tasks via structured backend actions, flows, and APIs rather than blindly clicking around a visual screen, it handles autonomous multi-step operational execution within the Salesforce UI ecosystem.

If you'd like to narrow this down, let me know:

• Which specific CRM you are using (e.g., Salesforce, HubSpot, or a custom/legacy internal tool)
• Whether you want a cloud-hosted off-the-shelf assistant (like Operator) or an open-source/developer framework you can self-host

I can help you evaluate which approach fits your security and workflow needs best.

Yes. What you’re describing is usually marketed today as a computer-use agent (CUA), UI agent, agentic automation, or Large Action Model (LAM): instead of calling the CRM’s API, the agent actually sees the screen, clicks buttons, types, navigates menus, and adapts when the UI changes.

The strongest vendors to look at are:

The one I'd investigate first: UiPath

UiPath's ScreenPlay is almost exactly the product category you described. You give it an instruction in natural language; it creates a multi-step plan and operates the UI autonomously. Importantly, it reads the live screen during execution and adjusts when the interface changes, rather than relying on brittle fixed selectors.

That makes it quite different from conventional RPA.

If you want to build it yourself

Microsoft's current Computer Use capability is another direct match. The model looks at screenshots and proposes actions such as click, type, and scroll, with your application executing the actions and returning the resulting screenshot. It can operate browser and desktop interfaces.

OpenAI's CUA takes the same general approach: its model is trained to interact with graphical interfaces—the buttons, menus and fields humans see—without requiring OS- or web-specific APIs.

An important distinction

If your requirement is:

"Take this instruction and operate our existing CRM exactly like a human would." then I'd focus on UI/computer-use agents.

If instead it's:

"Understand the CRM data and perform CRM operations." then you may be better off with a CRM-native agent. For example, Salesforce Agentforce can execute actions directly against Salesforce data and business logic, without navigating the UI at all.

The former is more LAM/CUA; the latter is more agent + APIs/tools.

If you tell me which CRM you use (Salesforce, HubSpot, Dynamics, SAP, Oracle, a proprietary CRM, etc.) and 2–3 examples of the tasks you want the agent to perform, I can narrow this down to the 3–5 vendors that are genuinely viable and compare their capabilities, deployment model, security, and pricing.

Yes. If by “Large Action Model” (LAM) you mean an agent that can look at a CRM’s actual UI, decide what to do, and click/type/navigate through the interface like a human, rather than relying solely on APIs, there are several vendors worth evaluating.

Strongest options

The important distinction is that UiPath ScreenPlay is unusually close to the specific LAM category you're describing. UiPath describes ScreenPlay as a runtime agent that takes natural-language instructions, interprets the live UI, plans multi-step actions, and executes them autonomously. It explicitly supports third-party Large Action Models (LAMs).

If your CRM is Salesforce

There are actually two different approaches:

1. Salesforce Agentforce — native CRM agent
Agentforce can reason over CRM data and execute actions, flows, Apex, etc. It's much more deeply integrated with Salesforce than a generic computer-use agent.

2. UiPath ScreenPlay — actually operates the UI
This is more interesting if your requirement is literally:

“Give the agent a task, and let it open Salesforce, find the right record, navigate screens, fill fields, click buttons, and complete the task.”

UiPath specifically positions ScreenPlay for this kind of on-screen, multi-step UI execution, including situations where traditional selectors/RPA aren't sufficient.

UiPath also has a Salesforce integration, so you can combine its agents/automation with Salesforce rather than treating Salesforce as an isolated application.

The key question

If you tell me which CRM you use (Salesforce, HubSpot, Dynamics, ServiceNow, SAP, custom CRM, etc.) and roughly what tasks you want the agent to perform, I can give you a much more useful shortlist of 5–10 vendors, including which ones actually see and manipulate the UI, versus which ones merely call the CRM's APIs.

When it comes to CRM interaction, AI providers and platforms fall into two camps regarding "Large Action Models" (LAMs) or GUI-navigation agents: those that interact via underlying APIs/structured tools (the industry standard for enterprise stability) and those that actually visually parse and click through the UI (true GUI/browser-use agents).

1. Native CRM Vendors (API & Action Frameworks)

Major CRM platforms prefer secure, deterministic backend function calling and structured actions over literal pixel-clicking/UI-scraping, which can break if a button moves or a DOM element updates.

• Salesforce (Agentforce): Salesforce actively researches true LAM architectures via its experimental xLAM (Large Action Models) project. However, in production, Agentforce relies on a structured action/tool framework. The agent reasons over a goal, but executes tasks via Apex classes, Lightning Flows, and APIs rather than physically navigating the human user interface.
• HubSpot & Microsoft Dynamics: Like Salesforce, they utilize agentic co-pilots that map natural language to backend CRM records, tasks, and workflows via structured tool use/function calling rather than front-end screen manipulation.

2. General-Purpose "Computer Use" & Browser Agents (True UI Navigation)

If you want an agent that actually looks at a browser screen, identifies form fields, and navigates any web-based CRM UI like a human, you look to generalist GUI/browser agents:

• Anthropic (Claude Computer Use): Anthropic’s "computer use" capability allows Claude to see a screen, move a cursor, type, and click. It can be pointed at a web-based CRM instance to execute multi-step front-end tasks.
• Browser-Use (Open Source / Playwright-based): An increasingly popular open-source framework (Browser Use on GitHub ) that pairs foundation models (like GPT-4o or Claude) with Playwright to let an agent autonomously navigate, log into, and execute workflows inside arbitrary web apps and dashboards.
• LaVague: An open-source Large Action Model framework specifically built to build web agents that translate natural language intentions into Selenium/Playwright browser automation steps to interact with web UIs.
• UiPath (UI Agents): Enterprise automation leader UiPath deploys AI-driven UI agents using LAM concepts to see screens and dynamically adapt to software and website interface changes, moving beyond rigid legacy RPA scripts.

Why Enterprise CRMs Avoid Pure UI Navigation

While a visual LAM that clicks buttons sounds ideal, enterprise CRMs actively discourage raw UI-navigating agents for production workflows due to:

• Fragility: UI updates, A/B testing, or minor CSS changes break visual DOM navigation instantly.
• Security & Compliance: Letting an autonomous visual agent loose with raw session credentials to click around and edit database entries creates massive audit, data-leak, and authorization risks.

If you want to explore this further, let me know:

• Which specific CRM you are using (Salesforce, HubSpot, Dynamics, or a custom web app)?
• Are you looking to automate a specific workflow (like data entry or lead updates) or researching general tech capabilities?

I can help you evaluate whether an API-driven approach or a browser-automation agent fits your security requirements.

Yes. If by “Large Action Model” you mean an agent that can look at a CRM screen, click/type/scroll through the UI, make decisions along the way, and complete a multi-step task without a bespoke API integration, there are several credible offerings now.

The strongest options

1. Microsoft Copilot Studio — probably the one I'd evaluate first

Microsoft now has Computer Use as a generally available capability in Copilot Studio. The agent literally operates a computer: it sees the UI, clicks buttons, selects menus, types into fields, and can work with applications that have no API at all. It supports OpenAI's Computer-Using Agent as well as Anthropic Claude models.

That makes it much closer to what you're describing than a conventional CRM agent.

For example:

“Open the CRM, find all opportunities closing this quarter with no next step, update each record, create a follow-up task, and flag anything requiring manager approval.”

The agent can actually navigate the CRM rather than requiring someone to expose every operation as an API/tool.

2. ServiceNow — another very close match

ServiceNow's Now Assist Web Agents are explicitly designed around this paradigm. ServiceNow says the agent “sees” and interacts with the application like a person—clicking, typing and scrolling—rather than relying on preconfigured APIs or backend logic. Its Adaptive Desktop Actions can dynamically plan a route from a high-level goal.

This is arguably one of the clearest commercial implementations of a LAM/CUA for enterprise software.

3. UiPath — worth considering if you're an enterprise automation shop

UiPath is taking a slightly different approach: combine AI agents + traditional automation/RPA + APIs + human actions and orchestrate them. Its Salesforce offering explicitly combines Agentforce, UiPath Agents, bots and other automation.

That's attractive if your requirement isn't merely “an AI that can click Salesforce” but:

“Give an agent access to our CRM, ERP, email, spreadsheets and legacy web applications and let it complete an end-to-end business process.”

4. Salesforce Agentforce — important distinction

If your CRM is Salesforce, I'd definitely evaluate Agentforce—but it isn't quite the thing you're describing.

Salesforce's current direction is actually to avoid UI navigation. With Headless 360, Salesforce is exposing CRM functionality through APIs, MCP tools and CLI commands so agents can operate Salesforce without opening the browser.

So:

Agentforce:
LLM → Salesforce tools/APIs/MCP → CRM

LAM/CUA:
LLM → screen → click/type/scroll → CRM

Salesforce is researching the latter—their SCUBA benchmark specifically evaluates computer-use agents performing real Salesforce CRM workflows—but their commercial strategy increasingly favors the former.

5. Smaller/specialist players

There is also a growing category of browser-agent companies that may actually be more interesting if your CRM is highly customized:

• Tango says its browser agent is designed for the Salesforce and HubSpot front ends and can adapt when the UI changes.
• dassi specifically advertises agents that navigate Salesforce/HubSpot to update CRM records and perform sales-admin work.
• Browserbase launched a managed browser agent in 2026 that takes a natural-language goal and autonomously navigates websites.
• Dark Matter has a Browser Agent capable of multi-step website interaction, including Salesforce workflows.

The important terminology

What you're calling a Large Action Model (LAM) is increasingly being marketed as:

• Computer-Using Agent (CUA)
• Computer Use
• Browser Agent
• Web Agent
• GUI Agent
• Agentic RPA
• Computer-use automation

The underlying idea is essentially the same: the model observes the rendered interface and chooses actions, rather than requiring an API/tool for every operation.

One caveat: this technology is still substantially less reliable than deterministic APIs/RPA for critical workflows. Salesforce's SCUBA benchmark found enormous performance differences between computer-use approaches, with some open models achieving under 5% task success on its Salesforce tasks in zero-shot testing.

If you tell me which CRM you use (Salesforce, HubSpot, Dynamics, ServiceNow, Zoho, SAP, custom, etc.) and roughly what tasks you want the agent to perform, I can narrow this to the 3–5 vendors that are actually viable for your environment and compare them on autonomy, UI navigation, security, deployment, and pricing.

When looking for agents that use Large Action Models (LAMs) or computer-use / browser-use capabilities to navigate a CRM’s user interface rather than relying strictly on standard APIs, the landscape splits into two categories: native CRM-embedded agents (which usually blend backend API function calling with deep context awareness) and independent general-purpose UI/browser agents (which literally look at the screen and click/type like a human).

1. Native CRM Ecosystem Agents (API & Context-Driven)

Major CRM platforms have moved past basic chatbots into autonomous agents. While they heavily utilize underlying data layers and function-calling (which acts like a programmatic LAM), they perform multi-step CRM tasks natively from natural language instructions:

• Salesforce Agentforce : Positioned as autonomous digital labor. It uses Salesforce's proprietary xLAM research and deep metadata structures to autonomously plan, reason, and execute multi-step workflows (like qualifying leads, updating pipeline fields, or managing service cases) directly inside the CRM environment.
• HubSpot Breeze : HubSpot's native AI engine. Breeze powers specialized "agents" (Content Agent, Customer Agent, Prospecting Agent) that navigate HubSpot's internal modules and UI spaces to draft outreach, enrich records, and execute marketing-to-sales actions.
• Microsoft Dynamics 365 Copilot : Integrated tightly into the Microsoft ecosystem, it uses advanced reasoning to execute tasks, summarize records, and update fields across Dynamics and connected Microsoft 365 tools.
• Creatio : Natively embeds operational AI agents capable of driving complex multi-step case management and process workflows directly inside the platform's visual interface.

2. Independent "Computer Use" & Browser Agents (Literal UI Navigation)

If your CRM is a custom legacy build, a proprietary internal tool, or a platform without clean public APIs, you look to general-purpose visual browser/UI agents. These agents interpret the Document Object Model (DOM) and screen pixels via multimodal models (like Claude or custom vision models) to click, scroll, and type:

• Browser Use (Open Source / Cloud) : A massively popular open-source framework and cloud platform that allows an LLM/LAM to control a browser via Playwright. You can point it at any logged-in web CRM session to extract data, fill forms, or move records.
• UIPath UI Agents : Leveraging computer vision and LAM research, UiPath provides UI-based autonomous agents that operate enterprise software via semantic criteria, mouse, and keyboard inputs when standard integration falls short.
• Custom Enterprise Browser Agents (via AWS Bedrock / Nova Act / Playwright) : Many enterprise engineering teams build custom task-runners utilizing tools like Amazon Bedrock combined with visual agents to safely operate inside isolated browser sessions for companies that require strict session-based CRM handling.

To give you the most accurate recommendation, could you tell me which specific CRM you are using (e.g., Salesforce, HubSpot, or a custom/legacy tool) and what exact tasks you want the agent to perform in the UI?

If you mean a Large Action Model (LAM) in the sense of an AI agent that can look at a CRM UI, click through screens, fill fields, create records, navigate workflows, and complete tasks like a human user, the market is still emerging. Many CRM vendors are moving toward agentic CRM, but most enterprise offerings today prefer API/tool-based agents rather than pure UI-driving agents.

Here are the main players to evaluate:

A few startups and platforms are specifically targeting browser-use agents (agents that operate any SaaS UI):

• Adept AI — early pioneer of “AI that uses software like a person.”
• Browserbase — infrastructure for browser-operating agents.
• Anthropic — Claude computer-use capabilities are aimed at interacting with graphical interfaces.

A practical distinction:

1. CRM-native agents (today’s enterprise mainstream)

   • Use CRM APIs, permissions, workflows, and business objects.
   • More reliable.
   • Examples: Salesforce Agentforce, Dynamics agents.

2. LAM / UI agents

   • See the screen and operate the application.
   • Useful for legacy CRMs, custom apps, or processes without APIs.
   • More brittle because UI changes can break them.
   • Examples: ServiceNow Adaptive Desktop Actions, RPA-style agents.

If you tell me which CRM you use (Salesforce, Dynamics, HubSpot, SAP, Oracle, Zoho, custom, etc.) and the tasks you want automated (data entry, lead routing, quote creation, reporting, case handling, etc.), I can narrow this to the vendors that are actually viable.

When looking for agents that visually or structurally navigate a software user interface (often called Large Action Models (LAMs), GUI Agents , or Computer Use Agents ) to execute tasks inside a CRM, the landscape is split between native CRM platform builders and general-purpose computer-use infrastructure that can be pointed at any web or desktop UI.

The primary providers offering agents capable of navigating a CRM interface include:

• Salesforce (Agentforce & xLAM) : Salesforce has pioneered enterprise-grade action models with its xLAM framework and Agentforce platform. Rather than just acting as a conversational chatbot, Agentforce uses the Atlas Reasoning Engine to plan multi-step workflows, retrieve data, and trigger actions directly inside the Salesforce CRM ecosystem via structured function calling and native semantic layers.
• Microsoft (Copilot Studio with Computer Use) : Microsoft provides native GUI and browser navigation capabilities through Copilot Studio . Utilizing underlying computer-use vision models, these agents can visually inspect a screen, move a cursor, click buttons, and fill out forms in both modern web apps and legacy/on-premise CRM installations that lack clean API integrations.
• Anthropic (Claude Computer Use / Claude Code) : Anthropic offers general-purpose Computer Use capabilities via its API (powered by models like Claude Sonnet), which allows developers to build or orchestrate custom agents that take screenshots, interpret a CRM’s DOM or visual layout, and click/type to execute end-to-end tasks like data entry or lead updates.
• Google Cloud (Gemini Computer Use Models) : Google provides computer-use and browser-navigation models via Vertex AI and Google AI Studio . These models are built to interpret mobile and web GUIs, making it possible to deploy visual web agents that can interact with custom or off-the-shelf CRM web dashboards.
• Specialized Enterprise UI Agents (e.g., Uniphore ActIO, Orby, UiPath UI Agents) : Independent automation platforms offer visual GUI agents specifically trained to observe user interface flows (clicks, form submissions) and replicate them dynamically without relying on rigid, traditional RPA scripts.

To give you the most relevant recommendation, could you tell me:

• Which specific CRM you are currently using (e.g., Salesforce, HubSpot, or a custom/legacy platform)?
• Whether you prefer an out-of-the-box native solution from your CRM vendor or an external AI agent that can be pointed at your current screen?