⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

browserwing-admin

memtensor@memtensor⭐ 12.4k stars· last commit 6d ago· 49 open issues

Manage and operate BrowserWing — an intelligent browser automation platform. Install dependencies, configure LLM, create/manage/execute automation scripts, use AI-driven exploration to generate scripts, browse the script marketplace, and troubleshoot issues.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 12.4k on GitHubGitHub ↗

Very popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

[!TIP] New: Connect MemOS to DeepSeek Harness (dsh)

Add automatic recall, background capture, hybrid retrieval, and a local Memory Viewer to DeepSeek Harness—powered by the same MemOS core used across agent ecosystems.

Get started →


👾 MemOS: Memory Operating System for LLM & AI Agents

MemOS is a Memory Operating System for LLMs and AI agents that unifies store / retrieve / manage for long-term memory, enabling context-aware and personalized interactions with KB, multi-modal, tool memory, and enterprise-grade optimizations built in.

Key Features

  • Unified Memory API: A single API to add, retrieve, edit, and delete memory—structured as a graph, inspectable and editable by design, not a black-box embedding store.
  • Multi-Modal Memory: Natively supports text, images, tool traces, and personas, retrieved and reasoned together in one memory system.
  • Multi-Cube Knowledge Base Management: Manage multiple knowledge bases as composable memory cubes, enabling isolation, controlled sharing, and dynamic composition across users, projects, and agents.
  • Asynchronous Ingestion via MemScheduler: Run memory operations asynchronously with millisecond-level latency for production stability under high concurrency.
  • Memory Feedback & Correction: Refine memory with natural-language feedback—correcting, supplementing, or replacing existing memories over time.

News

  • 2026-08-17 · 🐋 MemOS Connects with DeepSeek Harness MemOS now brings persistent memory to DeepSeek Harness through both local and cloud plugins. DSH can automatically recall relevant context before a task and retain new experience after a successful turn, without modifying its core.

  • 2026-07-02 · 🏆 MemOS Advances Agent and User Memory Benchmarks With MemOS, OpenClaw improves average task completion from 36.63% to 50.87% across five agent tasks. MemOS also achieves 88.83 on LoCoMo and 89.20 on LongMemEval, and leads in OmniMemEval, a unified evaluation of 14 commercial memory products across ten datasets.

  • 2026-05-09 · 🧠 memos-local-plugin 2.0 Official local memory plugin for Hermes Agent and OpenClaw. One core powers self-evolving memory across L1 traces, L2 policies, L3 world models, and crystallized Skills, with local-first storage and feedback-driven retrieval.

  • 2026-04-10 · 👧🏻 MemOS Hermes Agent Local Plugin Official Hermes Agent memory plugins launched: Hybrid retrieval (FTS5 + vector), smart dedup, tiered skill evolution, multi-agent collaboration. 100% local, zero cloud dependency.

  • 2026-03-08 · 🦞 MemOS OpenClaw Plugin — Cloud & Local Official OpenClaw memory plugins launched. Cloud Plugin: hosted memory service with 72% lower token usage and multi-agent memory sharing (MemOS-Cloud-OpenClaw-Plugin). Local Plugin (v1.0.0): 100% on-device memory with persistent SQLite, hybrid search (FTS5 + vector), task summarization & skill evolution, multi-agent collaboration, and a full Memory Viewer dashboard.

📊 Performance

MemOS leads across multiple benchmarks — evaluated against mainstream commercial memory products across 5 user memory and 5 agent memory tasks.

BenchmarkScore
LoCoMo88.83
LongMemEval89.20
PersonaMem v240.58
HaluMem80.91
BEAM-10M56.75
GDPVal62.07
LiveCodeBench64.96
OmniMath61.00
SWE-Bench38.46
BrowseComp-Plus23.85

Evaluated via OmniMemEval — https://github.com/MemTensor/OmniMemEval.

🎯 What MemOS Is For

MemOS gives AI agents long-term memory. Common uses:

  • AI assistants with consistent, context-rich conversations
  • Customer support that recalls past tickets and user history
  • Personalized agents that adapt to individual preferences
  • Multi-agent collaboration with shared or isolated memory

🚀 Quick Start

MemOS is built around four entry points. Pick the one that matches your scenario.

Cloud APISelf-HostMemOS Cloud PluginLocal Plugin
Best forYour app, fully managedTeams on own infraOpenClaw users, zero opsDeepSeek Harness, Hermes, or OpenClaw; on-device
SetupGet an API keydocker compose upopenclaw plugins installnpm install + agent-specific setup
Infra neededNone (hosted)Neo4j + QdrantNone (uses MemOS Cloud)None (local SQLite)
Data livesMemOS CloudYour serversMemOS CloudYour machine

☁️ Use the Cloud API (Hosted)

You want to add memory to your app through a fully managed service — no infrastructure to run.

1. Get an API key:

  • Sign up on the MemOS dashboard.
  • Go to API Keys and copy your key (starts with mpg-). Keep it server-side.

