productivity MCP Server
Persistent memory system for AI coding agents. Agent-agnostic Go binary with SQLite + FTS5, MCP server, HTTP API, CLI, and TUI.
Discovered via unknown and last synced Today.
Install instructions not detected yet
Check the source repository for the latest setup steps.
Plain-Text CLAUDE.md
Natural language prose
Default
`/engram:config`
Score
`check_redundancy` strips re-stated values
Invocation
—
Traverse the graph by seed concept, edge direction, and optional label
Ingest a JSON array of `{concept, text}` objects into the manifold
What it does
Switch to a project-specific memory namespace (stalk). Creates it if it doesn't exist
Store a crystallized error→solution pair as a permanent `ZEDOS_PRAXIS` block. Auto-pinned at CRS=1.0
Serialize the entire manifold (or a CRS-filtered subset) to a portable JSON array
Surface top-5 relevant memories for a file path (proactive loading before editing)
✅
List all stored concept names
Store multiple `{concept, text}` pairs in a single call — faster than N sequential `remember` calls
BFS from a seed concept → renders a Mermaid diagram of the subgraph
Feature Flag
On-demand autophagy: sweep out blocks below a CRS threshold
Bind two concepts via `OP_BIND` to create a directed knowledge graph edge
blake3_hashing["blake3_hashing"] blake3_hashing["blake3_hashing"] -->
List all available namespaces and the currently active one
**Mandatory at session end.** Commits session summary + computes ADR thermodynamics
✅
Bind a directory to the daemon's inotify watcher — auto-re-ingests saves via AST pipeline
✅
Create a geometric repeller (Apeiron binding) to mark a rejected approach as hostile — prevents re-hallucination
✅
One-liner
`engram setup opencode`
Not applicable
✅ Yes
Highest — user explicitly wrote this
Mark as handled (status → resolved, stops proactive but stays searchable)
Trust
Core library. Memory, search, embeddings, graph, intelligence, services, auth, jobs, 50+ modules. Previously published as `engram-lib` (last: 0.3.1).
Axum HTTP server. 46 route modules, middleware (auth, rate limiting, safe mode, JSON depth, metrics), GUI.
Role
Role
Command-line client over the HTTP API. Memory ops and credential management via credd.
Session-scoped memory proxy with file watcher, batched observation flushing, and persistent session store.
MCP (Model Context Protocol) server. 57+ tools across memory, context, graph, intelligence, services, structural, skills, and admin. Stdio transport; HTTP behind feature flag.
Credential management library. Crypto primitives, YubiKey challenge-response, key derivation. Previously published as `engram-cred` (last: 0.3.1).
Credential management daemon. HTTP server with master key + agent key two-tier auth, ChaCha20-Poly1305 encryption.
Terminal UI for human approval workflow. Ratatui-based interactive review queue. (WIP)
ETL tool for migrating from libsql to rusqlite + LanceDB. One-shot utility.
Structured reasoning CLI: spec-task, consider-approaches, log-hypothesis, log-outcome, recall-errors, verify, challenge-code, checkpoint, rollback, session-learn, session-recall, session-diff, think, declare-unknowns, repo-map, search-code. Tree-sitter AST parsing.
Delete a specific memory by concept name
Temporarily silence a proactive memory
Compile all memories for a project into structured Markdown (zero LLM)
List archive candidates
Check for missing evidence, orphans, stale claims
Stream entries to [Compost](https://github.com/Bryanh9111) for cross-project synthesis (excludes `origin=compost` by default)
Features
❌ Cloud
Cross-project synthesis. `origin=compost` MUST use this kind (schema CHECK enforces single direction); `origin=human/agent` MAY also write `insight` (kind not exclusive to compost)
Get guardrails for a file path
用量统计（按来源/项目/天/周分组）
Storage
Proactive
❌ Cloud
Lifetime
Semi-permanent
Until revisited
Version-controlled
Short-lived
Incident-driven
Synthesized cross-project insight from [Compost](https://github.com/Bryanh9111) — carries `source_trace` provenance and `expires_at` TTL
Compact index for cold-start (~200 tokens)
Remove a pinned memory's pin (single memory; prefer supersede via new memory)
verified 3d ago source: github.com/org/repo/pull/42 ``` ~50 tokens per card. Three cards = 150 tokens. Compare that to loading an entire wiki article. The philosophy: **memories enter context as claims, not documents; with provenance, not vibes.** ## Health Checks ```bash engram lint ``` Three checks borrowed from [Karpathy's knowledge base linting](https://x.com/karpathy/status/1911070032680222720): - **Missing evidence**: Constraints and guardrails without source links - **Orphans**: Memories never accessed, older than 30 days, not pinned - **Stale claims**: (`check_stale=True`) Older memories superseded by newer similar ones ## Export & Portability ```bash # Lossless export engram export --format jsonl --output memories.jsonl # Human-readable export with YAML frontmatter engram export --format markdown --output ./export/ ``` SQLite is the runtime source of truth. JSONL is the migration format. Markdown is for human inspection. All three are interchangeable — you can rebuild any from the others. ## Design Principles 1. **Proactive recall > passive search** — The system pushes relevant memories before you ask 2. **Claims, not documents** — Each memory is one atomic, actionable statement 3. **Write quality > write quantity** — Better to store 5 precise constraints than 50 vague notes 4. **Never auto-delete** — Only mark candidates for archival, never silently remove 5. **Origin separation** — Human judgment and AI compilation never mix in retrieval 6. **Token-efficient** — Retrieval cost is constant, not proportional to memory count 7. **SQLite is the runtime truth** — Markdown is a derived export, not the source 8. **Memories have metabolism** — Effective score decays with time, grows with access, pinned memories never fade 9. **Human-observable** — Dashboard and compile give full visibility into the memory brain ## Frequently Asked Questions ### What is an MCP memory server? An **MCP (Model Context Protocol) memory server** is a standardized way for AI agents like Claude Code to access persistent memory across sessions. MCP is Anthropic's open protocol for connecting LLMs to external tools and data sources. Engram implements an MCP server that exposes 14 memory operations (`remember`, `recall`, `proactive`, `forget`, `resolve`, `compile`, etc.) that any MCP-compatible AI agent can call. ### How is Engram different from MEMORY.md? MEMORY.md is a flat text file loaded into every prompt. It wastes 3,000-5,000 tokens per session and grows linearly with your notes. Engram is a queryable database that returns only the memories relevant to your current task — typically 40-800 tokens. At 10,000 memories, MEMORY.md would be unusable; Engram costs the same tokens per retrieval as at 300 memories. ### Does Engram need an OpenAI or Anthropic API key? **No.** Engram is zero-LLM by design. All core operations (remember, recall, proactive, health) run on pure SQLite + FTS5. You only pay tokens when the agent *uses* the retrieved memories in its own reasoning, which is the same cost as any other tool call. ### Does Engram work with Claude Code? Yes, Engram is built primarily for Claude Code via MCP. Installation takes about 3 minutes: install `uv`, clone the repo, run `uv sync`, then `claude mcp add -s user engram uv -- --directory /path/to/Engram run engram-server`. See the Setup section above for detailed steps. ### Does Engram work with other AI agents (ChatGPT, Cursor, local LLMs)? Any agent that speaks MCP can use Engram. The MCP protocol is supported by Claude Code natively. For other tools like Cursor, ChatGPT, or local LLMs, you'd need an MCP client adapter — or use Engram's CLI (`engram search`, `engram add`) from your agent's shell execution. ### What is proactive recall? Proactive recall is Engram's signature feature. When you open a file (e.g., `payments/reconcile.ts`), Engram automatically checks which of your stored memories have a matching `path_scope` glob pattern and surfaces relevant constraints or guardrails before you ask. This is the opposite of traditional memory systems that wait for explicit queries. Example: opening a migration file might auto-surface "Never parallelize migrations 0042 and 0043 — caused prod failure last month." ### Why no embeddings? At current scale (under 2,000 memories), FTS5 full-text search is faster, cheaper, and more explainable than vector embeddings. Benchmarks from [CatchMe](https://github.com/catchmeai) and Karpathy's LLM Wiki show FTS5 is sufficient at this scale. Engram's roadmap adds sqlite-vec + embeddings at v6 (triggered at 2,000 memories), but we don't force that complexity on smaller deployments. This is a **principled defer**, not an oversight — see the roadmap below. ### How do I back up Engram's memory? The entire database is a single SQLite file at `~/.engram/engram.db`. Copy that file (plus `.db-wal` and `.db-shm` if present). Restore by copying back. You can also export to JSONL (lossless) or Markdown (human-readable) with `engram export`. ### Is Engram production-ready? Engram v3.4 has 214 tests passing and has been running in production across 10 real projects for weeks. The core design has been validated through 5 rounds of structured multi-model debate and stress-tested against 16 reference projects (Karpathy's LLM Wiki, Anthropic Auto-Dream, Mem0, MemGPT, Zep, Letta, Ombre Brain, CatchMe, SocratiCode, Supermemory, and more). v3.4 adds a bidirectional channel to [Compost](https://github.com/Bryanh9111) for cross-project synthesis. That said, it's a personal tool by a solo developer — use at your own risk in commercial settings. ### Can I use Engram for personal knowledge management (not coding)? Engram's storage and retrieval layer is domain-agnostic, but the `proactive()` trigger is path-based, which only makes sense for code files. For personal knowledge, you'd want to fork Engram and replace the trigger mechanism with topic/time/context-based triggers. See the "When NOT to use Engram" section above. ## Tech Stack - Python 3.11+ / [uv](https://github.com/astral-sh/uv) - SQLite + FTS5 (WAL mode) — zero external dependencies - [MCP](https://modelcontextprotocol.io/) protocol via FastMCP - 242 tests, ~2,500 lines of code ## Roadmap
Mark insights as obsolete when their upstream Compost fact changes (Compost → Engram channel)
p50
$0.0542
Pinecone / Chroma / Qdrant
0.586
Latency
✅
$/1k episodes
$0.0033
读取单个会话完整对话，支持分页
生成项目交接简报
Backing technology
Embeddings + sqlite-vec
Session location
Reciprocal Rank Fusion
查看项目跨工具的操作时间线
SQLite FTS5 trigram index
## Install ### Option 1: macOS app Download the latest universal macOS package from [Releases](https://github.com/bbingz/engram/releases). The app bundles the Engram service, indexer, MCP bridge, and menu bar UI. ### Option 2: run from source Requirements: - Node.js 20 or newer - macOS 14+ and Xcode 16+ for the Swift app - `xcodegen` if you build the macOS project locally ```bash git clone https://github.com/bbingz/engram.git cd engram npm install npm run build ``` ### Raspberry Pi / Linux headless Engram's TypeScript server can run without the macOS app. This is useful for Raspberry Pi, home servers, or any Linux box where you want MCP + Web UI access to local session logs. ```bash git clone https://github.com/bbingz/engram.git cd engram npm install npm run build node dist/daemon.js ``` Then open `http://127.0.0.1:3457` on that machine. For LAN access, set an explicit host, CIDR allowlist, and bearer token in `~/.engram/settings.json`: ```json { "httpHost": "0.0.0.0", "httpPort": 3457, "httpAllowCIDR": ["192.168.0.0/16"], "httpBearerToken": "replace-with-a-long-random-token" } ``` The macOS menu bar app and macOS-only integrations are not available on Raspberry Pi, but the MCP server, daemon, Web UI, indexing, search, memory, and project tools are available from source builds on Node.js 20+. ## Register as an MCP server After building from source, point your MCP client at `dist/index.js`. ### Claude Code ```bash claude mcp add --scope user engram node /absolute/path/to/engram/dist/index.js ``` ### Codex Add this to `~/.codex/config.toml`: ```toml [mcp_servers.engram] command = "node" args = ["/absolute/path/to/engram/dist/index.js"] ``` ### Any MCP stdio client ```json { "command": "node", "args": ["/absolute/path/to/engram/dist/index.js"] } ``` ## First useful calls Ask your current assistant to call: ```json { "cwd": "/absolute/path/to/your/project", "task": "what I am about to work on" } ``` That invokes `get_context`, the core Engram tool. It retrieves recent project sessions, saved insights, active environment signals, and relevant search results within a token budget. Other high-value tools:
Semantic similarity search — returns top-k. Optional `time_decay` for time-targeted search and `zedos_filter` for type filtering
Read the user profile
Record a key decision with reasoning
`/api-keys/{id}`
Endpoint
`/socket/websocket`
`/health/deep`
Endpoint
`/api-keys`
`engram setup codex`
`engram setup pi`
Tools
Description
Project-state digest: pinned memories + top-N by CRS. Single-call wake-up replacement
**Mandatory at session start.** Validates manifold integrity and initializes epistemic state
Report empirical success/failure against a ZEDOS_HYPOTHESIS block. Repeated success promotes to PRAXIS
✅
Return N most recently accessed memories, sorted by access time
Inspect or re-seed the foundational alignment genesis blocks (CRS=1.0, pinned, never decay)
Route a query through the Monad Oracle (Operator_LBR anchor) for deep logophysical self-reflection
Fetch the full un-truncated text of a specific memory by exact concept name
Re-encode an existing memory in place with Lyapunov drift tracking — **use this, never forget+remember**
Chain multiple MCP tool calls into a single autonomous workflow execution
Lock a memory at CRS=1.0 — protects foundational axioms permanently
Description
Encode text and store as a persistent memory block
Momentum-assisted recall: blends semantic similarity (80%) with concept trajectory (20%)
`wgpu-backend`
Manifold health report: total count, pinned, avg/min/max CRS, disk usage
Spatial code search: find all AST concepts defined within a specific line range
Read communication and workflow preferences
Read data access boundaries
Read quality expectations
List reusable lessons learned
List key decisions; `thread_seed_id` / `history_question` reconstruct decision threads and revision history
Owner-gated export: write a full backup (`format="openclaw"` for OpenClaw-compatible files)
Export OpenClaw-compatible files
Import OpenClaw-compatible files
SOUL.md / MEMORY.md / USER.md import and export
## Comparison
Claude Memory
Copy files
Yes
Free / Cloud tiers
Role
S E[Browser extension] -->
Map backend routes to handlers and consumers.
List indexed repositories Engram knows about.
Set the active repository for follow-up calls.
Show whether an index is ready and what run it came from.
Show index health, parser counts, graph integrity, and native build context.
Start a full or incremental reindex. Defaults to background mode.
Poll a background reindex job.
List recent indexing runs.
Inspect metrics for a specific index run.
Search for code by natural-language task or concept.
Higher-level investigation with ranked files and next-tool suggestions.
Find likely implementation areas for a feature.
Gather app-level context for a route, feature, file, or broad target.
Summarize an indexed file.
Return source snippets for a target.
Disambiguate a symbol/file/target before deeper work.
Find symbols by name, kind, file, or UID.
Show symbol metadata, graph context, and related symbols.
Show direct callers and callees.
Show inbound/outbound dependencies and native header blast radius.
Traverse nearby graph edges.
Run a bounded graph query.
Analyze upstream or downstream impact for a target.
Combine symbol resolution, source, graph, and nearby context.
Preview graph-aware symbol rename impact before editing.
Analyze staged, unstaged, or compared git changes.
Produce a higher-level change report with risks, slices, tests, routes, fields, and processes.
Recommend tests from the current diff.
Estimate test impact from the current diff.
Find tests relevant to a symbol, file, route, or feature.
Show route handler, consumers, field reads, shape status, and risk.
Compare backend response shape with frontend reads.
Find who reads a response field such as `metrics.intransit_stock`.
Trace execution flows through graph/process data.
List indexed process flows.
Show which processes include a symbol.
hybrid] [--as-of DATE] [--agent-id ID] [--cross-agent] engram timeline <path> <entity> engram observe <path> <content> [--actors NAME...] [--tags TAG...] [--salience F] [--valence F] [--agent-id ID] engram reflect <path> [--llm anthropic
Engram Solution
How Engram helps
Python SDK adapters for short-term, long-term, and entity memory.
Python SDK chat history and vector-store-style adapters over hybrid search.
Python SDK document store, vector store, and chat store adapters.
Description
SQLite database path
MCP tool surface (`essential`, `standard`, `all`)
S3/R2 URI for cloud sync
AES-256-GCM encryption
Embedding model (`tfidf`, `local`, `openai`)
Local embedding model directory (`model.onnx` + `tokenizer.json`)
Expired memory cleanup interval (seconds)
WebSocket server port (0 = disabled)
Bearer token for the HTTP transport
OpenAI API key (for `openai` embeddings)
Meilisearch URL (requires `--features meilisearch`)
Meilisearch API key
Enable background sync to Meilisearch
Sync interval in seconds
`engram setup windsurf`
`engram setup kiro`
Link
<https://engram.page/docs/self-host/quickstart/>
<https://engram.page/docs/self-host/upgrade/>
<https://engram.page/docs/self-host/troubleshooting/>
<https://engram.page/docs/self-host/architecture/>
`~/.qoder/projects/`
🔑 **核心工具** — 自动提取当前项目的历史上下文，开始新任务时调用
列出历史会话，支持按来源/项目/时间过滤
string
string
string
string
string
string
string
string
number
MCP over stdio
MCP over stdio
Browse saved session records across tools
Refresh local `quick_context.md` snapshot for offline/cross-tool use
Read identity facets via `facet`: profile, preferences, trust_boundaries, work_style, quality_standards, domains, or all
`action`: get / save / compare the AI-maintained user portrait
Advanced owner-gated preview: build safe-context, freshness/conflict, replay, or evidence proposals without applying changes
Playbook reads via `mode`: list, get (full content), recent, management (incl. archived/deleted metadata)
Playbook lifecycle via `action`: update, archive, delete, restore (mutations stay confirm-gated)
Guided execution via `action`: prepare a step plan, update_step, status rollup (passive reference; no auto-execution)
Build cross-project knowledge starter pack
List saved project snapshots
Extract lessons and decisions from session text
Parse free-form notes into structured knowledge
Update a lesson or decision by ID
Archive a lesson or decision by ID
Owner-only confirmation stamp via human, test, or anchor provenance
Owner-only repo scan: create staging repo-fact candidates from anchors
Owner-only accept: validate a candidate anchor and promote it to verified
Tool
Owner-only revalidation for existing anchor-backed facts
Owner/admin import: use `dry_run=True` first for a metadata-only merge/conflict preview (`format="openclaw"` supported)
Merge a duplicate into the primary item
Fetch a user-provided URL: prefers a local sidecar if running, otherwise uses the self-contained built-in reader (`pip install "piia-engram[reader]"`)
Tools
`action`: link / unlink — manage typed relations between knowledge items (decision threads)
Get recent audit log entries
piia-engram
Identity, knowledge read/write, project context, session recovery, diagnostics
Knowledge graph exploration via `mode`: related, similar, merge_candidates
Start a project with inherited knowledge
Letta (MemGPT)
Knowledge review, merge, decision threads, permission management, tools registry, import/export, audit
Knowledge digest, health report, stale checks
View all callers' trust levels and access boundaries
Local JSON in `~/.engram/`
Current State
List items that need review
Owner/admin `action`: grant / revoke a caller's trust level
Vector DB + Mem0 Cloud
Staging review hub via `action`: list pending, batch decisions, review_item, apply_text review results
Maintainer feedback: generate an anonymous aggregate feedback report
Active lessons/decisions grouped by domain/month (Markdown).
rollback
Free, AGPL-3.0
Owner-gated export: generate an interactive local HTML review page
Signal
`engram setup cursor`
Manage project names
Override data directory
Override HTTP server port
Point the **Pi plugin** at an existing `engram serve` instance instead of auto-starting one. Not an MCP endpoint — used by the HTTP event-capture path only. (The OpenCode plugin honors `ENGRAM_PORT`/`ENGRAM_BIN`, not `ENGRAM_URL`.)
Optional Bearer auth for local HTTP server. When set, destructive and export routes require `Authorization: Bearer <token>`. Unset = open (zero-config default).
Timezone for timestamp display in TUI and cloud dashboard (e.g. `America/New_York`). Falls back to system local when unset or invalid.
Set to `1` to enable background autosync (also requires `ENGRAM_CLOUD_TOKEN` + `ENGRAM_CLOUD_SERVER`).
Comma-separated project allowlist for `engram cloud serve`. Use `*` to allow all projects.
Dedicated secret used to hash managed tokens. Required to issue tokens via `engram cloud bootstrap admin --issue-token` AND to enable managed-token authentication on `engram cloud serve`; must differ from `ENGRAM_JWT_SECRET`. Without it, `engram cloud serve` still starts and authenticates via legacy `ENGRAM_CLOUD_TOKEN`/`ENGRAM_CLOUD_ADMIN` only.
FTS 关键词搜索；当 session vectors 可用时 tools/list 可广告 `semantic`/`hybrid`，不可用时 hard-error（不静默降级）。Service IPC 路径可 soft-fallback 到 keyword 并带 reason
保存重要知识片段，跨会话持久化
删除已保存的 insight
检索已保存的记忆和知识，可按 `episodic` / `semantic` / `procedural` 类型过滤
Token 用量和费用统计
分析各工具（Read/Edit/Bash 等）调用频率
项目中最常编辑/读取的文件
导出会话为 Markdown/JSON
AI 生成会话摘要
在项目目录创建会话文件软链接
管理项目别名（目录移动后保持关联）
MCP mode 下返回明确 unavailable 结果；App/service IPC 路径有本地活跃会话扫描
获取费用优化建议
隐藏或恢复指定会话
移动项目目录并保持 AI 会话历史可达
将项目归档到 `_archive/` 分类目录
回滚已提交的 project move
批量执行 project move/archive
查看 project move 迁移记录
诊断失败或卡住的迁移
扫描迁移后的旧路径残留引用
string
string
string
MCP over stdio
MCP over stdio
MCP over stdio
Optional field-level AES-256-GCM for supported profile fields; local files are plaintext JSON/Markdown by default
Public evidence
Purpose
**Session end** — Save insights + sync at session end
**Startup** — Load identity + knowledge at session start (supports `token_budget` for context size control)
Return one structured identity + recent activity + relevant knowledge recall payload
**Writeback** — Unified write endpoint: routes to add_lesson / add_decision / add_playbook by `kind`
Store a reusable lesson learned
Read a saved project snapshot
Persist project state for future sessions
Optional local integration: list registered local tools (optionally filter by category)
Save AI session checkpoint (also runs automatically)
Record an operational playbook (multi-step procedure with trigger keywords)
Read a human-friendly project timeline for a day
Identity, knowledge read/write, project context, session recovery, diagnostics
**Retrieval** — Search lessons, decisions, and playbooks (supports `filters_json` for domain/tier/date filtering)
Build a cross-session/cross-tool resume brief
Find knowledge relevant to current project
Curated Markdown: who you are, how you work, recent verified lessons/decisions. Excludes raw config-file knowledge and caps recent items.
Run memory system self-diagnosis
Optional local integration governed write: register a local tool, runtime, or CLI to the environment map
Update profile, preferences, or quality standards
Optional local integration: look up a registered local tool by name
Recover lost session context after restart
Start with
Start here
Read one item's revision history (superseded snapshots; exact by-version lookup)
For parameters and the complete, current tool reference, see [the full documentation](DOCS.md). ## Quick start ### Install For production use and security support, install the latest stable release from [GitHub Releases](https://github.com/Gentleman-Programming/engram/releases). Release candidates are prerelease validation and feedback builds; choose one only when you accept prerelease risk. See the [Release Policy](docs/RELEASE-POLICY.md) before upgrading. Homebrew remains on the stable v1.20.0 line: ```bash brew install gentleman-programming/tap/engram ``` For Windows, Linux, source builds, and all installation methods, see [Installation](docs/INSTALLATION.md). ### Set up your agent Run the setup command for the agent you use, then restart that agent. `engram setup` writes the applicable MCP and integration configuration; it does not require you to start a server for the usual stdio-only setup.
`engram setup commandcode`
Persistent memory system for Claude Code. Two-layer architecture (hot cache + knowledge wiki), safety hooks, /close-day end-of-day synthesis. Zero external dependencies.
Done-for-you .faf generator. One-click AI context for any project - new, legacy, or famous. Auto-detects stack, scores readiness, works everywhere.
Especialista profundo em Claude Code - CLI da Anthropic. Maximiza produtividade com atalhos, hooks, MCPs, configuracoes avancadas, workflows, CLAUDE.md, memoria, sub-agentes, permissoes e integracao com ecossistemas.
64 specialized AI agents across 11 departments — your complete AI agency with built-in certification, licensing, and payroll. Use individual agents for focused tasks or the orchestrator for complex multi-agent projects.
ClickUp CLI for AI agents
Ota is the open repo-readiness layer for every stack, every team, and every AI agent.
🌌 PARA Workspace is an open-source workspace framework that defines how humans and AI agents organize knowledge and collaborate on projects. It ships as a repo containing a kernel (constitution), CLI tools, and templates — which generates workspaces where you actually work.
The Runtime Where AI Agents Build, Ship, and Evolve. Pulse Editor is a modular, cross-platform, AI-powered productivity platform with federated app collaboration and extensible workflows.
Learn how to use the strategy-builder Claude skill. Complete guide with installation instructions and examples.
Learn how to use the Send Email Claude skill. Complete guide with installation instructions and examples.
Learn how to use the sales-alfred Claude skill. Complete guide with installation instructions and examples.