Carve: An Open-Source Browser Agent Supporting Local Models and Multi-Model Web Automation

Carve: An Open-Source Browser Agent with Multi-Model Support

Browser automation is becoming one of the most important deployment scenarios for AI agents. Recently, a developer shared an open-source project on Reddit called Carve — a "computer use agent" that can operate any website using only text instructions, without requiring custom scripts or rules for each individual page.

Unlike traditional RPA (Robotic Process Automation) tools, Carve leverages large language models to interpret natural language instructions and translate them into concrete browser-level actions. The developer demonstrated Carve automatically filling out a supply chain form — the entire process required no manual field-by-field data entry. The project is open-sourced on GitHub at github.com/getcarve/carve.

Multi-Model Support as the Core Selling Point

Carve's most notable design choice is its model compatibility. According to the author, it supports local models, OpenRouter, OpenAI, and Anthropic simultaneously. This multi-backend architecture allows users to flexibly choose based on cost, privacy, and performance requirements:

• Local models: Ideal for scenarios with strict data privacy requirements where users don't want operational data sent to third parties;
• OpenRouter: Acts as an aggregation layer for easy switching between different providers;
• OpenAI / Anthropic: Users seeking stronger reasoning capabilities and reliability can call mainstream commercial models directly.

For browser agents, model capability directly determines how accurately the agent understands page elements and how reliably it executes actions. Giving users model choice reduces the risk of vendor lock-in and enables the developer community to run comparative tests across different models.

OpenRouter is a unified AI model API aggregation service that lets developers call models from dozens of providers — including OpenAI, Anthropic, Google, and Meta — through a single endpoint. Its core value lies in reducing switching costs: users don't need to apply for and manage multiple sets of API keys, nor write different integration logic for each model. For applications like browser agents that are sensitive to model reasoning quality, OpenRouter also provides convenient comparisons of model performance and pricing, making it easier to find the best cost-performance combination. In Carve's architecture, OpenRouter serves as a "routing layer," allowing the underlying model to be swapped out at any time without changing the upper-level task logic.

A Safety Mechanism for Consequential Actions

The greatest risk with browser agents is this: when an agent has the ability to click, submit, and send, a single erroneous action can produce real, irreversible consequences. Carve addresses this with a targeted design — it is trained to pause and ask for user confirmation before executing any consequential action (such as submitting a form or sending a message).

This "human-in-the-loop" mechanism is an important trend in current agent products. It strikes a balance between automation efficiency and operational safety, preventing the kind of mistakes that can arise from fully autonomous execution. For tasks involving business data — such as supply chain data entry or order submission — this confirmation step is almost essential.

Speed Performance and "Ultrafast Mode"

The author specifically noted that Carve executes tasks significantly faster than manual operation, especially when "ultrafast mode" is enabled. This feature hasn't been officially released yet; the author says it will be included in a future version.

Speed advantage is an intuitive value proposition for automation tools. For workflows that involve repeatedly filling out forms or batch-processing web tasks, an agent can complete in seconds what a human might take minutes or longer to do. That said, speed and reliability often involve trade-offs — in high-speed execution mode, how the confirmation mechanism coexists with speed optimization will be a key factor in measuring this type of tool's practical utility.

Use Cases and Community Feedback

Based on the demo, Carve's most direct application is repetitive form-filling work such as supply chain data entry, data registration, and information submission. The author also actively solicited feedback from the community, asking which specific websites or workflows most need this kind of automation.

Open-source projects like this depend heavily on community feedback to grow. Practical use cases for potential users include: batch web data scraping, form stress testing in test environments, and repetitive web operations in day-to-day office work. For developers following AI agent technology, Carve provides an open-source reference for studying how "computer use agents" can be deployed in real browser environments.

RPA (Robotic Process Automation) is the predecessor technology to browser agents, with representative products including UiPath, Automation Anywhere, and Blue Prism. RPA automates operations by recording user action sequences or writing scripts based on element selectors — it is fundamentally "rule-driven" automation. Once a page's structure changes, scripts often break immediately, leading to very high maintenance costs. LLM-driven browser agents like Carve take a different approach — "understanding-driven" automation: the model dynamically identifies operation targets by analyzing visual screenshots or DOM structure, with no need for pre-recorded sequences or hardcoded rules. This makes them significantly more robust to page changes, but also introduces new challenges such as model hallucination, action latency, and inference cost. The two approaches represent different trade-offs between reliability and flexibility.

Summary

Carve represents a typical exploration in the current browser agent landscape: natural language as the entry point, multi-model backends, and human confirmation as the safety boundary. Its multi-model compatibility and open-source nature lower the barrier to entry, and its design philosophy of "requiring confirmation before consequential actions" is worth learning from for similar products.

As a project still in active development, its real-world stability, ability to handle complex pages, and the ultimate performance of ultrafast mode still need to be validated in more real-world scenarios. Interested readers can try it out through the GitHub repository and participate in feedback and co-development.

Background

"Human-in-the-Loop" (HITL) is a design paradigm that embeds human judgment at critical nodes within automated processes. It originated in automatic control and machine learning. In traditional machine learning, HITL refers to human annotators participating in the selection and correction of model training data; in the context of AI agents, it specifically refers to an agent pausing before executing high-risk or irreversible actions, allowing a human to review and decide whether to proceed. This mechanism directly counters the risks of "over-autonomy": an agent's understanding of instructions may be ambiguous, and subtle differences in page structure can cause operational deviations. Once a scenario involves data submission, financial transfers, or message sending, the cost of errors is often unrecoverable. Current mainstream agent products — whether OpenAI's Operator or Anthropic's Computer Use — have incorporated HITL checkpoints to varying degrees. This has become one of the foundational principles of responsible agent design.