📖 Overview

Mano-P: "Mano" means "hand" in Spanish, and "P" stands for Private. We believe that both individuals and organizations can create their own Private AI, and a bright future of human-machine collaboration is on the horizon.

Mano-P is a GUI-VLA agent project designed specifically for edge devices. It serves both as an open-source project and a hardware product solution. As an open-source project, Mano-P is being released in a phased, progressive manner, targeting three distinct groups of developers. In the first phase, we will open-source the Mano-CUA Skills. This phase is aimed at Agent enthusiasts—such as users of OpenClaw or Claude Code—enabling them to leverage the capabilities of Mano-CUA Skills to construct more intelligent CUA task workflows and overcome the bottlenecks associated with human intervention. In the second phase, we will open-source the local-side models and SDK components of Mano-CUA. This phase targets developers with high security requirements, allowing them to directly utilize GUI-VLA models capable of running inference locally on a Mac mini to build their own custom Skills, Tools, and more; crucially, all your CUA operations will be executed entirely on your local Mac mini and will not be uploaded to external servers. In the third phase, we will open-source the training methodologies and the pruning and quantization techniques used for the Mano-P models. This phase is designed for developers with specific model training needs, empowering them to apply our training methods to create their own on-device GUI-VLA models tailored to their unique requirements.

Regarding our GUI-VLA models—which are capable of running inference directly on Mac mini and MacBook devices—we currently support two deployment methods: First, direct deployment on Mac mini or MacBook models equipped with an M4 chip and 32GB or more of RAM; and second, deployment utilizing a compute stick connected via a USB 4.0 port or higher. We will be releasing detailed instructions for both deployment methods in the near future, and we plan to expand our support to include additional deployment options in the future.

Main Capabilities

• Complex GUI Automation: Autonomously complete complex interface operations containing hundreds of interactive elements
• Cross-System Data Integration: Extract and integrate multi-source data through pure visual interaction without API interfaces
• Long-Task Planning Execution: Support enterprise-level business process automation of dozens to hundreds of steps
• Intelligent Report Generation: Automatically generate structured documents such as data analysis reports and work summaries
• Edge-Native Inference: Efficient on-device execution on Apple Silicon via INT8 activation quantization (Cider)
• Autonomous Application Construction: Drives end-to-end software construction pipelines through visual GUI operation (Mano-AFK)

Technical Background

Mano-P builds upon the complete technical framework of the Mano project (see Mano Technical Report), employing the Mano-Action bidirectional self-reinforcement learning method, three-stage progressive training (SFT → Offline Reinforcement Learning → Online Reinforcement Learning), "think-act-verify" loop reasoning mechanism, and a closed-loop data circulation system to achieve high-precision GUI understanding and operation capabilities. The edge version is optimized through mixed-precision quantization, visual token pruning, and edge inference adaptation, enabling large-scale parameter models to run efficiently on edge devices like Mac mini/MacBook/computing sticks.

🎯 Key Highlights

• #1 on OSWorld Benchmark: Mano-CUA 1.1 achieves 58.2% success rate on OSWorld, ranking first among all specialized GUI agent models, outperforming the second-place opencua-72b (45.0%) by 13.2 percentage points
• Leading on WebRetriever Protocol I: Mano-CUA 1.1 scores 41.7 NavEval, surpassing Gemini 2.5 Pro Computer Use (40.9) and Claude 4.5 Computer Use (31.3)
• Fully Local Execution: Runs inference locally on Apple M4 chip with 32GB RAM (Mac mini or MacBook). No cloud API calls required. All screenshots and task data stay on-device
• High-Performance Inference: Mano-CUA-4B achieves ~80 tokens/s decode on Apple M5 Pro; with Cider's W8A8 activation quantization, prefill speeds up by ~12.7% over the W8A16 baseline
• Autonomous Long-Task Execution: Supports complex business processes with end-to-end automation without internet connectivity
• Edge-Native INT8 Acceleration: Companion Cider SDK adds the W8A8 / W4A8 activation-quantization primitives MLX lacks natively, delivering 1.4x–2.2x prefill speedup over MLX W4A16 on Apple M5 Pro — works with any MLX model, not just Mano-P
• Autonomous Software Construction: Mano-AFK drives a full PRD → code → deploy → test → fix loop using Mano-P as its local vision model for real-browser E2E testing — from a single natural-language prompt to a deployed, tested application, no human in the loop

