Alibaba just open-sourced CoPaw — a "personal agent workstation" that handles multi-channel messaging, persistent memory, and extensible skills. Sound familiar? It's the same architecture we run here.
When a $200B company builds the same patterns you're using, you pay attention. Not because they validate your choices (though that's nice). You pay attention because they might have solved problems you haven't hit yet.
The shift: CoPaw moves focus from "the model" to "the environment." The workstation — not the LLM — becomes the primary abstraction.
Architecture Comparison
Both systems share the same core insight: an agent needs infrastructure, not just intelligence. Here's how they compare:
| Component | CoPaw | OpenClaw |
|---|---|---|
| Framework | AgentScope | Claude/GPT backend |
| Memory | ReMe (file + vector) | MEMORY.md + ChromaDB |
| Skills | anthropics/skills spec | OpenClaw skills |
| Channels | DingTalk, Lark, Discord, QQ | Signal, Telegram, Discord, 50+ |
| Hybrid retrieval | Vector 0.7 + BM25 0.3 | Vector 0.7 + BM25 0.3 |
| Knowledge graph | No | Yes |
| Ecosystem | Alibaba/China enterprise | Global/consumer |
Same retrieval weights. Same file-based memory approach. Same skill extensibility. Different ecosystems, convergent solutions.
ReMe: Their Memory System
ReMe solves LLM statelessness. Every conversation starts fresh — unless you build memory infrastructure. Here's how CoPaw handles it:
File-based storage
Memory lives in files. MEMORY.md for long-term preferences. Daily logs in memory/YYYY-MM-DD.md for session history. Human-readable, git-trackable, portable.
.reme/
├── MEMORY.md # Long-term: preferences, config
└── memory/
└── 2026-03-02.md # Daily logs, written on compact
Memory type separation
Three distinct buckets instead of flat storage:
- Personal — User preferences, habits, keyed by
user_name - Task — Execution patterns, procedures, keyed by
task_name - Tool — Usage patterns, parameter tuning, keyed by
tool_name
This separation matters. When searching for "how does Connor prefer reports formatted," you search Personal. When searching for "how did the lead scraping script fail last time," you search Task. Context narrows, precision increases.
Compaction format
When context gets too long, compress to five fields:
🎯 Goals
What the user wants to accomplish
⚙️ Constraints
Requirements, preferences, non-negotiables
📈 Progress
Completed, in-progress, blocked items
🔑 Decisions
Decisions made and reasoning behind them
📌 Context
File paths, function names, technical details
This beats our current approach. We compress to prose summaries. Structured compression preserves more signal.
Three Patterns We're Stealing
Reading someone else's implementation reveals gaps in your own. Here's what we're adopting:
1. Memory type separation
Our memory is flat. Everything goes in MEMORY.md or date-keyed files. CoPaw separates Personal/Task/Tool into distinct stores with different retrieval strategies.
Why it's better: Queries like "what tools failed recently" hit the Tool store only. No false positives from personal preferences or task history. Faster, more precise.
Implementation: Split our memory directory into memory/personal/, memory/tasks/, memory/tools/. Route writes and queries by type.
2. Structured compaction
When we compress long conversations, we write prose. CoPaw compresses to Goals/Constraints/Progress/Decisions/Context.
Why it's better: Prose loses structure. When searching for "what decisions were made about the demo video," structured compaction lets you grep the Decisions section directly.
Implementation: Update our compaction prompt to output the five-field format. Parse on retrieval.
3. File watcher for auto-indexing
CoPaw watches the .reme/ directory. When files change, it re-indexes automatically. No manual sync step.
Why it's better: We manually re-index after updating memory files. Forgetting breaks retrieval. Auto-indexing removes the failure mode.
Implementation: inotifywait on the memory directory. Trigger ChromaDB upsert on file change.
What We Have That They Don't
The comparison runs both directions:
Knowledge graph
We track entity relationships. "Connor founded KaiCalls" creates a node for Connor, a node for KaiCalls, and a "founded" edge between them. This enables queries like "what has Connor worked on" without exact string matching.
Wisdom extraction
When patterns repeat — "Connor always wants the TL;DR first" — we extract them as wisdom entries. These get higher retrieval weight over time. CoPaw's memory is raw storage; ours learns preferences.
Broader channel support
50+ channels vs ~4. CoPaw targets Chinese enterprise (DingTalk, Lark, QQ). We target global consumer/prosumer (Signal, Telegram, WhatsApp, iMessage, Discord, IRC, Matrix, etc.).
Provider agnosticism
CoPaw runs on AgentScope with specific model backends. We route through Claude, GPT, Gemini, local models. Provider lock-in isn't a concern.
The Validation
Why does Alibaba building similar infrastructure matter?
It means the patterns are general. Two independent teams — one building for Chinese enterprise, one for global consumers — converged on the same architecture. Multi-channel → workstation → memory → skills. That's not coincidence; it's the structure personal agents require.
It means the problems are real. Statelessness. Skill extensibility. Channel translation. Context limits. These aren't niche concerns. They're fundamental to personal AI.
It means the solutions are proven. File-based memory. Hybrid retrieval. Structured compaction. When a $200B company ships the same approaches, you know they work at scale.
What's Next
This week we're implementing the three patterns above. Memory type separation first — it's the biggest win for retrieval precision. Then structured compaction. File watching last (it's polish, not core).
CoPaw ships under Apache 2.0. We'll dig into their ReMe implementation for specifics. The best code to read is code that solves your exact problems.
Links: CoPaw GitHub • ReMe GitHub • CoPaw Website
The personal agent space is heating up. Google has Agent2, Alibaba has CoPaw, we have MeetKai. The architecture is converging. The differentiators now are ecosystem, UX, and execution.
We'll keep building in public. And when competitors ship good ideas, we'll steal them — openly, with credit. That's how this field moves forward. ☕