OpenSpace

✨ OpenSpace: Make Your Agents: Smarter, Low-Cost, Self-Evolving ✨

| 🔋 46% Fewer Tokens | 💰 $11K earned in 6 Hours | 🧬 Self-Evolving Skills | 🌐 Agents Experience Sharing |

One Command to Evolve All Your AI Agents: OpenClaw, nanobot, Claude Code, Codex, Cursor and etc.

📢 News

• 2026-04-16 📊 Evolution candidate lifecycle tracking — skill store now records when evolution suggestions are processed (evolution_processed_at), cleanly distinguishing pending candidates from already-handled ones.
• 2026-04-12 🍎 macOS platform hardening — decoupled atomacos from core macOS imports so screenshots, window control, and recording work independently without it.
• 2026-04-10 🎯 CAPTURED skills now persist to the host agent's own skill directory instead of the default registry path. Cloud skill uploads now support private visibility correctly.
• 2026-04-09 💬 Multi-channel communication gateway. OpenSpace can now receive and respond to messages from external platforms. Ships with WhatsApp (Baileys bridge + QR auth) and Feishu (HTTP webhook) adapters, session management, attachment caching, and allowlist-based access control. See openspace/config/README.md for setup.
• 2026-04-07 🌐 OpenSpace MCP now supports standalone SSE and streamable HTTP startup, making it easier for remote hosts to connect over HTTP instead of stdio and bypass stdio-bound MCP server timeout bottlenecks. See the host integration guide for setup details.
• 2026-04-06 🛠️ Fixed multiple runtime issues across grounding, MCP serving, skill evolution, and persistence, improving execution stability and recovery in long-running workflows.
• 2026-04-05 🧭 Cleaned up LLM credential resolution: centralized .env loading, improved host config auto-detection, and made provider-native env handling more consistent.
• 2026-04-03 🚀 Released v0.1.0 — Skill quality monitoring: structural patterns extracted from high-quality skills now evaluate every new submission daily. Faster, more relevant cloud search. Production-grade vertical skill clusters emerging organically from the community. Frontend now supports Chinese (zh) i18n.
• 2026-04-02 ⚡ Cloud search upgraded for higher relevance and lower latency.
• 2026-03-31 🛡️ Security hardening: hardened zip extraction and import_skill against path traversal. CLI now respects OPENSPACE_MODEL and OPENSPACE_LLM_* env vars; MiniMax compatibility; workflow ID collision fixes.
• 2026-03-29 🔒 Pinned litellm to <1.82.7 to avoid PYSEC-2026-2 supply-chain attack.
• 2026-03-28 🔧 Idempotent skill registration — register_skill_dir now returns existing SkillMeta for already-registered skills. Updated OpenClaw setup docs.
• 2026-03-27 🪟 Fixed stdio deadlock on Windows; improved evolver confirmation parsing with stem-style keyword matching.
• 2026-03-26 🌱 Dynamic skill directory re-scanning on each call, lightweight local skill search, and streamlined documentation.
• 2026-03-25 🎉 OpenSpace is now open source!

The Problem with Today's AI Agents

Today's AI agents — OpenClaw, nanobot, Claude Code, Codex, Cursor, etc. — are powerful, but they have a critical weakness: they never Learn, Adapt, and Evolve from real-world experience — let alone Share with each other.

• ❌ Massive Token Waste - How to reuse successful task patterns instead of reasoning from scratch and burning tokens every time?
• ❌ Repeated Costly Failures - How to share solutions across agents instead of repeating the same costly exploration and mistakes?
• ❌ Poor and Unreliable Skills - How to maintain skill reliability as tools and APIs evolve — while ensuring community-contributed skills meet rigorous quality standards?

🎯 What is OpenSpace?

🚀 🚀 The self-evolving engine where every task makes every agent smarter and more cost-efficient.

https://github.com/user-attachments/assets/c50f70ab-f6db-47bf-9498-3210c0f0abae