🎬 Use Case Demonstrations

Scenario 1: Mano-AFK Fully automated application construction

https://github.com/user-attachments/assets/8512ab65-f836-4779-979a-4c636fe61fd2

We demonstrated the fully automated application construction process of Mano-AFK. After receiving natural language requirements, the system sequentially completes requirement clarification, technical architecture design, code generation, local deployment, and multi-level testing (API interface testing, LLM based page visual inspection, and end-to-end GUI automation testing driven by VLA model). When the test fails, the system automatically locates the root cause of the problem, fixes the code, and deploys verification again, iterating until all test cases pass. The entire process does not require manual intervention, and ultimately delivers a runnable application with complete requirement documents and build reports.

Scenario 2: Commercial video intelligent system

https://github.com/user-attachments/assets/04730188-e664-4f92-8ba7-023269880718

We fully demonstrated the actual workflow of a commercial video intelligent system. Starting from the user's command, the system automatically completes the entire process of video generation, uploading, analysis, editing, and secondary evaluation. During the process, the system can autonomously operate web pages and editing software, complete fine operations such as file processing and subtitle modification, and generate analysis reports containing subjective evaluations and objective indicators. By comparing the differences between the initial and refined versions, visually present the overall capabilities and application effects of the system.

Scenario 3: Local model task execution

https://github.com/user-attachments/assets/992f4961-3028-45c9-a7c2-29a8e5bf93a9

Mano-P, The small-sized end side GUI-VLA model can run directly on your computer, supporting direct inference operation on Macmini/Macbook with M4 chip and above, as well as direct operation on plug and play computing power sticks. In the CUA scenario, break through the bottleneck of human participation in the Agent workflow. Mano-P, The first step in leading Private AI.

Scenario 4: Daily Life and Entertainment Applications

https://github.com/user-attachments/assets/ff11fd5b-9ee7-4a74-b8e6-3ad3071d3af8

Mano-P excels not only in enterprise-level business automation but also integrates seamlessly into daily life. This video demonstrates the system's application in Mahjong gameplay: through pure visual understanding of the game interface, it autonomously completes tile recognition, analysis, and decision-making. This case validates Mano-P's general-purpose capabilities beyond work scenarios—from office automation to leisure entertainment, from structured data processing to unstructured game interactions, truly realizing the vision of "Private AI." One model, adapting to every aspect of life and work.

Scenario 5: Mano-AFK × Cider Locally-Accelerated End-to-End App Construction

https://github.com/user-attachments/assets/b987f367-5c47-4659-890b-3e8a6e741603

This video demonstrates the combined capability of Mano-AFK and the Cider inference acceleration SDK. Starting from a single natural-language requirement, Mano-AFK autonomously performs requirement clarification, architecture design, code generation, and local deployment. In the E2E testing stage it drives a real browser through the local Mano-P vision model — accelerated by Cider — to run GUI automation tests; on failure, it localizes the defect, patches the code, and re-verifies until a runnable application is delivered. Cider supplies the INT8 activation-quantization primitives that give Mano-P a substantial prefill speedup on Apple Silicon, so the entire build–test–fix loop runs fully on-device, balancing autonomy, privacy, and performance.

📊 Benchmark Performance

Performance of the Mano series models in multiple benchmarks:

1. GUI Grounding

2. BUA & CUA

3. Perception & Cognition

4. Pruning

5. Context Learning

6. Mano-P Local · Cloud · Qwen3-VL Task Execution

🔧 Skills

Mano-Skill is a desktop GUI automation tool based on the Mano model, driving cross-platform graphical interface operations through natural language. We provide two different usage forms for the same core capability to adapt to different usage scenarios and user groups.

📦 Core Capability Overview

Feature Highlights

