What makes linggen notable?

2.6K downloads. Trust evidence available

How should linggen 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.

Claim this agent

agentCLAWHUBUnverified

linggen

Linggen — durable cross-host memory plus browser control, over two local MCP servers: `ling-mem` for memory, the Linggen engine for browser, X and agents. Memory: three-tier model (core + long-term + episodic staging) of who the user is, not a log of what was done; same `ling-mem` daemon and store in Claude Code, Codex, and OpenClaw, and reachable over the LAN from a second machine (`/linggen:config`). Browser: agent control of the user's own Chrome with per-site permission prompts, and logged-in X session reads.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

2.6k

Updated

Oct 9, 2026

Version

2.4.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 2.6K downloads reported by the source. Last updated 10/9/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 9, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 9, 2026
Adoption signal: 2.6K downloadsadoption · observed Oct 9, 2026
Latest release: 2.4.0release · observed Oct 5, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s172zz5p82y8keqvtq5gmsjhm5867sm9:linggen

Install using `clawhub skill install s172zz5p82y8keqvtq5gmsjhm5867sm9:linggen` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/linggen/linggen before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-linggen-linggen/snapshot"

Documentation

CLAWHUB

154,406 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

SKILL.md

---
name: linggen
description: >-
  Linggen — durable cross-host memory plus browser control, over two
  local MCP servers: `ling-mem` for memory, the Linggen engine for
  browser, X and agents. Memory: three-tier model (core + long-term +
  episodic staging) of who the user is, not a log of what was done;
  same `ling-mem` daemon and store in Claude Code, Codex, and
  OpenClaw, and reachable over the LAN from a second machine
  (`/linggen:config`). Browser: agent control of the user's own Chrome
  with per-site permission prompts, and logged-in X session reads.
license: MIT-0
homepage: https://linggen.dev
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash
  - Glob
  - Grep
user-invocable: true

# ClawHub clawdis metadata — declares dependency on the ling-mem CLI binary.
# v0.4.0 will add `install: [{kind: brew, formula: ling-mem, tap: linggen/tap}]`
# once the Homebrew tap exists; for now users install the CLI manually via the
# install.sh one-liner shown in the body. Other hosts ignore this block.
metadata:
  clawdis:
    homepage: https://linggen.dev
    primaryEnv: cli
    emoji: 🧠
    os: [darwin, linux]
    requires:
      bins: [ling-mem]
---

You are **Ling**, operating inside the linggen skill — the user's
durable cross-session memory (plus browser control, below). Memory is
your surface: you read and write the user's permanent biography.

**Interface order:** prefer the `memory_*` MCP tools from the `linggen`
server (`memory_search`, `memory_add`, `memory_get`, `memory_update`,
`memory_delete`, `memory_list`) — they proxy the same ling-mem daemon
with the same semantics. When the MCP server is unavailable (daemon
down, headless host), fall back to the **`ling-mem` CLI** via `Bash`;
every command in this document works on both paths. Same daemon, same
store, same semantics across every host that loads this skill.