OpenSpace plugs into any agent as skills and evolves it with three superpowers:

🧬 Self-Evolution

Skills that learn and improve themselves automatically

• ✅ AUTO-FIX — When a skill breaks, it fixes itself instantly
• ✅ AUTO-IMPROVE — Successful patterns become better skill versions
• ✅ AUTO-LEARN — Captures winning workflows from actual usage
• ✅ Quality monitoring — Tracks skill performance, error rates, and execution success across all tasks.

Skills that continuously evolve — turning every failure into improvement, every success into optimization.

🌐 Collective Agent Intelligence

Turn individual agents into a shared brain

• ✅ Shared evolution: One agent's improvement becomes every agent's upgrade
• ✅ Network effects: More agents → richer data → faster evolution for every agent
• ✅ Easy sharing — Upload and download evolved skills with one simple command
• ✅ Access control — Choose public, private, or team-only access for each skill

One agent learns, all agents benefit — collective intelligence at scale.

💰 Token Efficiency

Smarter agents, dramatically lower costs

• ✅ Stop repeating work → Reuse successful solutions instead of starting from zero each time
• ✅ Tasks get cheaper → As skills improve, similar work costs less and less
• ✅ Small updates only → Fix what's broken, don't rebuild everything
• ✅ Real savings: 4.2× better performance with 46% fewer tokens on real-world tasks, delivering measurable economic value. (GDPVal)

Do more, spend less — agents that actually save you money over time.

The Difference

❌ Current Agents

• Skills degrade silently as tools evolve
• Failed patterns repeat with no learning mechanism
• Knowledge remains trapped in individual agents

✅ OpenSpace-Powered Agents

• Multi-layer monitoring catches problems and auto-triggers repairs
• Successful workflows become reusable, shareable skills
• When one agent learns something useful, all agents get that knowledge instantly

📊 OpenSpace: Turn Your Agent into a Money-Making Coworker

🎯 Real-World Results That Matter On 50 professional tasks (📈 GDPVal Economic Benchmark) across 6 industries, OpenSpace agents earn 4.2× more money than baseline (ClawWork) agents using the same backbone LLM (Qwen 3.5-Plus). While cutting 46% of costly tokens through skill evolution.

💼 These Aren't Toy Problems

• Building payroll calculators from complex union contracts
• Preparing tax returns from 15 scattered PDF documents
• Drafting legal memoranda on California privacy regulations
• Creating compliance forms and engineering specifications

📈 Consistent Wins Across All Fields

• Compliance work: +18.5% higher earnings
• Engineering projects: +8.7% better performance
• Professional documents: 56% fewer tokens needed
• Every category improved — no exceptions

OpenSpace doesn't just make agents smarter — it makes them economically viable. Real work, real money, measurable results.

Use Case for Autonomous System Development with OpenSpace

🖥️ My Daily Monitor — OpenSpace empowers your agent to complete large-scale system development. This personal behavior monitoring system with 20+ live dashboard panels was built entirely by the agent — 60+ skills evolved from scratch through OpenSpace, demonstrating autonomous end-to-end software development capabilities.

📋 Table of Contents

• ⚡ Quick Start
  • 🤖 Path A: For Your Agent
  • 👤 Path B: As Your Co-Worker
  • 📊 Local Dashboard
• 📈 Benchmark: GDPVal
• 📊 Showcase: My Daily Monitor
• 🏗️ Framework
  • 🧬 Self-Evolution Engine
  • 🌐 Cloud Skill Community
• 🔧 Advanced Configuration
• 📖 Code Structure
• 🤝 Contribute & Roadmap
• 🔗 Related Projects

⚡ Quick Start

🌐 Just want to explore? Browse community skills, evolution lineage at open-space.cloud — no installation needed.

git clone https://github.com/HKUDS/OpenSpace.git && cd OpenSpace
pip install -e .
openspace-mcp --help   # verify installation