• Natural Language Driven: Users describe tasks in natural language, and the system automatically executes GUI operations
• Flexible Inference Modes:
  • Local Mode: Models run locally, data stays on device, fast response
    • Run directly on Mac mini/MacBook (M4 chip or above, 32GB+ RAM)
    • Or use Mano-P computing stick (via USB 4.0 connection)
  • Cloud Mode: Without local model configuration, uses cloud API service (mano.mininglamp.com)
  • System automatically detects local model configuration and seamlessly switches inference modes
• Comprehensive Interaction Support: Click, type, hotkey, scroll, drag, mouse movement, screenshot, wait, app launch, URL navigation
• Cross-Platform Support: macOS (stable), Windows, Linux (Beta)

How It Works

Cloud Mode (Default)

1. Capture current screen screenshot
2. Send screenshot and task description to cloud vision model (mano.mininglamp.com)
3. Cloud model analyzes and returns next action instruction
4. Local client executes operation (click, type, etc.)
5. Loop execution until task completion

Local Mode

1. Capture current screen screenshot
2. Run Mano-P model on local device (Mac mini/MacBook) or computing stick for inference
3. Local model analyzes and returns next action instruction
4. Client executes operation (click, type, etc.)
5. Loop execution until task completion

Data Privacy & Security

Cloud Mode:

• ⚠️ Data Sent: Screenshots and task descriptions sent to mano.mininglamp.com for real-time visual analysis
• ✅ Data Not Sent: Does not access or transmit local files, clipboard contents, system credentials
• ⚠️ Privacy Note: Avoid displaying sensitive documents, chat logs, or credential information on screen when running tasks

Local Mode (Mac mini/MacBook or Computing Stick):

• ✅ Fully Local Processing: All data processing is completed locally, screenshots and task descriptions never leave the device
• ✅ Data Stays on Device: Does not access or transmit any data to external servers
• ✅ Maximum Privacy Protection: Suitable for handling sensitive information and high-security scenarios

General Assurance:

• ✅ Open Source Auditable: Complete source code publicly available for review

🔧 Two Usage Forms

If you want to use Mano-P directly to accomplish GUI automation tasks, here are two different usage forms. Choose the one that best fits your use case.

1️⃣ mano-cua (CLI Command-Line Tool)

Use Case: For human users — developers and advanced users invoking mano-cua directly in a terminal to quickly execute one-off or scripted GUI automation tasks

Installation:

# Install via Homebrew
brew tap Mininglamp-AI/tap
brew install mano-cua

The installation process will automatically:

• Create an isolated Python 3.13 virtual environment
• Install required dependencies (including Tkinter GUI library)
• Configure the executable command to system PATH

Usage:

# Cloud mode (default — no extra setup required)
mano-cua run "Open WeChat and tell FTY the meeting is postponed"
mano-cua run "Search for AI news on Xiaohongshu and display the first post"

# Stop current task
mano-cua stop

mano-cua ships with two inference modes: cloud and local. Cloud is the default; to run Mano-P locally on macOS Apple Silicon, use the --local flag:

# First-time local setup: verify env / install SDK / pull the local model
mano-cua check
mano-cua install-sdk
mano-cua install-model

# Run a task in local mode
mano-cua run "Open Safari and search for Python" --local
mano-cua run "Type hello in the search box" --local --url "https://www.baidu.com" --minimize --max-steps 15

In local mode, Mano-P runs on-device via MLX — screenshots and task descriptions make zero network calls for inference.

Features:

• ✅ Command-line interface, quick invocation
• ✅ Virtual environment isolation, no system Python pollution
• ✅ Suitable for script integration and batch processing
• ✅ Can be embedded in shell scripts
• ✅ Cloud / local inference modes — --local switches to on-device in one flag

Installation & Distribution:

• Homebrew Tap: github.com/Mininglamp-AI/homebrew-tap

2️⃣ mano-skill (ClawHub Skill Form)

Use Case: For AI agents — Claude Code, OpenClaw and similar agents autonomously invoke GUI automation capabilities mid-reasoning to complete user tasks, no manual command execution needed

Installation:

Option 1: Install via Claude Code

In Claude Code, skills exist as "commands". Installation steps:

