How to Configure Manus AI Local Installation and Folder Permissions

According to the official download documentation, the Manus desktop application requires Apple Silicon macOS or Windows 10/11 to access local systems via My Computer permissions, meaning older operating systems are blocked from native local executions [Manus Official Desktop Download Documentation]. This device boundary is a primary constraint for teams planning a rollout. The Manus desktop application allows the autonomous agent to interface directly with local file systems and terminals, requiring explicit folder permission. When an agent has access to local terminals, it operates at machine speed, carrying out tasks that would take humans minutes or hours in a fraction of a second. This execution speed is a primary benefit of autonomous agents, but it also increases the risk of undetected errors.

Organizations deploying autonomous agents often face a significant visibility gap, only discovering what an AI agent did (such as modifying records, executing commands, or deleting files) after the action has already been executed. This latency in visibility highlights the core challenge of deploying autonomous agents locally on workstations. The official Manus AI application is designed to act as a general-purpose digital assistant. It can navigate files, interact with local applications, and execute command line scripts on your machine. This integration requires a high degree of access, which is managed through a feature called My Computer. Because the agent can write code and execute it in real time, security cannot rely on post-event cleanup. A single incorrect loop or misunderstood instruction could result in the agent scanning directories containing sensitive files or executing a destructive shell command.

In contrast, OpenManus is a developer-focused, open-source alternative hosted on GitHub. Unlike the official desktop app, OpenManus does not include a hosted user interface. Instead, it runs as a command line utility in a Python terminal environment. Because it is open-source, developers can inspect the agent's code, modify its tool definitions, and control the prompt templates directly. However, OpenManus runs with the exact permissions of the terminal session that launches it. If the terminal has write permissions to a system directory, the agent inherits those permissions. This makes local directory isolation and strict boundary configuration essential for any developer setting up the tool. For teams deploying local agent setups, integrating a dedicated agent workspace helps prevent local file corruption, as documented in the Fast.io guide for agents.

To download and install the official Manus desktop application, navigate to the official download page at https://manus.im/desktop and select the installer package compatible with your operating system. For Windows users, the application is also available in the Microsoft Store, while macOS users must download the disk image file. Once the installation is complete, launch the application and sign in to your user account. Before running any tasks, you must configure the folder permission authorization settings to establish a secure boundary for the agent. The My Computer feature requires explicit folder-scoped approval to prevent the agent from accessing sensitive directories outside your project scope. This folder permission configuration is essential for establishing local automation safety boundaries that protect sensitive data.

Here is the step-by-step setup guide for configuring folder access on My Computer:

1. Create a dedicated directory on your local machine, such as C:\ManusWorkspace on Windows or /Users/username/ManusWorkspace on macOS, to act as the agent's sandbox.

2. Open the Manus Desktop app and select the My Computer tab from the primary navigation menu.

3. Click the Add Folder button in the center of the interface to trigger the operating system's file browser.

4. Browse to and select the dedicated directory you created, then click Select Folder or Open.

5. Click Approve on the operating system pop-up window that requests folder access permissions for the application.

Once these steps are complete, the agent is restricted to this specific directory. If it attempts to run a terminal command that navigates outside this path, the application blocks the process. For local automation safety, verify the permissions at the operating system level to ensure no inheritance rules grant the app broader access. Check the permissions list to ensure the user account running the application has Read and Write access, but deny Full Control to prevent the agent from modifying system-level ownership settings. On macOS, open System Settings, navigate to Privacy & Security, and select Files and Folders. Verify that the application is listed with access restricted only to your chosen directory. During active execution, the application uses an interactive confirmation step for terminal actions. When the agent constructs a command, it displays the script in the UI. You can choose to allow a single execution or select a persistent permission setting for that specific tool. If the agent behaves unexpectedly, you can immediately terminate the active run from the control panel. If the application becomes unresponsive or fails to access authorized folders, sign out of your account, restart the application, and sign back in to refresh the active session token.

Isolate local Manus AI workspace files in secure cloud storage

Deploy a dedicated, persistent workspace for your local AI agent. Connect via Model Context Protocol to auto-index documents, manage file version history, and transfer ownership to your team once setup is complete. Starts with a 14-day free trial.

Start 14-Day Trial

For developers who prefer an open-source model, OpenManus is a community-maintained framework that runs locally in a terminal. According to the OpenManus GitHub repository documentation, OpenManus requires Python 3.10+ and external API keys [OpenManus GitHub Repository]. To install the framework, open your terminal and run the following commands to clone the repository and navigate into the project directory:

git clone https://github.com/FoundationAgents/OpenManus.git
cd OpenManus

Using the uv package manager is recommended for rapid installation and clean environment isolation:

uv venv --python 3.12
source .venv/bin/activate
uv pip install -r requirements.txt

If you prefer conda, you can create and activate a new environment:

conda create -n open_manus python=3.12
conda activate open_manus
pip install -r requirements.txt

If the agent needs to perform browser automation tasks, you must also install the browser binaries using playwright:

playwright install

Once the dependencies are installed, you must configure the API credentials. Copy the example configuration file to create your active configuration file:

cp config/config.example.toml config/config.toml

Open config/config.toml in your text editor. Locate the LLM configuration section and input your target model, API endpoint, and authentication key. The configuration structure is shown below:

