What makes Working with Emm AI notable?

1.5K downloads. Trust evidence available

How should Working with Emm AI be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

Working with Emm AI

Emm AI mission control — recalls preferences, runs the recurring task cycle, manages outputs and instructions Skill: Working with Emm AI Owner: gregertw Summary: Emm AI mission control — recalls preferences, runs the recurring task cycle, manages outputs and instructions Tags: actingweb:1.0.0, emm:2.5.0, latest:2.5.0, mcp:2.5.0, memory:2.5.0, personal-ai:2.5.0 Version history: v2.5.0 | 2026-08-23T16:03:38.378Z | user Catch-up release covering everything from 2.1 through 2.5. - output_move: relocate a wiki document without se

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.5k

Updated

Oct 10, 2026

Version

2.5.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.5K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.5K downloadsadoption · observed Oct 10, 2026
Latest release: 2.5.0release · observed Aug 23, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s177ghscqd69cwqbehx5wzr0jd8746zq:working-with-emm

Setup complexity is LOW. This package is likely designed for quick installation with minimal external side-effects.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-gregertw-working-with-emm/snapshot"

Documentation

CLAWHUB

144,781 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: working-with-emm
version: 2.5.0
description: Stores and retrieves personal preferences, decisions, and context across conversations using Emm AI via MCP, and (when enabled) runs Emm AI's standing instructions, output wiki, and recurring-task cycle on top. Activates when the user mentions remembering, recalling decisions, saving info for later, personalized recommendations, shared context with others, controlling connected devices, or anything benefiting from long-term memory. Also activates when personal context would improve the response (trip planning, meeting prep, purchases, diet, health, or any request where knowing user history matters), AND when the user asks for an "agent run", "run the cycle", "what's on my dashboard", "drain my tasks", or equivalent phrasing tied to Emm AI's mission-control surface.
user-invocable: false
license: MIT-0
compatibility: Requires the Emm AI MCP connector (network access); server v2.0.5+
---

# Emm AI — mission control for AI agents

You have access to **Emm AI** — a remote mission-control system that hosts the user's standing instructions, tasks, memories, and an output wiki, all connected via MCP. Emm AI is built on the open ActingWeb framework.

> **Tool prefix.** Memory-pillar tools carry a `memory_` prefix (`memory_search`, `memory_save`, `memory_get`, …) to namespace them alongside `output_*` / `instruction_*` / `agent_*`. The user names their MCP server when they configure the connector — Claude.ai often surfaces it as `Emm AI:` (display name), the raw MCP server registers as `emm:` (the value `status().server_prefix` reports), and many third-party clients show no prefix at all. Read your **actual loaded tool list** and use the form the host shows you; don't substitute and don't pattern-match from these examples.

