How to Install and Run OpenManus for Free

OpenManus is a free, MIT-licensed open-source agent framework that you run from the command line using your own model API keys. At Layer3Labs, we build AI workflows for small and mid-sized businesses, and a free agent framework still needs someone who can manage API keys and a Python environment.

While Manus AI operates as a hosted, credit-based product, OpenManus gives developers direct terminal execution without requiring invite codes or monthly platform fees.

What OpenManus Is and How to Run It

OpenManus is free, open-source software, and it is not Manus. It is a separate agent framework built by contributors from MetaGPT, and you clone it from GitHub and run it with your own model API keys. Manus itself has a $0 Free plan with 300 daily credits, but it runs in Manus's cloud and needs a Manus account. The code is released under the MIT License and sits in the OpenManus GitHub repository under the Foundation Agents organization. OpenManus requires Python 3.12 or later, and you execute tasks directly through your local command line.

Setting up OpenManus takes a few terminal commands, with the project documentation recommending the uv package manager for dependency management. Alternatively, you can install the environment using conda.

• Install uv and clone the repository: run curl -LsSf https://astral.sh/uv/install.sh | sh, clone with git clone https://github.com/FoundationAgents/OpenManus.git, and navigate into the folder using cd OpenManus.
• Create the virtual environment: run uv venv --python 3.12, activate it using source .venv/bin/activate on Unix or macOS (or .venv\Scripts\activate on Windows), and install dependencies with uv pip install -r requirements.txt.
• Alternative conda installation: run conda create -n open_manus python=3.12, activate it with conda activate open_manus, clone the repository, enter the directory, and run pip install -r requirements.txt.
• Initialize the configuration: copy the template by running cp config/config.example.toml config/config.toml.
• Configure your model credentials: open config/config.toml and populate model, base_url, and api_key under the [llm] block.
• Launch the agent: run python main.py in your terminal and enter your prompt when requested.

Relationship to Manus and Hosted Differences

OpenManus is an open-source project created by contributors from MetaGPT. The README in the GitHub repository opens by calling Manus "incredible" and saying OpenManus can achieve any idea without an invite code. The documentation states no affiliation with Manus either way.

Manus is a hosted product: Manus runs your tasks in its own cloud, and you need a Manus account to use it. The Manus membership pricing documentation lists a $0 Free plan with Chat Mode and Manus 1.6 Lite in Agent Mode. It includes 300 daily credits, one concurrent task, and two scheduled tasks.

For higher usage, the Manus pricing page lists paid tiers at $20 monthly for 4,000 credits, $40 monthly for 8,000 credits, and $200 monthly for 40,000 credits. In contrast, OpenManus has no membership tiers and runs on your own machine, calling whichever model API you configure.

Model Provider Options and Configuration

OpenManus connects to multiple LLM providers through standard API endpoints defined in config/config.toml. The repository ships several provider templates in the config/ directory, including configuration files for Anthropic, OpenAI, Azure, Google, local Ollama, Amazon Bedrock, PPIO, and Jiekou.AI.

The shipped config/config.example.toml defaults to Anthropic using model = "claude-3-7-sonnet-20250219" with base_url = "https://api.anthropic.com/v1/" and max_tokens = 8192. In contrast, the README snippet demonstrates an OpenAI configuration using model = "gpt-4o" with base_url = "https://api.openai.com/v1" and max_tokens = 4096. For Google Gemini, the repository includes config.example-model-google.toml configured with model = "gemini-2.0-flash" and base_url = "https://generativelanguage.googleapis.com/v1beta/openai/".

Developers can avoid cloud API billing by running local models through Ollama, which needs hardware strong enough to run the model (see our Ollama guide). The OpenManus template config.example-model-ollama.toml sets api_type = 'ollama', model = "llama3.2", a secondary vision model llama3.2-vision, base_url = "http://localhost:11434/v1", and a placeholder api_key = "ollama".

• Azure OpenAI: configured via config.example-model-azure.toml using api_type = 'azure', model = "gpt-4o-mini", and a required api_version parameter.
• Amazon Bedrock: configured using api_type = "aws" with a dummy key parameter api_key = "bear" noted in the example as required but not used for Bedrock.
• PPIO Cloud: configured via config.example-model-ppio.toml with api_type = 'ppio', model = "deepseek/deepseek-v3-0324", and base_url = "https://api.ppinfra.com/v3/openai".
• Jiekou.AI: configured via config.example-model-jiekouai.toml using api_type = 'jiekou', model = "claude-sonnet-4-5-20250929", and base_url = "https://api.jiekou.ai/openai".

Execution Modes and Multi-Agent Workflows

OpenManus provides three execution entry points depending on whether you require a standalone agent, Model Context Protocol (MCP) integrations, or multi-agent planning. python main.py runs a single agent. It takes your prompt at the terminal or through the --prompt argument.

