App Launch · What's New · Learning Results · Install · Quick Start · What Is This · Why It Matters · Ecosystem · Citation

English · 中文摘要

v0.3.8 publishes the Memento-S desktop app as the recommended path for most users. Windows and macOS builds are now available directly from the README, with future product updates continuing through the app.

v0.3.0 focuses on cleaner separation of concerns. The runtime is now organised into a dedicated infrastructure layer, a unified tool registry, and a long-lived agent profile system, so that core agent logic, infrastructure, and tools can evolve independently.

A new top-level infra/ package isolates infrastructure concerns from core/ so that agent logic and platform code can evolve independently.

Tooling has been promoted to a top-level tools/ package with a single ToolRegistry. The previous builtin/tools/ layer has been retired in favour of this unified surface.

core/agent_profile/ introduces persistent profiles that capture an agent's long-term identity, while a matching daemon/agent_profile/ package evolves those profiles in the background.

A new daemon/dream/ package runs background consolidation between sessions, similar to how reflection updates the skill library.

The shared/ package has grown beyond chat utilities into a broader foundation for cross-cutting helpers.

The new layout supersedes several v0.2.0 modules. The v0.2.0 tool_bridge/ layer (runner, bridge, context, args_processor, result_processor) is replaced by the unified tools/ registry. builtin/tools/ (bash, file_ops, grep, python_repl, web) has been moved to tools/atomics/. The monolithic core/skill/execution/executor.py and core/context/manager.py, together with core/context/{block,scratchpad,runtime_state,memory}.py, have been split into tools/, infra/context/, and infra/memory/. IM startup no longer goes through middleware/im/gateway_starter.py and middleware/im/gateway/agent_worker.py; both are removed and replaced by a single EndpointService (server/endpoint/im/) that manages all IM channels and the agent worker. bootstrap.py and middleware/llm/llm_client.py have been reworked to align with this new wiring.