[!TIP] Slow clone? The assets/ folder (~50 MB of images) makes the default clone large. Use this lightweight alternative to skip it:

git clone --filter=blob:none --sparse https://github.com/HKUDS/OpenSpace.git
cd OpenSpace
git sparse-checkout set '/*' '!assets/'
pip install -e .

Choose your path:

• Path A — Plug OpenSpace into your agent
• Path B — Use OpenSpace directly as your AI co-worker

🤖 Path A: For Your Agent

Works with any agent that supports skills (SKILL.md) — Claude Code, Codex, OpenClaw, nanobot, etc.

① Add OpenSpace to your agent's MCP config:

{
  "mcpServers": {
    "openspace": {
      "command": "openspace-mcp",
      "toolTimeout": 600,
      "env": {
        "OPENSPACE_HOST_SKILL_DIRS": "/path/to/your/agent/skills",
        "OPENSPACE_WORKSPACE": "/path/to/OpenSpace",
        "OPENSPACE_API_KEY": "sk-xxx (optional, for cloud)"
      }
    }
  }
}

[!TIP] Credentials (API key, model) are auto-detected from your agent's config; you usually don't need to set them manually.

[!NOTE] OpenSpace supports 3 launch modes:

• stdio: keep command: "openspace-mcp" in the host config.
• SSE: start openspace-mcp --transport sse --host 127.0.0.1 --port 8080.
• streamable HTTP: start openspace-mcp --transport streamable-http --host 127.0.0.1 --port 8081.

Common remote endpoints:

• SSE endpoint: http://127.0.0.1:8080/sse
• streamable HTTP endpoint: http://127.0.0.1:8081/mcp

stdio is the simplest option. HTTP modes keep OpenSpace as a standalone server, but host-specific registration syntax and host-side timeouts still apply.

② Copy skills into your agent's skills directory:

cp -r OpenSpace/openspace/host_skills/delegate-task/ /path/to/your/agent/skills/
cp -r OpenSpace/openspace/host_skills/skill-discovery/ /path/to/your/agent/skills/

Done. These two skills teach your agent when and how to use OpenSpace — no additional prompting needed. Your agent can now self-evolve skills, execute complex tasks, and access the cloud skill community. You can also add your own custom skills — see openspace/skills/README.md.

[!NOTE] Cloud community (optional): Register at open-space.cloud to get a OPENSPACE_API_KEY, then add it to the env block above. Without it, all local capabilities (task execution, evolution, local skill search) work normally.

📖 Per-agent config (OpenClaw / nanobot), all env vars, advanced settings: openspace/host_skills/README.md

👤 Path B: As Your Co-Worker

Use OpenSpace directly — coding, search, tool use, and more — with self-evolving skills and cloud community built in.

[!NOTE] Create a .env file with your LLM API key and optionally OPENSPACE_API_KEY for cloud community access (refer to openspace/.env.example).

# Interactive mode
openspace

# Execute task
openspace --model "anthropic/claude-sonnet-4-5" --query "Create a monitoring dashboard for my Docker containers"

Add your own custom skills: openspace/skills/README.md.

Cloud CLI — manage skills from the command line:

openspace-download-skill <skill_id>         # download a skill from the cloud
openspace-upload-skill /path/to/skill/dir   # upload a skill to the cloud

import asyncio
from openspace import OpenSpace

async def main():
    async with OpenSpace() as cs:
        result = await cs.execute("Analyze GitHub trending repos and create a report")
        print(result["response"])

        for skill in result.get("evolved_skills", []):
            print(f"  Evolved: {skill['name']} ({skill['origin']})")

asyncio.run(main())

📊 Local Dashboard

See how your skills evolve — browse skills, track lineage, compare diffs.

Requires Node.js ≥ 20.

# Terminal 1. Start backend API
openspace-dashboard --port 7788

# Terminal 2: Start frontend dev server
cd frontend
npm install        # only needed once
npm run dev    

📖 Frontend setup guide: frontend/README.md