For tooling interoperability, python run_mcp.py launches an MCPAgent supporting standard input and output (stdio) and Server-Sent Events (sse) connections. Command-line flags include --connection (or -c), --server-url (default http://127.0.0.1:8000/sse), --interactive (or -i), and --prompt (or -p). The project includes config/mcp.example.json illustrating an SSE server target at http://localhost:8000/sse.

Complex orchestration is handled by python run_flow.py, which constructs a planning flow across agents. The repository README describes this multi-agent mode as unstable. run_flow.py stops any flow after 3600 seconds and logs a timeout message. Use python main.py for tasks you need to finish reliably.

Browser Automation Setup and Tools

OpenManus incorporates automated web browsing capabilities by launching Browser Use Command Line Interface (CLI) version 3.0 as a default MCP server. OpenManus runs uvx browser-use --cli-mcp on startup, giving the agent the canonical Browser Use skill plus the native browser_exec and browser_screenshot tools.

Local browser execution attaches directly to existing Chrome or Chromium installations without requiring a third-party API key. Developers can verify local browser prerequisites by running uvx browser-use --doctor or install browser binaries via uvx browser-use install. If you run tasks that rely on BrowserGym, you must install Playwright browsers manually using playwright install.

For isolated remote execution, you can export BROWSER_USE_API_KEY="bu_..." before launching OpenManus. Developers can target specific browser instances using the BU_CDP_URL, BU_CDP_WS, or BU_NAME environment variables. If your workflow does not require web browsing, set OPENMANUS_DISABLE_BROWSER_USE=1 to turn off the MCP browser server entirely.

Software Licensing and Operational Boundaries

The MIT License means you can use and modify OpenManus without paying for the software. You still pay your model provider for every input and output token OpenManus uses.

The project authors note in the documentation that OpenManus is a simple implementation with a prototype created in three hours. The Foundation Agents project page lists a web interface for watching the agent work in real time, but the README documents no web UI. The Hugging Face demo Space is paused, so there is no hosted version to try.

The sandbox is disabled by default, so decide before your first run whether to turn on the commented [sandbox] block in config/config.toml. The block's defaults are use_sandbox = false, the container image python:3.12-slim, a 1-gigabyte memory limit, and a 300-second timeout. OpenManus does not publish formal benchmark figures on evaluations like GAIA. For businesses evaluating self-hosted tooling versus turnkey platforms, our self-hosted agent guide covers what it takes to keep one running.

OpenManus is not built for non-technical users who want a zero-configuration web interface with managed cloud execution. Those teams should use hosted platforms like Manus or review our Manus AI pricing guide. Our recommendation would change if an official hosted version of OpenManus ships or the project adds a graphical installer.

Research Directions with OpenManus-RL

The OpenManus-RL repository is a reinforcement learning (RL) project for tuning LLM agents, which its README calls an extended version of the original OpenManus initiative. Developed jointly by researchers from the University of Illinois Urbana-Champaign (UIUC) and MetaGPT, OpenManus-RL investigates post-training tuning methods such as Group Relative Policy Optimization (GRPO) for agentic reasoning.

Its README says results will be tested on agent benchmarks such as GAIA, AgentBench, WebShop, and OSWorld. The initiative makes its dataset and code publicly accessible, hosting an Agent Supervised Fine-Tuning (SFT) dataset on Hugging Face under CharlieDreemur/OpenManus-RL.

To get started with OpenManus today, clone the repository to your workstation, configure your preferred API key in config/config.toml, and run python main.py to test your first terminal agent prompt.

ChromeOS Support and Pixelbook Go Setup

Running OpenManus on a Chromebook such as the Google Pixelbook Go is possible only through the ChromeOS Linux development environment, with several operational caveats. We have not tested OpenManus on a Pixelbook Go. You must check whether your device allows Linux installation, because Google's support page does not list specific supported models or hardware requirements. Work or school accounts can also disable Linux access on a managed Chromebook, which requires contacting an administrator.

The Linux development environment is turned off by default in ChromeOS. Turn it on in Settings under About ChromeOS, open the Developers section, and select the setup option for Linux. That setup can take 10 minutes or more and launches a terminal with Debian and the Advanced Package Tool (APT). Inside that terminal, create a Python 3.12 environment, clone the OpenManus repository, and install the dependencies from the requirements file.

Google notes that ChromeOS Linux does not support hardware acceleration, meaning Graphics Processing Unit (GPU) acceleration and video decode are unavailable, and cameras do not connect. OpenManus sends requests to external model Application Programming Interface (API) endpoints with your own key, so the model itself does not have to run on the laptop. For web tasks, OpenManus launches the Browser Use command line tool as its default Model Context Protocol (MCP) server, which runs in local mode without an API key and attaches to Chrome or Chromium. We have not checked how that browser step behaves on ChromeOS Linux.