Google Antigravity Now Lets AI Agents Build and Deploy Apps Through Lovable

Lovable now shows up as a first-class citizen inside Google Antigravity, Google's agent-first development platform. With one OAuth connection, agents running inside Antigravity can reach into an entire Lovable workspace to scaffold projects, iterate on existing ones, run SQL against Lovable Cloud databases, and push apps to production.

The bridge is the Lovable MCP server at https://mcp.lovable.dev. Once wired into Antigravity's MCP configuration, the platform treats Lovable like any other tool an agent can plan around, call, and verify against.

What Antigravity actually is

Google Antigravity is a fork of Visual Studio Code built around an agent-first interaction model. You still get a familiar AI-powered coding surface, but the headline feature is deploying agents that plan, execute, and verify complex tasks across your editor, terminal, and browser without constant hand-holding.

Model choice is generous. Antigravity runs on macOS, Windows, and Linux, with high rate limits on Gemini 3 Pro plus support for Anthropic's Claude Sonnet 4.5 and OpenAI's GPT-OSS. The public preview is free for individuals, which lowers the friction for trying this integration.

Why MCP is the connective tissue

The Model Context Protocol is the reason this integration is a one-liner rather than a bespoke plugin. Antigravity speaks MCP, an open standard that lets AI agents and editors securely connect to local developer tools, databases, file parsers, and remote APIs. Think of it as a common port so any agent can discover and invoke Lovable's capabilities without a custom SDK on either side.

On the Lovable side, the server is broad. Scope covers your full account, not one project. Whatever client you connect can list, read, and edit every project you have access to. Calls run live, consume real credits, and modify real projects. That is powerful and slightly dangerous, worth knowing before you point an autonomous agent at a production workspace.

What agents can do end to end

The MCP server exposes a wide surface. From an Antigravity agent session you can now:

• Spin up a new app with create_project, optionally starting from a template or design system
• Send natural-language iterations with send_message, including a plan_mode for design-first workflows
• Inspect the codebase with list_files, read_file, and get_diff
• Run reads, writes, and schema changes against Lovable Cloud through query_database
• Ship it live with deploy_project, which returns a URL on lovable.app
• Read and write workspace and project knowledge, so agents can persist context between runs

A typical Antigravity workflow becomes something like: plan the feature in the Manager view, delegate the scaffold to Lovable via MCP, pull the diff back into Antigravity, verify with the browser-in-the-loop agent, and deploy. That maps neatly onto what many teams have already been doing by hand. One hands-on comparison described the pattern as building the initial scaffold in Lovable, exporting to GitHub, then pulling it into Antigravity to harden for production. The MCP connection collapses that hand-off into a single agent session.

Setting it up

Antigravity discovers MCP servers from a config file, located globally at ~/.gemini/config/mcp_config.json or locally in your workspace under .agents/mcp_config.json. A minimal entry for Lovable looks like this:

{
  "mcpServers": {
    "lovable": {
      "type": "http",
      "url": "https://mcp.lovable.dev"
    }
  }
}

On first use, Lovable's OAuth flow opens in a browser. Access is available on every plan. Third-party MCP client access is enabled by default on Free, Pro, and Business workspaces and disabled by default on Enterprise, where an admin or owner flips it on under Settings, Security, Privacy and security, Third-party MCP clients.

Two philosophies, one session

The two products have sat on opposite ends of the spectrum. Lovable optimizes for going from prompt to deployed React and Supabase app in a browser tab. Antigravity optimizes for orchestration, verification, and multi-agent execution inside a real repo. One community write-up framed the split cleanly: Lovable is collapsing the path from prompt to product, while Antigravity is expanding the amount of real engineering work an agent can safely own.

Stitching them together through MCP means an Antigravity agent can lean on Lovable for the greenfield scaffold, then take over for production hardening, without a developer manually shuttling code between two environments. Lovable's data layer is also reachable from a general-purpose agent host, which turns Lovable Cloud into a backend that any Antigravity workflow can query and mutate.

For anyone already living inside Antigravity, this is a small config change that unlocks a large capability surface. For Lovable, it is a bet on being the composable building block other agent platforms reach for, rather than a walled garden.