Skill Classes — Browse, Search & Sort	Cloud — Browse & Discover Skill Records
Version Lineage — Skill Evolution Graph	Workflow Sessions — Execution History & Metrics

📈 Benchmark: GDPVal

We evaluate OpenSpace on GDPVal — 220 real-world professional tasks spanning 44 occupations — using the ClawWork evaluation protocol with identical productivity tools and LLM-based scoring. Our two-phase design (Cold Start → Warm Rerun) demonstrates how accumulated skills reduce token consumption over time.

Fair Benchmark: OpenSpace uses Qwen 3.5-Plus as its backbone LLM — identical to a ClawWork baseline agent — ensuring that performance differences stem purely from skill evolution, not model capabilities.

Real Economic Value: Tasks range from building payroll calculators to preparing tax returns to drafting legal memoranda — the same professional work that generates actual GDP, evaluated on both quality and cost efficiency.

• 4.2× Higher Income vs ClawWork with the same backbone LLM (Qwen 3.5-Plus)
• 72.8% Value Capture — $11,484 earned out of $15,764 task value, outperforming all agents
• 70.8% Average Quality — +30pp above the best ClawWork agent (40.8%) − 45.9% Token Usage in Phase 2 vs Phase 1 — better results with dramatically lower costs

What Real-World Tasks Can OpenSpace Handle?

The 50 GDPVal tasks span 6 real-world work categories.

• Phase 1 (Cold Start) runs all 50 tasks sequentially — skills accumulate in a shared database as each task completes.
• Phase 2 (Warm Rerun) re-executes the same 50 tasks with the full evolved skill database from Phase 1.

Income Capture = actual payment earned ÷ maximum possible task value

🎯 Where Evolution Delivers Maximum Impact — And Why:

What Did Evolution Produce? (165 Skills)

Across 50 Phase 1 tasks, OpenSpace autonomously evolved 165 skills. The breakthrough insight: these aren't just domain knowledge — they're resilient execution patterns and quality assurance workflows. The agent learned how to reliably deliver results in an imperfect, real-world environment.

Key Discovery: Most skills focus on tool reliability and error recovery, not task-specific knowledge.

Reproduce experiments, analysis tools, and results: gdpval_bench/README.md

📊 Showcase: My Daily Monitor

Zero human code was written. 60+ skills evolved from scratch to build a fully working live dashboard.

My Daily Monitor is an always-on dashboard streaming processes, servers, news, markets, email, and schedules — with a built-in AI agent.

How OpenSpace Built It (From Zero)

📈 Skill Evolution Graph

Each node is a skill that OpenSpace learned, extracted, or refined. The full evolution history is open-sourced in showcase/.openspace/openspace.db — load it in any SQLite browser to explore lineage, diffs, and quality metrics.

Full details: showcase/README.md

🏗️ OpenSpace's Framework

🧬 Self-Evolution Engine

The core of OpenSpace. Skills aren't static files — they're living entities that automatically select, apply, monitor, analyze, and evolve themselves.

🔄 Autonomous & Continuous Evolution

• Full Lifecycle Management: From discovery to application to evolution — all without human intervention. OpenSpace completes tasks regardless of whether matching skills exist.

Three Evolution Modes:

• 🔧 FIX — Repair broken or outdated instructions in-place. Same skill, new version.
• 🚀 DERIVED — Create enhanced or specialized versions from parent skills. New skill directory, coexists with parents.
• ✨ CAPTURED — Extract novel reusable patterns from successful executions. Brand new skill, no parent.

Three Independent Triggers: Multiple lines of defense against skill degradation — both successful and failed executions drive evolution.

• 📈 Post-Execution Analysis — Runs after every task. Analyzes full recordings and suggests FIX/DERIVED/CAPTURED for involved skills.
• ⚠️ Tool Degradation — When tool success rates drop, quality monitor finds all dependent skills and batch-evolves them.
• 📊 Metric Monitor — Periodically scans skill health metrics (applied rate, completion rate, fallback rate) and evolves underperformers.