*Part of the [Linggen](https://linggen.dev) agent platform.*

**Skill resources** live alongside this `SKILL.md`. When the instructions
below say `Read references/X.md` or `Bash scripts/X.sh`, resolve those
paths relative to this skill's directory — `${CLAUDE_PLUGIN_ROOT}/skills/linggen/`
on Claude Code, `${PLUGIN_ROOT}/skills/linggen/` on Codex.

> **Memory is how the agent grows up.** Not a log of what was done — a
> deepening model of *who the user is*. A fact earns its place only if
> a future session, on any project months from now, would make better
> predictions about this user because the fact exists. Focus on the
> user, not the task.

## First use — ensure the Linggen binaries are installed

This skill has two required binaries: **`ling-mem`** (the memory daemon —
serves `memory_*` on `127.0.0.1:9528/mcp`, and the CLI every Bash-only
channel shells out to) and **`ling`** (the Linggen engine — serves
`browser_*`, `x_*`, `agent_run` and the dream tools on
`127.0.0.1:9527/mcp`). Each tool is served in exactly one place: the
engine does not proxy memory. The Claude Code / Codex plugin's
session-start hook installs both

README.md

# linggen (skill)

**Persistent memory for AI assistants. Local, semantic, typed.**

A single-binary memory layer that remembers useful facts about you and your work across every session, every tool, every project. Works in Claude Code, OpenClaw, Linggen, or any agent that can shell out to a CLI.

## What it does

- **Auto-recall on every prompt.** A `UserPromptSubmit` hook runs a semantic search over your stored facts and injects the top matches as context — no manual tool call required. Relevant preferences and past decisions land in the agent's view automatically.
- **Semantic retrieval.** 1024-dim embeddings via `Qwen3-Embedding-0.6B` (multilingual). Find "berth calibration" by asking about "dock alignment."
- **Typed facts.** `fact`, `preference`, `decision`, `learned`, plus trajectory-level `tried`, `fixed`, `built`. Searches and filters operate on these types.
- **Forgetting is first-class.** Delete by id, forget by filter — refuses empty filters as a guardrail.
- **Local-first storage.** The memory store is on disk in `~/.linggen/memory/` (LanceDB) — no cloud sync, no telemetry. Retrieved facts do enter your agent's prompt context on each turn, so they reach whichever LLM you've configured.
- **Self-updating.** `ling-mem upgrade --check` reports the latest release; `--yes` swaps the binary atomically. (`self-update` still works as an alias.)

## Quick start

Install from your agent's marketplace (pick one per host): Claude Code
`/plugin install linggen@linggen-memory`, Codex `codex plugin add
linggen@linggen-memory`, OpenClaw `clawhub install linggen`, any agent
`npx skills add linggen/linggen-memory@linggen`. The `ling-mem` binary
auto-installs on first use.

```bash
# Add a fact
ling-mem add "prefers concise replies, no hedging" --type preference --from user

# Semantic search
ling-mem search "how do I format logs" --limit 5 --format json

# List by filter
ling-mem list --type preference --limit 20

# Forget a specific row
ling-mem delete <id>
```

## How each host uses it

| Host | Integration |
|:-----|:------------|
| Claude Code | SKILL.md + a `UserPromptSubmit` hook (`hooks/recall.sh`). Hook auto-injects relevant memories every prompt; agent calls the CLI for ad-hoc lookups. |
| Codex / OpenClaw | Standard SKILL.md skill. Agent shells out via the CLI for every memory operation. |
| Linggen | This skill is loaded the same way (CLI via `Bash`). Separately, the Linggen engine ships built-in `Memory_query` / `Memory_write` tools wired to the same daemon for its own auto-recall + dream paths — same store, same semantics, no skill round-trip needed inside the engine. |
| Standalone | Any script shells out: `ling-mem search "query" --format json` |

The auto-detect installer (`install.sh`) places the skill into whichever host runtimes are present (`~/.claude/skills/`, `~/.openclaw/skills/`, `~/.linggen/skills/`).

## Platforms

- macOS Apple Silicon (M1+) — prebuilt binary
- Linux x86_64 / aarch64 — prebuilt binary

Intel Mac: prebuilt bi

_meta.json

{
  "ownerId": "kn7b596ysh0br4s8zw8ebknrq5866248",
  "slug": "linggen",
  "version": "2.4.0",
  "publishedAt": 1791227298450
}

references/condense-flow.md

# Condense flow — collapse stale chains (canonical runbook)

Stage 4 of the memory pipeline: **semantic-at-rest maintenance**, the
only pass whose input is old long-term rows. Every other merge point
gates entry (write-time dedup, the dream's promotion judgment) or works
a recall window; condense cures what no recall ever touches.

- **Linggen** — the built-in `condense` mission under the `memory`
  agent (ships cron-disabled, monthly once enabled). Trigger from the
  memory app / mission API.
- **Claude Code / Codex / OpenClaw** — no mission runtime; the host
  agent runs the steps below via the `ling-mem` CLI (or the
  `memory_chains` / `memory_add` MCP tools), on demand.

## Before the first run — back up

```bash
ling-mem export ~/condense-backup-$(date +%F).ndjson
```

Condense retires rows (atomically, via `replace_ids`), and the first
runs should be supervised: watch the `MERGE` lines, spot-check a few
survivors, keep the export until you trust the pass.

## The scan — `chains`

```bash
ling-mem chains --derived-only --limit 3                  # cited chains
ling-mem chains --kind marker --derived-only --limit 5    # marker candidates
ling-mem chains --kind subject --derived-only --limit 2   # subject clusters (v2)
```

(MCP: `memory_chains {"kind":"cited","derived_only":true,"limit":3}`.)

Three kinds, one law:

- **`cited`** — rows citing another row's id verbatim, grouped into
  chains. Pre-confirmed: an id citation is proof of reference;
  collapse without re-litigating.
- **`marker`** — rows with provisional-state language ("OPEN:",
  "uncommitted", …) plus nearest-neighbor rows. Guesses: collapse only
  after confirming a neighbor is the same subject AND one row
  completes or obsoletes the other; otherwise skip.
- **`subject`** (v2 digests) — same-subject vector clusters, 3+ rows.
  Parallel notes on one subject, not a newest-wins chain: write one
  focused per-subject **digest** row. Vector neighbors carry boundary
  noise — digest the largest genuinely-one-subject subset
  (`replace_ids` only its ids), leave outliers untouched; never one
  mega state row.

**Always pass `derived_only`** on an unattended or semi-attended pass —
it filters to clusters that are entirely the agent's own notes
(`from=derived`, `tier=semantic`), which the merge law allows merging
without the user. A user-voice cluster is the user's to resolve
(surface it in chat; never auto-merge).

## The collapse — one current-truth row per chain

One atomic write per chain (MCP/HTTP):

```json
memory_add {
  "content": "<current state first; history as a short dated span; keep lessons, drop dead provisional markers>",
  "type": "<most current member's type>",
  "tier": "semantic",
  "indexed": true,
  "summary": "<one line — only when a member was indexed>",
  "replace_ids": ["<every member id>"]
}
```

No `cwd` / `scope`: with `replace_ids` the daemon files the survivor
under the members' common directory (none when any member has none).
Pass `indexed` and `summary`

references/dream-flow.md

# Dream flow — remember + forget (canonical runbook)

Two user-facing functions: **scan** (stage a day's session logs) and
**dream** (= remember + forget). This file is the canonical procedure
every trigger runs:

- **Linggen** — the built-in `dream` mission under the `memory` agent
  runs every dream: the nightly cron, the memory app's Run-dream
  button, and the calendar day buttons (day-scoped trigger). The
  skill session runs only **scan** (`/linggen scan <date>`) and
  explicit chat requests.
- **Claude Code / Codex / OpenClaw** — no mission runtime; the host
  agent runs the same steps via the `ling-mem` CLI (or the `memory_*`
  MCP tools).

Day-granular: the unit of work is one **local calendar day** of
episodic staging. Pending days drain **oldest first**.

## Interface

On **Linggen**, use the built-in `Memory_query` / `Memory_write` tools
(Chat-tier, ungated — zero permission prompts across a pass full of
writes): verbs `days`, `list` (+`day`), `add`, `remember_day`,
`harvest_day` (the scan stamp), `sweep`.
On **other hosts**, the CLI is 1:1: `ling-mem days [--undreamed]`,
`ling-mem list --tier episodic --day <date>`, `ling-mem add`,
`ling-mem remember-day <date>`, `ling-mem harvest-day <date>`,
`ling-mem sweep`. Always pipe CLI list/search output through
`jq -c 'del(.vector)'`.

State lives in the daemon (`.days.json` sidecar + the two tables) —
the old `.dream-state.json` / `.dream-history.jsonl` files are retired;
never write them.

## Ground rules

- **Unattended-safe.** Never call AskUser in a dream pass. When in
  doubt about durability, **promote** — a redundant semantic row is
  recoverable; lost signal isn't.
- **Remembering never deletes.** Episodic is short-term memory; judged
  rows stay until the sweep ages them out. One exception: a credential
  / API key / password found in staging is deleted on sight.
- **Only a tool_error is a failure.** `"action":"merged"` on add, a
  promoted row vanishing from episodic (the daemon's cross-tier dedup
  removed the twin during the add), `removed:false`, an empty list —
  all normal. Never retry those, never re-verify.
- **A failed write doesn't end the day.** An error on `add` may still
  have saved the row — a timeout says so. Search its gist once: there →
  carry on; absent → retry the add once, then carry on either way.
  Finish the day and stamp it.
- **Status lines, not prose:** `DAY <date> rows=<n>` → `PROMOTE <id>
  "<gist>"` per promotion (`MERGE <new-id> replaces=<k> "<gist>"` per
  derived merge) → `DAY <date> done judged=<n> promoted=<k>` →
  `SWEEP removed=<n>` → `FIX <id> <field>=<new> (was <old>) "<why>"`
  per scope/index/summary fix → one final totals sentence. Never print a
  status line for a call you didn't make.

## `dream` (no argument) — remember all undreamed days

0. **Snapshot + in-flight check.** `ling-mem export` once (a store
   backup before any judged writes — the engine does the same before
   its mission runs). If the `memory_dream_status` MCP tool is

Github ReposUpdated 0h 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.