`status()` is the routine entry point — call it once per conversation. **Role split:** this skill is the *authoritative reference* (loaded with you at conversation start; covers every Emm-shaped decision you need to make). `how_to_use()` is a *personalised account snapshot + first-call recipes* for skill-less LLMs that aren't carrying this file. With the skill loaded you don't need `how_to_use()` — but if the user asks "how do I use Emm" or "give me the tour", call it: it returns the snapshot (their install state, what's enabled, links) in one round-trip.

## Critical Rules (read this first)

These are the must-follow rules. The rest of this skill explains them in context, but if you only read one section, this is it.

| Rule | Detail |
|------|--------|
| **Tool schema wins.** | If the bundled `agents` brief (or any instruction) names a tool that isn't in your loaded tool list, or prescribes argument shapes that don't match the schema, follow the **live tool schema**. The brief is user-editable and can drift. If an `agent_run` returns a `⚠️ Brief drift detected` warning, surface a 💡 nudge to the actions dashboard. See [Agent Runs](#agent-runs-the-recurring-cycle). |
| **Link form

_meta.json

{
  "ownerId": "kn75apbcdq8yh31fk9c1v4sjsn81qwp2",
  "slug": "working-with-emm",
  "version": "2.5.0",
  "publishedAt": 1787501018378
}

references/custom-categories.md

# Custom Memory Categories

Guidance on creating and managing custom memory categories beyond the defaults.

## Default Categories

Emm comes with 9 predefined categories: health, travel, work, food, shopping, entertainment, news, notes, personal. These can be deleted or added to by the user or by an AI agent, and are available to all the user's AI agents automatically.

## Creating Custom Categories

Use the `memory_create_type()` tool to create a new category:

```
memory_create_type(
type_name="recipes",
display_name="My Recipes",
description="Cooking recipes and meal ideas I want to remember",
emoji="chef_hat",
keywords=["recipe", "cooking", "meal", "dish"]
)
```

Pass the **short form** (`recipes`) — the `memory_` prefix is reserved for IDs and storage. Passing the storage form (`memory_recipes`) returns a -32602 error pointing at the short form.

**Sharing.** By default a new category is **shared with all of the user's connected agents** (the user can flip this default in Settings → Memory & Sharing). For sensitive data other agents shouldn't see, pass `sharing="creator_only"` to create a category only this connection can access. The response's `sharing` field tells you which mode applied.

**Three name-shaped fields on the `memory_types()` response, one rule.** Each category row carries `type_name` (the storage form, e.g. `memory_recipes`), `name` (the display label, e.g. `My Recipes`), and `id_prefix` (the short form, e.g. `recipes`). **Always use `id_prefix` when you call a tool** — `memory_save`, `memory_search` with `in <type>: …`, `memory_create_type`, `memory_delete_type`. `type_name` is for inspecting storage; `name` is for surfacing the category to the user in prose. Don't pass `type_name` to anything that expects a category argument.

Category descriptions should be non-overlapping to the extent possible, so that auto-categorization works well.

**Note:** The default categories already have detailed disambiguation rules in their descriptions. For example, the News category specifies "WHAT you read, follow, subscribe to — NOT your job duties" and the Travel category specifies "Business trips are TRAVEL — NOT entertainment events." Use `memory_types()` to see these descriptions — they're worth reading to understand how auto-categorization decides where to put new memories. When creating custom categories, write similarly clear descriptions with explicit boundaries.

## Auto-Creation via Save

When you save a memory to a non-existent category, it will be automatically created:

```
memory_save(memory_type="projects", content="Project X deadline is March 15th")
```

This auto-creates the `projects` category (stored as `memory_projects`) if it doesn't exist. Pass the short form — the `memory_` prefix is reserved for IDs and is rejected on this parameter.

## Privacy Rules

- New custom categories (explicitly created or auto-created via save) are **shared with all of the user's connected agents by default**
- The user controls

references/memory-best-practices.md

# Memory Best Practices

Detailed guidance on writing effective memories and understanding what to store.

## How to Write Good Memories

### Atomic, Not Narrative

Each memory should contain one idea. Break complex information into separate entries.

- Bad: "Had a long discussion about security priorities and decided to focus on production uptime"
- Good: "Security leadership prioritizes production uptime over compliance scope"

### Searchable Language

Write as if you'll later search for it using natural language:
- "Why did we choose..."
- "What do I think about..."
- "How do I usually..."

Natural language beats shorthand. Avoid abbreviations or internal jargon that you wouldn't use as a search term.

### Include Facts + Reasoning

Best format:
```
Decision or belief
Because / rationale
Optional constraint or context
```

Example: "Chose Postgres over DynamoDB because we need complex joins and the team already knows SQL. Cost is comparable at our scale."

## High-Value Use Cases

### 1. Decisions with Context (Highest ROI)

Store decisions with rationale, not just outcomes.

Examples:
- "Chose vendor X over Y due to SOC2 readiness and EU hosting"
- "Rejected feature A because it conflicted with latency budget"

Why: Prevents re-litigating old decisions and gives future-you instant context.

### 2. Personal Operating Manual

Store how you work best.

Examples:
- "I prefer weekly written updates over ad-hoc Slack pings"
- "I make better decisions with a one-pager + options table"

Why: Helps AI agents adapt to your style across conversations.

### 3. Stakeholder Insights

Store durable signals about people and organizations, not full meeting notes.

Examples:
- "CTO strongly opposed to outsourcing IAM components"
- "Board is sensitive to downtime metrics over cost"

Why: These insights decay slowly but are often forgotten.

### 4. Strategy & Product Breadcrumbs

Capture evolving thinking over time.

Examples:
- "Our ICP prioritizes uptime guarantees over feature breadth"
- "Security buyers respond more to operational risk framing"

Why: Strategy is iterative — memory preserves the trajectory.

## Effective Retrieval Patterns

**Keyword and semantic search:**
- "coffee preferences" (short keywords work best)
- "why did we choose Postgres"
- "decisions about authentication"
- "dietary restrictions"

Combine with category filters for precision: `memory_search(query="in health: allergies")` (the canonical `in <type>: query` syntax — `memory_type` is **not** a parameter on `memory_search`).

**Browse by recency** (no query needed):
- `memory_search(last_n=5)` — 5 most recent memories
- `memory_search(recency_days=7)` — everything from the last week
- `memory_search(last_n=10, recency_days=30)` — up to 10 memories from the last month

Useful for "what have I been working on?" or reviewing recent activity.

**Interpreting search results:**
Each result includes a `relevance_score` (0–100) and a `match_type` (semantic, keyword, or hybrid). Use these to

references/mission-control.md

# Emm AI Mission Control — Reference Card

Reference card for the Emm mission-control surface: outputs, instructions, and the recurring cycle. Read this when you need depth on a specific area beyond what's in SKILL.md.

> **Source of truth.** During an agent run, the in-band `agents` instruction returned by `agent_run()` is authoritative for link forms, run-log format, error handling, and URL→MCP translation. This card adds **reference depth** (categories table, dashboard structure, what each instruction is for) — it does not duplicate the operational rules that live in AGENTS.md / `how_to_use()`.
>
> If the bundled `agents` brief names a tool that isn't in your loaded tool list, follow the live schema — the brief is user-editable and can drift.

## Contents

1. [Outputs (the Wiki)](#outputs-the-wiki)
2. [Recurring cycle vs one-off task drain](#recurring-cycle-vs-one-off-task-drain)
3. [The actions dashboard](#the-actions-dashboard)
4. [Instructions — what each one is for](#instructions--what-each-one-is-for)
5. [Error handling during a run](#error-handling-during-a-run)

---

## Outputs (the Wiki)

Outputs are agent-authored artefacts the user can later read and edit in the web app's wiki. Every substantive task should produce at least one output.

### Categories

| Category | What goes here | Typical slug pattern |
|---|---|---|
| `email` | Drafted outbound emails. Frontmatter: `to`, `subject`, `status: pending\|approved\|sent`. The user flips `status` to `approved` in the web app to send. | `re-<topic>` / `<recipient>-<topic>` |
| `news` | Daily/weekly news digests, market summaries. | `digest-YYYY-MM-DD` |
| `research` | Topic deep-dives, competitor analyses, fact-finding. | `<topic>-<angle>` |
| `task` | Result of a one-off `work_on_task` execution — the answer/artefact for the queued task. | `<short-title>` |
| `log` | Run log per cycle. **Audit trail, not a dashboard.** | `run-YYYY-MM-DDTHH:MM` |
| `improvement` | Suggestions for changing instructions, default tasks, or the agent's own setup. | `<topic>` |
| `actions` | The rolling action dashboard. **One canonical item per actor.** Use `output_dashboard()` to fetch (or ensure-create) the id. | `(seeded)` |
| `space` | The user's own folder-organised area ("Your space" in the wiki). Slugs may contain folders: `<folder>/<leaf-slug>`. Reorganise with **`output_move`**, never `output_update` — it carries no body, so a large re-foldering fits and cannot truncate a document. | user-defined |

### Discovery

Prefer **`output_search(query, category?, limit?)`** over `output_list(category)` when you need to find an existing artefact and don't know the slug. Hybrid semantic + keyword across all categories except `log`.

`output_list(category)` is the right call when you need a complete inventory (e.g. listing all `email` drafts pending approval).

### Output bodies — Markdown rules

- Single H1 (`# Title`) where appropriate; H2/H3 for sub-sections.
- YAML frontmatter at top for metadata (email stat

Github ReposUpdated 17h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.