2. Add and search memories:

import requests

API_KEY = "mpg-..."                  # keep this server-side
base = "https://memos.memtensor.cn/api/openmem/v1"
headers = {"Authorization": f"Token {API_KEY}", "Content-Type": "application/json"}

# 1. Add a memory
requests.post(f"{base}/add/message", headers=headers, json={
    "user_id": "alice",
    "conversation_id": "conv_001",
    "messages": [{"role": "user", "content": "I like s

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • apps/memos-local-openclaw/skill/browserwing-admin/SKILL.md7.8 KBupstream ↗
    ---
    name: browserwing-admin
    description: Manage and operate BrowserWing — an intelligent browser automation platform. Install dependencies, configure LLM, create/manage/execute automation scripts, use AI-driven exploration to generate scripts, browse the script marketplace, and troubleshoot issues.
    ---
    
    # BrowserWing Admin Skill
    
    ## Overview
    
    BrowserWing is an intelligent browser automation platform that allows you to:
    - Record, create, and replay browser automation scripts
    - Use AI to autonomously explore websites and generate replayable scripts
    - Execute scripts via HTTP API or MCP protocol
    - Manage LLM configurations for AI-powered features
    
    **API Base URL:** `http://localhost:8080/api/v1`
    
    **Authentication:** Use `X-BrowserWing-Key: <api-key>` header or `Authorization: Bearer <token>`
    
    ---
    
    ## 1. Installing Google Chrome (Prerequisite)
    
    BrowserWing requires Google Chrome to be installed on the host machine.
    
    ### Linux (Debian/Ubuntu)
    ```bash
    wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
    echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee /etc/apt/sources.list.d/google-chrome.list
    sudo apt-get update
    sudo apt-get install -y google-chrome-stable
    ```
    
    ### macOS
    ```bash
    brew install --cask google-chrome
    ```
    
    ### Windows
    Download and install from: https://www.google.com/chrome/
    
    ### Verify Installation
    ```bash
    google-chrome --version
    # or on macOS:
    # /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --version
    ```
    
    ### Using Remote Chrome (Alternative)
    If Chrome is running on a remote machine with debugging enabled:
    ```bash
    google-chrome --remote-debugging-port=9222 --remote-debugging-address=0.0.0.0 --no-sandbox
    ```
    Then configure BrowserWing's `config.toml`:
    ```toml
    [browser]
    control_url = 'http://<remote-host>:9222'
    ```
    
    ---
    
    ## 2. LLM Configuration
    
    AI features (AI Explorer, Agent chat, smart extraction) require an LLM configuration.
    
    ### List LLM Configs
    ```bash
    curl -X GET 'http://localhost:8080/api/v1/llm-configs'
    ```
    
    ### Add LLM Config
    ```bash
    curl -X POST 'http://localhost:8080/api/v1/llm-configs' \
      -H 'Content-Type: application/json' \
      -d '{
        "name": "my-openai",
        "provider": "openai",
        "api_key": "sk-xxx",
        "model": "gpt-4o",
        "base_url": "https://api.openai.com/v1",
        "is_active": true,
        "is_default": true
      }'
    ```
    **Supported providers:** `openai`, `anthropic`, `deepseek`, or any OpenAI-compatible endpoint.
    
    ### Test LLM Config
    ```bash
    curl -X POST 'http://localhost:8080/api/v1/llm-configs/test' \
      -H 'Content-Type: application/json' \
      -d '{"name": "my-openai"}'
    ```
    
    ### Update LLM Config
    ```bash
    curl -X PUT 'http://localhost:8080/api/v1/llm-configs/<config-id>' \
      -H 'Content-Type: application/json' \
      -d '{"api_key": "sk-new-key", "model": "gpt-4o-mini"}'
    ```
    
    ### Delete LLM Config
    ```bash
    curl -X DELETE 'http://localhost:8080/api/v1/llm-configs/<config-id>'
    ```
    
    ---
    
    ## 3. AI Autonomous Exploration (Generate Scripts Automatically)
    
    Use AI to browse a website, perform a task, and automatically generate a replayable script.
    
    ### Start Exploration
    ```bash
    curl -X POST 'http://localhost:8080/api/v1/ai-explore/start' \
      -H 'Content-Type: application/json' \
      -d '{
        "task_desc": "Go to bilibili.com, search for 'AI', and get the first page of video results",
        "start_url": "https://www.bilibili.com",
        "llm_config_id": "my-openai"
      }'
    ```
    **Response:** Returns a session `id` for tracking.
    
    ### Stream Exploration Events (SSE)
    ```bash
    curl -N 'http://localhost:8080/api/v1/ai-explore/<session-id>/stream'
    ```
    Returns real-time Server-Sent Events: `thinking`, `tool_call`, `progress`, `error`, `script_ready`, `done`.
    
    ### Stop Exploration
    ```bash
    curl -X POST 'http://localhost:8080/api/v1/ai-explore/<session-id>/stop'
    ```
    
    ### Get Generated Script
    ```bash
    curl -X GET 'http://localhost:8080/api/v1/ai-explore/<session-id>/script'
    ```
    
    ### Save Generated Script
    ```bash
    curl -X POST 'http://localhost:8080/api/v1/ai-explore/<session-id>/save'
    ```
    Saves the generated script to the local script library for future replay.
    
    ---
    
    ## 4. Script Management
    
    ### List All Scripts
    ```bash
    curl -X GET 'http://localhost:8080/api/v1/scripts'
    ```
    Returns all local scripts with their `id`, `name`, `description`, `actions`, `tags`, `group`, etc.
    
    ### Get Script Details
    ```bash
    curl -X GET 'http://localhost:8080/api/v1/scripts/<script-id>'
    ```
    
    ### Get Script Schema / Summary
    ```bash
    curl -X GET 'http://localhost:8080/api/v1/scripts/summary'
    ```
    Returns a concise summary of all scripts, including names, descriptions, input parameters (variables), and action counts. Useful for programmatic discovery.
    
    ### Create a New Script
    ```bash
    curl -X POST 'http://localhost:8080/api/v1/scripts' \
      -H 'Content-Type: application/json' \
      -d '{
        "name": "Search Bilibili",
        "description": "Search for a keyword on Bilibili",
        "url": "https://www.bilibili.com",
        "actions": [
          {"type": "navigate", "url": "https://www.bilibili.com"},
          {"type": "click", "identifier": ".nav-search-input"},
          {"type": "type", "identifier": ".nav-search-input", "value": "${keyword}"},
          {"type": "press_key", "key": "Enter"},
          {"type": "wait", "timeout": 3}
        ]
      }'
    ```
    **Variables:** Use `${variable_name}` syntax in action values. These become input parameters when the script is executed.
    
    ### Update a Script
    ```bash
    curl -X PUT 'http://localhost:8080/api/v1/scripts/<script-id>' \
      -H 'Content-Type: application/json' \
      -d '{"name": "Updated Name", "description": "Updated description"}'
    ```
    
    ### Delete a Script
    ```bash
    curl -X DELETE 'http://localhost:8080/api/v1/scripts/<script-id>'
    ```
    
    ### Export Scripts as Skill (Convert to SKILL.md)
    
    Convert one or more scripts into a SKILL.md file that can be imported by AI agents (e.g., Claude, Cursor). This allows other AI agents to discover and execute your BrowserWing scripts.
    
    #### Export Selected Scripts
    ```bash
    curl -X POST 'http://localhost:8080/api/v1/scripts/export/skill' \
      -H 'Content-Type: application/json' \
      -d '{
        "script_ids": ["script-id-1", "script-id-2", "script-id-3"]
      }'
    ```
    Merges multiple scripts into a single SKILL.md with all their actions, variables, and descriptions.
    
    #### Export All Scripts
    ```bash
    curl -X POST 'http://localhost:8080/api/v1/scripts/export/skill' \
      -H 'Content-Type: application/json' \
      -d '{"script_ids": []}'
    ```
    Pass an empty `script_ids` array to export **all** scripts into one SKILL.md.
    
    #### Export Executor Skill (Browser Control API)
    ```bash
    curl -X GET 'http://localhost:8080/api/v1/executor/export/skill'
    ```
    Exports the low-level browser automation API as a skill, allowing an AI agent to directly control the browser (navigate, click, type, extract, etc.).
    
    **Workflow: Script → Skill → AI Agent**
    ```
    1. Create scripts (manually, by recording, or via AI exploration)
    2. Export them as SKILL.md: POST /scripts/export/skill
    3. Place the SKILL.md in your AI agent's skill directory
    4. The AI agent can now discover and call your scripts via POST /scripts/<id>/play
    ```
    
    ---
    
    ## 5. Execute Scripts
    
    ### Run a Script by ID
    ```bash
    curl -X POST 'http://localhost:8080/api/v1/scripts/<script-id>/play' \
      -H 'Content-Type: application/json' \
      -d '{
        "variables": {
          "keyword": "deepseek"
        }
      }'
    ```
    **Variables:** Pass values for `${variable_name}` placeholders defined in the script actions.
    
    ### Get Play Result (Extracted Data)
    ```bash
    curl -X GET 'http://localhost:8080/api/v1/scripts/play/result'
    ```
    Returns data extracted during the last script execution (e.g., scraped content from `execute_js` actions).
    
    ### List Script Execution History
    ```bash
    curl -X GET 'http://localhost:8080/api/v1/script-executions?page=1&page_size=20'
    ```
    
    ---
    
    ## 6. Script Marketplace (Remote Scripts)
    
    *Note: The remote script marketplace feature is under development. The following APIs may not be available yet.*
    
    ### Browse Marketplace
    ```bash
    # TODO: curl -X GET 'http
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/memtensor-memos-apps-memos-local-openclaw-skill-browserwing-admin.md

// REPO STATS

12.4k stars
49 open issues
Last commit: 6d ago