[llm]
model = "gpt-4o"
base_url = "https://api.openai.com/v1"
api_key = "sk-proj-your-api-key"

Save the file. Run the main script to start the agent:

python main.py

When prompt input appears in your terminal, type your task and press enter. The agent will begin executing the task, downloading files, writing scripts, and running commands in the context of your terminal session. Because OpenManus executes terminal commands directly, it inherits the permissions of the terminal session that launches it. If you launch the agent from an administrator terminal, the agent can execute administrative commands, creating a severe security risk. To mitigate this risk, run the agent in a non-privileged shell. You should also configure a dedicated environment variable file to restrict the agent's visibility. If the agent fails to find the required dependencies, verify that your virtual environment is active. You can run pip list to ensure that core dependency files are installed correctly. If the script returns an API key error, double-check that the config.toml file is located in the config subdirectory and that the format exactly matches the example layout. When running complex multi-agent flows, you can run the flow runner script using python run_flow.py. If you are developing custom tools, you can expose local files and endpoints through a custom server, enabling the agent to read and write data safely within a defined schema.

Running autonomous agents like Manus AI or OpenManus strictly on a local workstation presents long-term coordination challenges. When an agent creates files, runs tests, or generates reports, that output remains isolated on a single machine. Traditional cloud storage services like Google Drive, Dropbox, or OneDrive are often used to sync local directories, but they lack the metadata structure, RAG index capabilities, and granular controls required for agentic workflows. To solve this, developers are integrating local agents with persistent, intelligence-enabled cloud workspaces. In an intelligent workspace, such as the workspaces provided by Fast.io, files are automatically indexed for semantic search, summarization, and chat groundings once Intelligence is enabled. Instead of maintaining a separate vector database and ingestion pipeline, you upload the files to a workspace and the files are immediately ready for AI consumption.

For example, a developer can run OpenManus locally but configure its output path to write directly to a Fast.io workspace. Fast.io exposes action-based tools via the Model Context Protocol, allowing local agents to query, read, write, and manage files programmatically. Fast.io supports Streamable HTTP access at /mcp and legacy SSE access at /sse (see the Fast.io Agent Storage guide for details). Furthermore, when an agent operates in a shared workspace, every file has a complete version history. If the agent makes a mistake, overwrites a script, or deletes a directory, a human collaborator can restore prior versions instantly. This version history keeps concurrent agent modifications fully auditable and prevents data loss. The workspace serves as a secure coordination layer, ensuring that agent output is versioned, indexed, and visible to the entire team.

While simple cloud storage platforms sync files back and forth, they do not index the content for agentic querying. An agent trying to search for a specific clause across hundreds of synced PDFs would have to download every file and process it locally, consuming excessive bandwidth and API tokens. Fast.io solves this with its hybrid search capability, which combines exact full-text matching with semantic retrieval. An agent can call a single search tool to locate matching passages and file contents, receiving citation-backed results instantly. This reduces the number of tokens the agent needs to process, lowering operational costs. The usage-based billing model of Fast.io aligns with this efficiency: instead of paying high per-seat subscription costs for idle users, organizations are billed based on their actual consumption of storage, bandwidth, and AI tokens. The Starter plan starts at $29/mo, the Business plan at $99/mo, and the Growth plan at $299/mo, and each organization begins with a 14-day free trial that requires a credit card. This usage-based credit system ensures that teams pay only for the storage and processing their agents actually use.

Once an autonomous agent finishes building a project, generating reports, or staging files inside a workspace, the next step is delivering that output to human stakeholders. A common bottleneck in developer workflows is the handoff process, where files must be zipped, emailed, or manually uploaded to client portals, losing version control and access records. In an intelligent workspace, the handoff is built into the permission model. An agent can operate inside an organization, create the required workspaces, configure branded client shares, and then perform an ownership transfer. Fast.io allows agent accounts to transfer organization ownership to a human collaborator via a secure claim link. Once the human accepts the transfer, they assume administrative control, while the agent can retain scoped access to continue background updates.

Additionally, teams can use branded shares for Send, Receive, and Exchange workflows. Single-file shares can be configured to expire or remain durable, with per-recipient access grants that can be managed individually. If you need to gather files from clients or partners, guest upload workflows allow external users to upload documents directly into the workspace without creating an account or sending email attachments. For formal approvals, Fast.io features a built-in workflow engine that runs as a directed acyclic graph of steps. You can set up scheduled triggers, event triggers, and routing options to direct files through a four-step review flow: Submit, Review, Approve/Reject, and Complete. A visual dashboard displays all pending approvals and active tasks across every workspace, providing a single surface of what needs attention. Every action taken by both humans and agents is logged in an append-only, immutable audit log, establishing a complete chain of custody for compliance and security reviews.

If the workflow requires signing contracts, native e-signature capabilities allow users to send documents for signature directly from the workspace. Signer routing supports sequential or parallel execution, and signer identities are verified using a one-time passcode. The executed document is automatically returned to the workspace with a tamper-evident audit certificate, ensuring the entire process is self-contained and auditable. By combining local agent execution (using tools like Manus AI or OpenManus) with cloud-based persistent workspaces, teams can automate complex data workflows while maintaining strict control over data governance, security, and human review.