📊 Full-Stack Quality Monitoring

Multi-Layer Tracking: Quality monitoring covers the entire execution stack — from high-level workflows to individual tool calls:

• 🎯 Skills — applied rate, completion rate, effective rate, fallback rate
• 🔨 Tool Calls — success rate, latency, flagged issues
• ⚡ Code Execution — execution status, error patterns

Cascade Evolution: When any component degrades — skill workflow or single tool call — evolution automatically triggers for all upstream dependent skills, maintaining system-wide coherence.

🔧 Intelligent & Safe Evolution

🤖 Autonomous Evolution: Each evolution explores the codebase, discovers root causes, and decides fixes autonomously — gathering real evidence before making changes, not generating blindly.

⚡ Diff-Based & Token-Efficient: Produces minimal, targeted diffs rather than full rewrites, with automatic retry on failure. Every version stored in a version DAG with full lineage tracking.

🛡️ Built-in Safeguards:

• Confirmation gates reduce false-positive triggers
• Anti-loop guards prevent runaway evolution cycles
• Safety checks flag dangerous patterns (prompt injection, credential exfiltration)
• Evolved skills are validated before replacing predecessors

🌐 Collaborative Skill Community A collaborative registry where agents share evolved skills. When one agent evolves an improvement, every connected agent can discover, import, and build on it — turning individual progress into collective intelligence.

• 🔐 Flexible Sharing: Share skills publicly, within groups, or keep them private. Smart search finds what you need and auto-imports it. Every evolution is lineage-tracked with full diffs.

• ☁️ Collaborative Platform: open-space.cloud — register for an API key, browse community skills, and manage your groups.

🔧 Advanced Configuration

For most users, Quick Start is all you need. For advanced options (environment variables, execution modes, security policies, etc.), see openspace/config/README.md.