1. Download the skill zip package from ClawHub
2. After extraction, copy files to Claude Code's commands directory
3. Restart Claude Code or in a new session, the skill will be automatically available

Option 2: Install via ClawHub CLI (Recommended)

Use the ClawHub CLI tool for one-click installation and skill management:

# Install skill
clawhub install mano-cua

# Install specific version
clawhub install mano-cua --version 1.0.0

# Update skill to latest version
clawhub update mano-cua

After installation, start a new Claude Code or OpenClaw session to use.

Prerequisites: ClawHub CLI tool must be installed first. See: OpenClaw Documentation - ClawHub

Usage:

When users make requests to AI agents that require GUI operations, the agent will automatically invoke this skill:

User: "Help me open WeChat, find FTY's chat window, and tell him the meeting is postponed to tomorrow"
Agent: [Automatically invokes mano-skill to complete GUI operation]

Features:

• ✅ Autonomously invoked by AI agents, no manual command execution needed
• ✅ Deeply integrated with agent reasoning capabilities
• ✅ Suitable for complex multi-step task automation
• ✅ ClawHub ecosystem with version management and security scanning

Project Resources:

• Source Code: github.com/Mininglamp-AI/mano-skill
• ClawHub Home: clawhub.ai/hanningwang/mano-cua
• Version: v1.0.0
• License: MIT

⚙️ Permission Requirements (Common to All Forms)

• Screen Recording Permission
• Accessibility Permission (keyboard/mouse control)
• Grant permissions in System Preferences → Privacy & Security

🔒 Security Constraints (Common to All Forms)

• Sensitive or potentially dangerous operations require user confirmation before execution
• Users can stop tasks at any time
• Only one task can run on each device simultaneously
• Only supports primary display (multi-display environment)

📊 Status Panel

When a task is running, a small status panel appears in the top-right corner of the screen to:

• Display real-time task status and progress
• Provide task management functions (pause/stop)
• Remind users that an automation task is running to avoid accidental interference

🔔 Platform Compatibility Note

Beta Version Notice: Mano-Skill is currently in Beta testing phase.

• macOS: ✅ Preferred and most thoroughly tested platform, stable and ready for use
• Windows and Linux: ⚠️ Platform adaptations not yet fully completed, minor issues may occur

We are continuously improving cross-platform compatibility. Feedback is welcome.

🤖 Models

If you want to integrate Mano-P's model capabilities into your own applications, this section provides performance metrics and usage guidelines.

Performance Evaluation