• Modules previously imported from builtin.tools.* are now under tools.* (for example, tools.atomics, tools.mcp, tools.registry).
• Modules previously under core/shared/* (compact, memory, context wiring) now live under infra/*. Update any direct imports accordingly.
• core/manager/ has been removed; conversation and session management now lives in shared/chat/.
• IM channels are now started via EndpointService.start_channel(...) (server/endpoint/im/); direct use of gateway_starter / agent_worker no longer applies.

v0.2.0 is a major architectural upgrade. The core agent, skill system, configuration layer, and deployment surfaces have all been redesigned or significantly extended compared to v0.1.0.

A unified IM Gateway (middleware/im/gateway/) with AgentWorker, ConnectionManager, and platform-specific channels enables real-time message handling across all four platforms.

• Workspace browser — integrated file tree with drag-and-drop and in-place file operations.
• Session management — save, load, rename, and delete conversation history.
• Slash commands — /skills, /context, /compress, /feishu start|stop|status, and more.

• howto.md — a standalone quick-start guide for local source-based deployment.
• requirements-dev.txt — separate dev dependencies.
• 3rd/ — vendored third-party SDKs (WeChat iLink).
• .github/ — CI/CD workflows.

We evaluate Memento-Skills on two challenging benchmarks:

• HLE (Humanity's Last Exam) — a benchmark of extremely difficult questions spanning diverse academic disciplines, designed to probe the upper limits of frontier AI systems on expert-level reasoning and knowledge.
• GAIA (General AI Assistants) — a benchmark for evaluating general-purpose AI assistants on real-world tasks that require multi-step reasoning, web browsing, file handling, and tool use.

Performance improves over multiple learning rounds on HLE and GAIA, while the skill library grows from a small set of atomic skills into a richer set of learned skills. The point is not merely to add more tools. The point is to learn better skills through task experience.

Core question. Memento-Skills is not centred on "how to make an assistant run." It is centred on how to make an agent learn from deployment experience, reflect on failure, and rewrite its own skill code and prompts.

Memento-Skills is a fully self-developed agent framework organised around skills as first-class units of capability. Skills are retrievable, executable, persistent, and evolvable. Instead of treating tools as a flat pile of functions, Memento-Skills treats them as a growing library that can be routed, evaluated, repaired, and rewritten over time.

What makes it interesting is not just whether the agent can call tools. It is what happens after failure. Memento-Skills tries to identify which skill failed, reflect on why it failed, improve or regenerate that skill, and write the improved capability back into the skill library.

Memento-Skills is built around a continual Read -> Execute -> Reflect -> Write loop.

This is the key difference from systems that simply keep accumulating more skills in the workspace. Memento-Skills cares about whether a large skill library can still be retrieved correctly, repaired correctly, and improved continuously.

The two systems share a lot of DNA, but they are not centred on the same question.

• OpenClaw is more about getting an assistant to run in the real world.
• Memento-Skills is more about getting an agent to learn from the real world.

In one sentence: OpenClaw is about getting the assistant running; Memento-Skills is about getting the agent learning.

python -m venv .venv && source .venv/bin/activate && pip install -e . && memento doctor && memento agent

Download the pre-built desktop app — no Python or terminal needed. Install the package for your platform and start using Memento-S directly.

The desktop app is now the recommended path for most users. We will keep shipping product updates through the app, while this repository remains available for developers who want to inspect, extend, or run the source code.

Launch offer: new app users can receive a generous token package during the launch period. Open the app to check the latest campaign details.

For source-based development, continue with the developer quick start below.

git clone https://github.com/Memento-Teams/Memento-Skills.git
cd Memento-Skills
python -m venv .venv
source .venv/bin/activate
pip install -e .

On first launch, ~/memento_s/config.json is created automatically. Fill in your model profile, then start the app:

memento doctor    # Check environment, dependencies, and config validity
memento agent     # Start an interactive agent session in the terminal
memento-gui       # Launch the desktop GUI with chat interface

{
  "llm": {
    "active_profile": "default",
    "profiles": {
      "default": {
        "model": "openai/gpt-4o",
        "api_key": "your-api-key",
        "base_url": "https://api.openai.com/v1",
        "max_tokens": 8192,
        "temperature": 0.7,
        "timeout": 120
      }
    }
  },
  "env": {
    "TAVILY_API_KEY": "your-search-api-key"
  }
}

memento agent             # Interactive agent session
memento agent -m "..."    # Single-message mode
memento doctor            # Environment and config checks
memento verify            # Skill download / audit / execution validation
memento feishu            # Feishu IM bridge
memento wechat            # WeChat personal integration (iLink API)
memento im_status         # IM gateway status
memento-gui               # Desktop GUI

The built-in skills are the starting point, not the end state. The goal is not to freeze the system at ten hand-written skills, but to maintain a skill library that can keep growing, keep being retrieved, and keep being repaired.

Memento-Skills/
├── core/                  # Core agent framework
│   ├── memento_s/         # Agent orchestrator (4-stage ReAct + Finalize)
│   │   ├── phases/        # Intent, Planning, Execution/, Reflection, Finalize
│   │   └── skill_dispatch/ # Skill dispatch and tool routing
│   ├── skill/             # Skill framework
│   │   ├── loader/        # Skill discovery and loading
│   │   ├── retrieval/     # BM25 + vector hybrid retrieval
│   │   ├── execution/     # Sandbox execution + policies
│   │   ├── store/         # Skill persistence backends
│   │   ├── downloader/    # Skill download pipeline (new in v0.3.0)
│   │   ├── market.py      # Skill Market
│   │   └── gateway.py     # Unified skill gateway
│   ├── agent_profile/     # Agent profile system (new in v0.3.0)
│   ├── context/           # Bounded Context management
│   ├── protocol/          # Communication protocols
│   └── prompts/           # Prompt templates
├── infra/                 # Infrastructure layer (new in v0.3.0)
│   ├── memory/            # Long-term and session memory
│   ├── context/           # Context providers
│   ├── compact/           # Context compaction pipeline
│   ├── shared/            # Compact / extract helpers
│   └── service.py         # InfraService entry
├── tools/                 # Unified tool registry (new in v0.3.0)
│   ├── atomics/           # Atomic tools (bash, file, grep, web, repl, mcp)
│   ├── mcp/               # MCP client integration
│   └── registry.py        # ToolRegistry
├── middleware/             # Middleware layer
│   ├── config/            # Config v2 (three-layer isolation)
│   ├── llm/               # LLM client (litellm multi-provider)
│   ├── storage/           # SQLite + SQLAlchemy + vector storage
│   ├── im/                # IM platform middleware
│   ├── sandbox/           # uv sandbox
│   └── utils/             # Environment, path security
├── im/                    # IM platform integrations
│   ├── gateway/           # Gateway mode
│   ├── feishu/            # Feishu
│   ├── dingtalk/          # DingTalk
│   └── wecom/             # WeCom
├── gui/                   # Flet desktop GUI
├── cli/                   # Typer CLI
├── builtin/skills/        # Built-in skills (10)
├── shared/                # Shared layer (expanded in v0.3.0)
│   ├── chat/              # Session and conversation
│   ├── fs/, hooks/, schema/, security/, tools/  # Cross-cutting helpers
├── utils/                 # Shared helpers (runtime_requirements/ new in v0.3.0)
├── daemon/                # Background services
│   ├── agent_profile/     # Soul / user evolver (new in v0.3.0)
│   └── dream/             # Dream consolidation loop (new in v0.3.0)
├── tests/                 # Test suite
├── scripts/               # Build and deployment scripts
├── docs/                  # Documentation
├── 3rd/                   # Third-party SDKs
├── bootstrap.py           # Application initialisation
├── version.py             # Version metadata
├── Figures/               # README figures
└── pyproject.toml         # Project configuration

Memento-Skills is part of the broader Memento project family. Visit the links below to learn more about the full ecosystem and connect with the community.

If you find Memento-Skills useful in your research, please cite:

• Title: Memento-Skills: Let Agents Design Agents
• Authors: Huichi Zhou, Siyuan Guo, Anjie Liu, Zhongwei Yu, Ziqin Gong, Bowen Zhao, Zhixun Chen, Menglong Zhang, Yihang Chen, Jinsong Li, Runyu Yang, Qiangbin Liu, Xinlei Yu, Jianmin Zhou, Na Wang, Chunyang Sun, Jun Wang
• Paper: https://arxiv.org/abs/2603.18743

@article{zhou2026memento,
  title={Memento-Skills: Let Agents Design Agents},
  author={Zhou, Huichi and Guo, Siyuan and Liu, Anjie and Yu, Zhongwei and Gong, Ziqin and Zhao, Bowen and Chen, Zhixun and Zhang, Menglong and Chen, Yihang and Li, Jinsong and others},
  journal={arXiv preprint arXiv:2603.18743},
  year={2026}
}

MIT