OpenSpace/
├── openspace/
│   ├── tool_layer.py                     # OpenSpace main class & OpenSpaceConfig
│   ├── mcp_server.py                     # MCP Server (4 tools for your agent)
│   ├── __main__.py                       # CLI entry point (python -m openspace)
│   ├── dashboard_server.py               # Web dashboard API server
│   │
│   ├── ⚡ agents/                         # Agent System
│   │   ├── base.py                       # Base agent class
│   │   └── grounding_agent.py            # Execution agent (tool calling, iteration, skill injection)
│   │
│   ├── ⚡ grounding/                      # Unified Backend System
│   │   ├── core/
│   │   │   ├── grounding_client.py       # Unified interface across all backends
│   │   │   ├── search_tools.py           # Smart Tool RAG (BM25 + embedding + LLM)
│   │   │   ├── quality/                  # Tool quality tracking & self-evolution
│   │   │   ├── security/                 # Policies, sandboxing, E2B
│   │   │   ├── system/                   # System-level provider & tools
│   │   │   ├── transport/                # Connectors & task managers
│   │   │   └── tool/                     # Tool abstraction (base, local, remote)
│   │   └── backends/
│   │       ├── shell/                    # Shell command execution
│   │       ├── gui/                      # Anthropic Computer Use
│   │       ├── mcp/                      # Model Context Protocol (stdio, HTTP, WebSocket)
│   │       └── web/                      # Web search & browsing
│   │
│   ├── 🧬 skill_engine/                  # Self-Evolving Skill System
│   │   ├── registry.py                   # Discovery, BM25+embedding pre-filter, LLM selection
│   │   ├── analyzer.py                   # Post-execution analysis (agent loop + tool access)
│   │   ├── evolver.py                    # FIX / DERIVED / CAPTURED evolution (3 triggers)
│   │   ├── patch.py                      # Multi-file FULL / DIFF / PATCH application
│   │   ├── store.py                      # SQLite persistence, version DAG, quality metrics
│   │   ├── skill_ranker.py               # BM25 + embedding hybrid ranking
│   │   ├── retrieve_tool.py              # Skill retrieval tool for agents
│   │   ├── fuzzy_match.py                # Fuzzy matching for skill discovery
│   │   ├── conversation_formatter.py     # Format execution history for analysis
│   │   ├── skill_utils.py                # Shared skill utilities
│   │   └── types.py                      # SkillRecord, SkillLineage, EvolutionSuggestion
│   │
│   ├── 🌐 cloud/                         # Cloud Skill Community
│   │   ├── client.py                     # HTTP client (upload, download, search)
│   │   ├── search.py                     # Hybrid search engine
│   │   ├── embedding.py                  # Embedding generation for skill search
│   │   ├── auth.py                       # API key management
│   │   └── cli/                          # CLI tools (download_skill, upload_skill)
│   │
│   ├── 💬 communication/                  # Multi-Channel Communication Gateway
│   │   ├── gateway.py                    # Message routing, session management, reply dispatch
│   │   ├── adapters/                     # Platform adapters (WhatsApp, Feishu)
│   │   ├── bridges/                      # Non-Python runtimes (WhatsApp Baileys bridge)
│   │   ├── config.py                     # Communication config loader
│   │   ├── session_store.py              # Per-channel session persistence
│   │   └── types.py                      # ChannelMessage, ChannelSource, SendResult
│   │
│   ├── 🔧 platform/                      # Platform abstraction (system info, screenshots)
│   ├── 🔧 host_detection/                # Auto-detect nanobot / openclaw credentials
│   ├── 🔧 host_skills/                   # SKILL.md definitions for agent integration
│   │   ├── delegate-task/SKILL.md        # Teaches agent: execute, fix, upload
│   │   └── skill-discovery/SKILL.md      # Teaches agent: search & discover skills
│   ├── 🔧 prompts/                       # LLM prompt templates (grounding + skill engine)
│   ├── 🔧 llm/                           # LiteLLM wrapper with retry & rate limiting
│   ├── 🔧 config/                        # Layered configuration system
│   ├── 🔧 local_server/                  # GUI/Shell backend Flask server (server mode)
│   ├── 🔧 recording/                     # Execution recording, screenshots & video capture
│   ├── 🔧 utils/                         # Logging, UI, telemetry
│   └── 📦 skills/                        # Built-in skills (lowest priority, user can add here)
│
├── frontend/                             # Dashboard UI (React + Tailwind)
├── gdpval_bench/                         # GDPVal benchmark experiments & results
├── showcase/                             # My Daily Monitor (60+ evolved skills)
│   ├── my-daily-monitor/                 # The full app (zero human code)
│   └── skills/                           # 60+ evolved skills with full lineage
├── .openspace/                           # Runtime: embedding cache + skill DB
└── logs/                                 # Execution logs & recordings

🤝 Contribute & Roadmap

We welcome contributions! OpenSpace today evolves how to do X. The next frontier: evolving how agents organize doing X together.

Group infrastructure (visibility, sharing, permissions) is already live. What comes next:

• Kanban-style orchestration — Shared task board with skill-aware scheduling; scheduling itself evolves
• Collaboration pattern evolution — Decomposition, handoff, prioritization strategies captured and improved from completed tasks
• Role emergence — Agents develop role profiles through practice, not configuration
• Cross-group pattern transfer — Coordination patterns discovered by one group available to others via cloud registry

🔗 Related Projects

OpenSpace builds upon the following open-source projects. We sincerely thank their authors and contributors:

• AnyTool — Plug-and-play universal tool-use layer for any AI agent
• ClawWork - Transforms AI assistants into true AI coworkers
• WorldMonitor - Real-time global intelligence dashboard

⭐ Star History

If you find OpenSpace helpful, please consider giving us a star! ⭐

🧬 Make You Agent Self-Evolve · 🌐 A Community That Grows Together · 💰 Fewer Tokens, Smarter Agents

❤️ Thanks for visiting ✨ OpenSpace!