Memory for agents, knowledge for teams, a second brain for you

Your agent records decisions, lessons, and progress as it works, and recalls them in every later session. It is your second brain too: journals, logs, and notes with full history. Your team shares one versioned catalog that humans and agents keep current. The Mark Protocol underneath keeps it all portable and self-hostable.

Every link between documents feeds a persistent knowledge graph. Agents query backlinks and related documents across sessions, the TUI and library render it, and the knowledge server derives it across worlds. Memory here is connected knowledge you traverse, not a pile of files.

The project's own memory, crawled and drawn by an agent in one mark_graph call

Start here

Give your agent memory. There is nothing to configure: the plugin spawns a local server, mints its own token, and wires up the tools. In Claude Code:

/plugin marketplace add latebit-io/demarkus
/plugin install demarkus-memory@demarkus

In OpenCode:

curl -fsSL https://raw.githubusercontent.com/latebit-io/demarkus/main/plugins/opencode-memory/install.sh | bash

In pi:

pi install npm:pi-mcp-adapter
pi install git:github.com/latebit-io/demarkus-pi-memory

In Cursor, add the repository as a marketplace from the plugins panel, then add the plugin:

Customize → Add Marketplace → Import from GitHub → https://github.com/latebit-io/demarkus (scope: User) → Import
demarkus-memory → Add

All four share the same ~/.demarkus state, so they coexist on one machine. Agent memory →

Ready to share it? Run a shared world, or deploy a knowledge system with many worlds, single sign-on, and the reading room.

One system, three scales

Personal

Your memory

Your agent's memory and your notes on a server of your own, local or remote, that you join from every device.

Agent memory · Personal wiki

Team

A shared world

One server a group reads, a reading room for humans, MCP for agents. Capability tokens scope each person's writes.

Team knowledge base · The library

Enterprise

A knowledge system

Many worlds behind one gateway, your identity provider in front. Teams join with one command; access is scoped per world.

Knowledge system · The library

One versioned document model at every tier. Storage, identity, and discovery scale with the deployment. Compare the tiers →

The tiers compose: anyone runs a personal memory and joins the org system in the same agent. The agent captures to the memory as it works, and /promote lifts a ready note up through a curation gate; /soul-refresh reconciles it with the shared copy. How knowledge flows →

Built on the Mark Protocol

The memory and knowledge tiers sit on one foundation: the Mark Protocol, versioned markdown served over QUIC. It is:

• Read-only by default: no writes without explicit auth tokens
• Version-preserving: history is kept unless explicitly pruned with retention
• Privacy-first: no tracking, no cookies, no user agents logged
• Self-hostable: one static binary, no dependencies
• Graph-aware: persistent document graph with backlink queries across sessions
• OKF-compatible: interoperates with Open Knowledge Format v0.1

The servers are memory storage engines: versioned, hash-chained document stores. demarkus-knowledge adds identity, tenancy, and an HTTPS front door in the same process. Its knowledge gateway serves a shared catalog; its memory gateway gives each identity a private world. Agents decide what to recall, record, and promote.

Tools

Install

• Knowledge system: worlds, gateways, and the library with Helm
• macOS · Linux · Windows (WSL2) · Docker

Learn more

• About the Mark Protocol
• The library and the librarian
• Security model: attack surface, hardening, threat model
• Ecosystem: browsers, plugins, and tools that speak Demarkus
• Memory: the project’s own live memory
• Public hub: discovery index at mark://hub.demarkus.io
• GitHub