Introducing Lava Desktop: API Access and DOM Control in One AI Agent

Every agent we built hit the same wall. API access gets you data. But the agent still can't see what's on your screen, act inside a real UI, or work across apps the way a human would. You end up copy-pasting context manually, which defeats the point.

So we built Lava Desktop: an AI agent that combines API access to hundreds of providers with live DOM access to your real app UIs. Sign in, connect your apps, describe the task. No engineering required. Download it at lava.so/lavadesktop.

Key Takeaways

• The gap no one solved: Most agents have API access OR DOM access, not both. Lava Desktop has both.
• API + DOM together means agents can pull structured data from providers and act inside real UIs like Gmail, Slack, and Salesforce in a single workflow.
• You approve every action before it executes, so agents with real-world reach don't run loose.
• Model agnostic: Switch between Claude, GPT-4o, Gemini, and Grok mid-task. One wallet covers everything.
• No integrations to build: If an app has a UI, the agent can work in it.

See It in Action

The Wall Every Agent Hits

The promise of AI agents is automation: describe a task, watch it get done. The reality is that most agents operate in a narrow lane.

They can call APIs and fetch structured data from connected providers. What they cannot do is look at your screen, read a page that has no public API, click buttons, fill forms, or navigate an app the way you would.

This creates a gap that you fill manually. Your data lives in Salesforce, Gmail, Slack, and a dozen other tools. Some have good APIs. Many workflows span multiple apps, and the handoffs between them are manual. You copy data from one tool, paste it into the agent's context, run the task, then manually move the output somewhere else. You are the integration layer.

That is not automation.

Two Capabilities, Finally Together

Lava Desktop is the first agent that combines API and DOM access in one place.

API access through Lava's gateway connects to hundreds of providers: databases, CRMs, email, calendars, finance tools, enrichment APIs, and more. These are structured integrations with proper auth, metering, and reliability. When an agent needs data from an API, it gets it the right way.

DOM access means the agent can read and act inside the real UI of your apps in real time. Gmail, Slack, Salesforce, Outlook, Granola, Canvas LMS. It sees what's on the screen, navigates within the app, and takes actions the same way you would. No API endpoint required.

Look at where competitors land:

Claude with MCPs and Composio give you API access without DOM. They can call tools and fetch structured data, but they are blind to anything that only exists in a UI. ChatGPT Atlas and Perplexity Comet have DOM access but no API layer. They can navigate browsers but lack the connected provider network for structured data at scale.

Lava Desktop has both in one agent.

You Stay in Control

Every action the agent proposes goes through you before it executes.

This is not a limitation. When an agent can act inside real UIs with real consequences (sending emails, updating records, submitting forms) you need a clear approval step before anything happens. Lava Desktop surfaces each proposed action. You see what it's about to do and why. You confirm or skip. Then it runs.

This makes the agent useful immediately without requiring you to trust it blindly with your accounts.

Model Agnostic by Design

Lava Desktop works with Claude, GPT-4o, Gemini, and Grok. You can switch models mid-task. Different tasks call for different models, and locking into one provider is a design mistake we deliberately avoided.

All usage runs through one wallet. You load credits once. Every model call, every API request, every provider interaction settles against that balance. No juggling API keys across four providers, no surprise charges, no separate billing dashboards.

What You Can Actually Do With It

The combination of API and DOM access unlocks cross-app workflows that were previously impractical:

Research and outreach: Pull contact data from an enrichment API, cross-reference against your CRM in Salesforce, draft and send personalized emails in Gmail. The agent handles the full sequence. You approve each step.

Meeting follow-up: After a call in Granola, the agent reads the notes, updates the relevant deal in your CRM, drafts follow-up messages, and sends them through Slack or email. Each action approved step by step, nothing sent without your confirmation.

Support triage: Read incoming messages across Slack and email, categorize them, pull relevant context from internal tools, and draft responses or route tickets. The agent reads the UI and responds inside it.

Academic workflows: Canvas LMS does not expose every workflow through a clean API. DOM access means the agent can navigate and act inside Canvas the same way an instructor would, without waiting for an API endpoint to exist.

How the Architecture Works

Lava Desktop runs as a desktop application. The API layer goes through Lava's gateway, which handles auth, metering, and provider routing. The DOM layer uses a browser context embedded in the app, with the agent reading and acting on the live DOM.

Every API request is authenticated, logged, and metered. You see what the agent called, what it cost, and what came back. The wallet enforces spending limits automatically.

The approval flow is built into the agent loop. Before any action with side effects, the agent surfaces it. You approve or reject. Then it continues. There is no mode where the agent runs unsupervised.

Why We Built This

We ran agent workflows internally before building this product. Every time, we hit the same friction: the agent was useful within a single system with a clean API, and much less useful when a workflow crossed apps or touched a UI.

DOM access was the obvious missing piece. We built it into our gateway infrastructure so the same auth, metering, and spending controls that govern API calls also apply to DOM sessions. The result is an agent that does not require you to build integrations, does not require target apps to have a public API, and does not require any engineering to set up.

The bottom line: Agents that only have API access or only have DOM access are half-tools. The real workflows live at the boundary between structured data and real UIs. Lava Desktop works at that boundary.

How Lava Helps

Lava Desktop is built on two Lava products.

Lava Gateway handles all the API routing. It connects to 400+ providers with a single auth layer. Every request the agent makes goes through the gateway, is metered, and settles against your wallet. You see what was called, what it cost, and what it returned.

Lava Monetize handles the wallet. One prepaid balance covers all API calls across all providers and all models. Set a spending limit, load credits, and the agent operates within that budget automatically. No per-provider billing, no surprise charges.

If you're building or running workflows that need to cross apps, talk to real UIs, and work without engineering overhead, download Lava Desktop at lava.so/lavadesktop.