Agent Mode

How it works

Agent Mode runs one request to completion. The sequence below is what a single run does, in order.

1. 01

   Reads intent and explores the codebase

   The request is resolved against the actual project rather than a summary of it. The agent opens the files it needs to establish context before proposing any edit.

2. 02

   Plans first when the approach is undecided

   Strategy, architectural comparison, and investigation happen without touching code. Plan Mode is the explicit form of this, and it can be switched into at any point.

   Plan Mode
3. 03

   Delegates focused investigation to subagents

   Complex runs spawn temporary read-only subagents for research, code exploration, and review. They report findings back and cannot modify the project themselves.

   Subagents
4. 04

   Applies changes across files as diffs

   Edits are written directly to the project and surface as file diffs, so every change is reviewable rather than described.

5. 05

   Shows each step while it runs

   A live task list reports the current step, the files being modified, and the tools in use, including web fetch, search, and image generation.

   Tasks (Agent Transparency)
6. 06

   Takes further prompts in order

   One task runs at a time. Anything sent mid-run joins a visible queue that can be paused, reordered, or trimmed before it reaches the agent.

   Prompt Queue
7. 07

   Verifies before finishing

   Verification uses browser interaction for UI flows, Vitest and React Testing Library for isolated frontend logic, and direct invocation plus Deno tests for backend behavior.

8. 08

   Debugs its own failures

   On error, the agent inspects logs, runtime output, and network activity, then iterates until the problem is resolved or it has to ask.

   Questions (Agent Clarification Tool)

Lovable's current documentation calls this Build mode. Agent Mode is the name it launched under in February 2025 and the name still used across most write-ups, so the atlas keeps it as the record title and notes the change here.

Example workflows

Three runs worth copying verbatim. Each prompt is written the way it should be sent, as one paragraph with the outcome and the constraints stated up front.

1. 01

   Ship a feature end to end

   The outcome is clear and the approach is not contested. This is the run Agent Mode is built for: one prompt, one reviewable set of diffs.

   Add a saved-searches feature to the app: users can name and save the current filter set, see their saved searches in the sidebar, apply one with a click, and delete one. Persist them per user in the database with row level security so nobody can read another user's rows. Match the existing sidebar styling and design tokens, do not add new dependencies, and verify the create, apply, and delete flows in the browser before you finish.

   Expected outcome

   A single run that reads the existing sidebar and data layer, creates the table with policies, writes the UI and the persistence code, and drives the three flows in a browser to confirm they work. You get a task list of the steps and a diff per file, plus a working feature in the preview rather than a description of one.

2. 02

   Decide the approach before any code is written

   The change is architectural and the wrong choice is expensive to undo. Plan first, approve, then let the same run implement.

   We need multi-tenant workspaces: every user belongs to one or more workspaces, and all existing records become workspace-scoped. Do not write any code yet. Investigate how the current tables and queries are scoped, then give me a plan covering the schema change, the migration path for existing rows, how row level security changes, and what breaks in the UI. Flag anything you are unsure about instead of assuming it.

   Expected outcome

   A read-only investigation run: the agent explores the schema and query paths, spawns subagents for the parts it needs to read in depth, and returns a plan you approve, reject, or edit. No files change until you approve. Approving continues into implementation in the same conversation, with the plan as the contract.

3. 03

   Hand it a bug and let it debug itself

   Something is broken in the running app and the cause is not obvious from the code alone. Give the symptom, not a guessed diagnosis.

   The checkout page shows a blank screen for some users after they apply a discount code, but only on mobile. Reproduce it in the browser at 375px width, read the console and network output to find the actual cause, then fix it. Tell me what the root cause was and add a test that fails without the fix. Do not change unrelated code while you are in there.

   Expected outcome

   The agent reproduces the failure against the live preview, reads console errors and network responses rather than guessing, fixes the cause, and confirms the page renders. You get the root cause stated plainly, a regression test that pins it, and a diff limited to the files involved.

Frequently asked

• What is Agent Mode?

  Agent Mode is Lovable's Agent feature: Autonomous, end-to-end execution mode. Agent Mode takes ownership of a task end-to-end — understands intent, explores the codebase, applies changes across files, resolves issues mid-implementation, and verifies results.

• Is Agent Mode GA or in beta?

  Agent Mode is generally available (GA) on Lovable.

• What Lovable plan includes Agent Mode?

  Agent Mode is available on all Lovable plans.

• When did Agent Mode launch?

  Agent Mode launched on Feb 11, 2025.

• How is Agent Mode different from a normal chat message?

  A normal message answers or makes a single edit. Agent Mode runs a request to completion: it explores the codebase, plans, edits across files, verifies the result, and debugs its own failures before it hands back. Expect a longer run and a visible task list rather than one immediate reply.

• Why is my Agent Mode run taking so long?

  Runs scale with the work, not the prompt. Exploration, subagent research, multi-file edits, and verification each take a turn. If a run feels stalled, open the task list to see the current step and the files in use. A run that is still reporting steps is working, not stuck.

• Can I send another prompt while Agent Mode is running?

  Yes. One task runs at a time and anything you send joins the prompt queue. The queue is visible and can be paused, reordered, or trimmed before the agent reaches it, so a mistaken follow-up can be removed rather than absorbed mid-run.

• How do I stop Agent Mode from changing the wrong files?

  Scope the request and say what is off limits. Every change surfaces as a file diff, so review the diff list before continuing. For anything architectural, ask for a plan first and approve it, which keeps the run read-only until the approach is settled.

• Agent Mode stopped and asked me a question. Why?

  The agent asks when two readings of the request would produce materially different work, or when it needs a credential or decision it cannot infer. Answering resumes the same run. Vague first prompts cause most of these pauses, so state the outcome you want and the constraints that matter.

• What should I do when a run finishes with an error still on screen?

  Send the error back in the next message. The agent reads console logs, runtime errors, and network activity, so a pasted message or a description of the failing step is usually enough to reproduce it. Reverting to the last working version first is safe and does not lose the conversation.

• Does Agent Mode cost more credits than a normal message?

  A run uses credits for the work it performs, so a long multi-file run costs more than a single edit. Narrow prompts, an approved plan, and a trimmed queue are the practical ways to keep a run short.

• Agent Mode Default in Lovable 2.0Jul 2025
• Questions (Agent Clarification Tool)Nov 2025
• Plan Before You Build — Chat Mode QuestionsDec 2025