The table below presents actual inference benchmark results of Mano-CUA-4B running on Apple M5 Pro with the Cider inference SDK. Using W8A16 (MLX's native weight-only quantization path) as the baseline — the same reference convention adopted in Cider's quantization benchmark — enabling Cider's W8A8 activation quantization reduces prefill time from 2.839s to 2.519s on the same input, a ~12.7% prefill speedup. For more data, refer to the ⚡ Inference SDK section below.

Model Download:

⚡ Inference SDK

Overview

Cider is an inference acceleration SDK developed on top of MLX for macOS. It provides online activation quantization operators absent in MLX, with custom int-matmul kernels built as MLX custom primitives supporting full lazy evaluation. It also includes service-side extensions and non-intrusive compatibility patches for mlx_vlm (validated on mlx_vlm 0.4.3), including fixes for Qwen3-VL multi-image inference issues related to RoPE position handling and chunked prefill.

Conditional Compilation (M4 / M5)

Cider uses conditional compilation: the INT8 TensorOps C++ extension is only built on Apple M5+.

Override via environment variable:

CIDER_FORCE_BUILD=1 pip install -e .   # Force build (e.g., CI)
CIDER_FORCE_BUILD=0 pip install -e .   # Force skip

Modes

W4A16 and W8A16 are already supported by MLX natively — this SDK provides the missing W8A8 and W4A8 modes that MLX does not implement.

MLX's quantization is weight-only: QuantizedLinear dequantizes weights to FP16 and uses FP16 GEMM. While MLX's Steel NAX templates are generic enough to be instantiated with INT8 types (and would achieve identical raw matmul throughput — see the transparent benchmark), MLX does not provide the quantization/dequantization pipeline needed for actual W8A8 inference. Cider fills this gap with fused quantize-matmul-dequant primitives, implementing online INT8 activation quantization and INT8 TensorOps-based compute for the supported inference paths.

W8A8 Quantization Granularity

Performance (Apple M5 Pro)

Individual Operator Latency

Shape [N=10240, K=2560]

Shape [N=2560, K=10240]

End-to-End VLM

Qwen3-VL-2B

Qwen3-VL-4B

LLM Quantization: Precision vs. Speed Comparison

• 🔗 Repository: github.com/Mininglamp-AI/cider

⚗️ Approach

If you are a researcher or wish to train customized GUI Agent models based on your own data, we plan to open-source the complete Mano-Action training methodology and related tools.

Release Soon

Mano-Action Training Methodology

Mano-Action is a bidirectional self-reinforcement training framework specifically designed for GUI Grounding. Unlike traditional unidirectional prediction methods, Mano-Action achieves more robust interface understanding through Text↔Action cycle consistency learning, enabling the model to master both "locating elements from descriptions" and "describing given elements" simultaneously.

Core Features

• Bidirectional Cycle Learning: Mutual reinforcement between Text → Action and Action → Text
• Three-Stage Progressive Training: Supervised Learning → Offline RL → Online RL
• Closed-Loop Data Generation: Automatically generate high-quality training data for continuous model improvement
• Edge Optimization Adaptation: Includes quantization, pruning, and other edge deployment optimization techniques

Use Cases

• 🎓 Academic Research: Explore new approaches to GUI understanding and multimodal interaction
• 🏢 Enterprise Customization: Train specialized models based on internal enterprise systems
• 🌐 Domain Adaptation: Fine-tune models for specific domains (healthcare, finance, etc.)
• 🔬 Algorithm Innovation: Develop new training techniques building on Mano-Action

🌟 Technical Advantages

Mano-P vs Traditional Solutions CUA Comparison

Core Competitiveness

1. Edge Large Model + Flexible Deployment

   • 4B model runs directly on Mac (M4 chip + 32GB RAM)
   • Large parameter models (72B) supported via computing stick
   • No API key configuration needed, ready out-of-the-box
   • Significant advantage over OpenClaw (requires user model configuration) and Manus (cloud calls)

2. Universal Visual Understanding

   • Pure visual GUI interaction, not limited to browsers and web apps
   • Broader support than OpenClaw (CDP protocol mainly for browsers) and Manus (web apps only)
   • Supports desktop software, 3D applications, professional tools, and non-standard GUIs

3. Offline Long-Task Autonomous Planning

   • Fully offline reasoning for complex business processes
   • Autonomous decision-making and error correction without internet connection
   • Unique advantage over Manus (cloud latency) and traditional RPA (needs preset workflows)

4. Integrated Hardware Deployment

   • Model + computing stick integrated solution, plug-and-play
   • Lowers technical barrier compared to OpenClaw (open-source & free but requires self-deployment)
   • Multiple deployment forms (direct Mac install / plug-and-play compute stick), rapid launch

🔗 Applications

Mano-AFK — an autonomous full-cycle app builder that turns a single natural-language sentence into a deployed, tested, and bug-fixed application. Its E2E testing stage runs by default with Mano-P as the local backend (screenshots and task descriptions stay on-device); it can also switch to cloud mode driven by Anthropic's Claude CUA (requires ANTHROPIC_API_KEY; third-party service with no local alternative). Mano-AFK is a concrete application scenario of Mano-P in real-world software engineering pipelines.

• GitHub: github.com/Mininglamp-AI/mano-afk
• ClawHub: clawhub.ai/hanningwang/mano-afk

CUA Benchmark — Mano-CUA-4B on MacBook Pro M5 (16GB)

The suite evaluates 100 tasks across 5 web applications that were themselves built autonomously by Mano-AFK: TripSplit (expense splitting), md-wechat (Markdown → WeChat formatter), OMS (order management), Family Ledger (household bookkeeping), and Life Dashboard (personal widgets). Each app ships in two variants — a golden build (bug-free, expected verdict PASS, 76 tasks) and a buggy build with specific UI/logic defects injected (expected verdict FAIL, 24 tasks). Accuracy is defined as the share of tasks where the judge's verdict matches the expected label; each project contributes 15–16 golden tasks and 4–5 bug-injection tasks.

Metrics: Accuracy — judge verdict matches expected PASS/FAIL; Steps — actions taken per task; Prefill Speed — token throughput during the prefill phase; Tokens/Step — prompt + generation tokens combined.

Note on W8A8 on this hardware: The W8A8 row runs via Cider for INT8 activation quantization. W8A8 accelerates prefill through INT8 TensorOps, but it must hold both the original and the INT8 weights in memory simultaneously — roughly doubling weight footprint. On a 16 GB unified-memory device, the added pressure can trigger swapping that offsets the prefill gain, which is why W8A8 here lands slightly behind W8A16 on accuracy. At least 4 GB of free memory beyond the model size is recommended to see W8A8's full benefit.

• Benchmark methodology — full test design, task schema, and bug catalog

📄 Technical Papers & Citation

Related Papers

Mano-P is based on the following research work:

1. Mano Series Model Foundation Paper

@article{mano-2025,
  title={Mano Technical Report},
  author={Tianyu Fu, Anyang Su, Chenxu Zhao, Hanning Wang, Minghui Wu, Zhe Yu, Fei Hu, Mingjia Shi, Wei Dong, Jiayao Wang, Yuyang Chen, Ruiyang Yu, Siran Peng, Menglin Li, Nan Huang, Haitian Wei, Jiawei Yu, Yi Xin, Xilin Zhao, Kai Gu, Ping Jiang, Sifan Zhou, Shuo Wang},
  journal={arXiv preprint arXiv:2509.17336},
  year={2025},
  url={https://arxiv.org/abs/2509.17336}
}

2. WebRetriever Benchmark

@article{webretriever-2026,
  title={WebRetriever: A Large-Scale Comprehensive Benchmark for Efficient Web Agent Evaluation},
  author={Wei Dong and Tianyu Fu and Zhe Yu and Hanning Wang and Anyang Su and Zhizhou Fang and Yuyang Chen and Shuo Wang and Minghui Wu and Ping Jiang and Zhen Lei and Chenxu Zhao},
  year={2026},
  note={To be published},
  url={https://github.com/hhhhhhalf/WebRetriever}
}

Academic Collaboration

We welcome collaboration with academia:

• 🔬 Dataset Contribution: Provide new GUI task datasets
• 🤝 Joint Research: Collaborate on edge deployment, quantization optimization, GUI understanding, etc.
• 📚 Benchmarking: Test Mano-P on new evaluation sets

For academic collaboration inquiries, please contact: model@mininglamp.com

❓ FAQ

brew tap Mininglamp-AI/tap && brew install mano-cua

🤝 Contribution Guidelines

We welcome community contributions! If you want to contribute to the project:

1. Fork this repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

Contribution Areas

• 🐛 Bug fixes and issue reporting
• 📝 Documentation improvements and translations
• 💡 New feature suggestions and implementations
• 🧪 Test cases and benchmarking
• 🎨 Application scenarios and demo contributions

📄 License

This project is licensed under the Apache License 2.0.

License Highlights:

• ✅ Commercial use
• ✅ Modification and distribution
• ✅ Patent grant
• ⚠️ Must retain copyright notice
• ⚠️ Must state changes

📮 Contact

• 📧 Email: model@mininglamp.com
• 🏠 Website: https://github.com/Mininglamp-AI/Mano-P
• 💬 Community: (To be added)
• 🐛 GitHub Issues: https://github.com/Mininglamp-AI/Mano-P/issues

🙏 Acknowledgments

Thanks to all developers and researchers who contributed to this project.

Special Thanks:

• Mano project team for providing the technical foundation
• DeepMiner platform for deep integration support
• Edge computing hardware partners
• Open source community contributors

_{Built with ❤️ by the Mano-P Team}