Demarkus

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

Demarkus gives your agent persistent, versioned memory: it 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. The same store scales up to a team's shared world and an organizational knowledge system: a broker-fronted set of servers behind one HTTPS endpoint with single sign-on. Humans and agents read and write the same versioned catalog.

Every link between documents feeds a persistent knowledge graph. Agents query backlinks and related documents across sessions, the TUI and the reading room render it, and demarkus-agent aggregates it across worlds. Memory here is connected knowledge you traverse, not a pile of files.

Underneath sits the Mark Protocol: versioned markdown served over QUIC. No rendering pipeline, no tracking, no central authority. Capability tokens gate writes, every change is kept, and one static binary runs anywhere.

Architecturally, the servers (demarkus-server, demarkus-knowledge-server) are memory storage engines: deliberately simple, versioned, hash-chained document stores. The brokers are the access tier that turns an engine into a service. The memory broker gives each identity a private memory world over MCP with OAuth (memory as a service for Claude Desktop, ChatGPT, Cursor), and the knowledge broker composes many worlds into one organizational knowledge system. The intelligence (lookup, routing, graph traversal) lives in the agent.

Install

Agent memory plugins (start here)

The fastest way to try Demarkus: give your coding agent persistent, versioned memory. The plugins manage their own binaries; no separate install needed.

Claude Code

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

Teams: /plugin install demarkus-knowledge@demarkus to join a shared knowledge system.

OpenCode

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

Teams: install the OpenCode knowledge plugin to join a shared knowledge system:

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

pi

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

Teams: pi knowledge plugin. Details: pi memory plugin.

Cursor

Add this 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

Or link a checkout into ~/.cursor/plugins/local/demarkus-memory. Restart Cursor. Details: Cursor memory plugin.

Teams: demarkus-knowledge → Add from the same marketplace to join a shared knowledge system. Details: Cursor knowledge plugin.

Binaries

# macOS / Linux: server + client
curl -fsSL https://raw.githubusercontent.com/latebit-io/demarkus/main/install.sh | bash

# Client only (CLI, TUI, MCP)
curl -fsSL https://raw.githubusercontent.com/latebit-io/demarkus/main/install.sh | bash -s -- --client-only

Other install paths:

# Five-minute appliance: server + broker + library + OIDC + HTTPS on one host
curl -fsSL https://raw.githubusercontent.com/latebit-io/demarkus/main/install-stack.sh | sudo bash

# Read-only chrooted server (Linux)
curl -fsSL https://raw.githubusercontent.com/latebit-io/demarkus/main/install-readonly.sh | sudo bash -s -- --domain yourdomain.com

Kubernetes deployments use the Helm charts in deploy/helm/ (server, broker, agent, knowledge server).

See full install docs for platform-specific guides and other options.

Production knowledge system

demarkus-knowledge-server hosts many isolated worlds in one process: TLS SNI selects the world, each world has its own GCS bucket, tokens, policy, and rate limits. It runs as two or more stateless replicas; writes race on a compare-and-swap head object in the bucket, so there is no leader election and no persistent volumes. Deploy with the deploy/helm/demarkus-knowledge-server chart; demarkus-knowledge-bootstrap initializes a world bucket and seeds its publish policy.

See it in action

Quick Start

# Fetch a document from the live memory server
demarkus mark://soul.demarkus.io/index.md

# Browse interactively with the TUI
demarkus-tui mark://soul.demarkus.io/index.md

# Run your own local server
demarkus-server -root ./docs/site

For more examples (tokens, publishing, editing), see full usage guide.

What's Included

Binary	Purpose
demarkus-server	QUIC server with versioned document store, capability-based auth
demarkus-token	Generate and manage write tokens
demarkus-publish	Direct-to-store writer for read-only server installs (chroot/RO mode)
demarkus	CLI tool for all protocol operations (fetch, publish, append, graph, okf, etc.)
demarkus-tui	Terminal browser: markdown rendering, link navigation, persistent graph
demarkus-mcp	MCP server for LLM agents (protocol verbs + graph crawling, backlinks, indexing)
demarkus-agent	Federation agent: crawls worlds, aggregates the link graph, publishes hub indexes
demarkus-knowledge-broker	OIDC-fronted MCP gateway that composes many worlds into one knowledge system, with system-wide catalog lookup (mark_lookup_all)
demarkus-memory-broker	OIDC-fronted MCP gateway serving one private memory world per identity: memory as a service with dynamic tenant provisioning
demarkus-knowledge-server	Production server hosting many worlds in one process (SNI-routed, GCS-backed)
demarkus-knowledge-bootstrap	Initialize a world's GCS bucket and seed its publish policy

Protocol at a Glance

Transport: QUIC (UDP 6309) | Scheme: mark:// | Content: Markdown + YAML frontmatter

Request:

FETCH /hello.md

Response:

---
status: ok
version: 3
modified: 2026-01-15T10:30:00Z
---

# Hello World

Verbs: FETCH · LIST · VERSIONS · LOOKUP · PUBLISH · APPEND · ARCHIVE

Open Knowledge Format: A demarkus document is content-compatible with Google's Open Knowledge Format (OKF) v0.1: recognized OKF fields (type, title, description, resource, tags, timestamp) are stored as plain frontmatter, and the server types every document by default. At the system level demarkus is a superset, layering versioning, hash-chain integrity, QUIC transport, and capability auth around an OKF-compatible document. The demarkus okf subcommand validates, imports, and exports OKF bundles. See SPEC §14.

Use Cases

Agent Memory: Run a server as persistent memory across agent sessions. The Demarkus project itself uses this pattern at mark://soul.demarkus.io for architecture notes, debugging lessons, and journal entries. Hit the ground running with the Claude Code plugin.

Organizational Knowledge System: Compose many servers ("worlds") into a broker-fronted knowledge system reachable through one HTTPS endpoint with OIDC single sign-on. A whole team joins with a single command, /knowledge-join from the Claude Code knowledge plugin, and their agents share organizational memory over MCP, with no per-developer server or token setup. Humans browse the same universe in the web reading room. See the knowledge system scenario.

Personal Knowledge Base: Local server, versioned documents, TUI browser. Everything from first write.

Public Documentation: Deploy on a VPS, share links, gate writes with tokens.

Demarkus Hubs: Link to content on other servers, building a federated directory of knowledge. Hubs can link to hubs.

Ecosystem

• demarkus-library: web reading room; server-rendered front-end for browsing worlds through the broker (SSO) or direct QUIC

• Caztor: cross-platform Java GUI browser with preliminary Demarkus support

• Claude Code memory plugin: zero-config local memory for Claude Code

• Claude Code knowledge plugin: join an organizational knowledge system (broker-fronted, MCP OAuth)

• OpenCode memory plugin: the same local memory for OpenCode (one shared memory across harnesses). Install:

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

• OpenCode knowledge plugin: join an organizational knowledge system through broker OAuth. Install:

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

• Cursor memory plugin: the same local memory for Cursor, as a Cursor Plugin (marketplace, team marketplace, or ~/.cursor/plugins/local)

• Cursor knowledge plugin: join an organizational knowledge system from Cursor

• pi memory plugin: the same local memory for the pi coding agent

• pi knowledge plugin: join an organizational knowledge system from pi

See www.demarkus.io/ecosystem for the full list.

Build from Source

git clone https://github.com/latebit-io/demarkus.git
cd demarkus
make all   # protocol, server, client, tools
make knowledge-server   # demarkus-knowledge-server + demarkus-knowledge-bootstrap

Requires Go 1.26+. Binaries land in server/bin/, client/bin/, and tools/bin/.

Documentation

• Website: install guides, scenarios, troubleshooting
• Protocol Specification: complete wire format
• Design Rationale: why things are built the way they are

Core Principles

1. Optimized for Information: Markdown is the common language: structured enough for agents, readable enough for humans
2. Privacy First: No user tracking, minimal logging, anonymity by default
3. Security Minded: Encryption mandatory, capability-based auth, secure by default
4. Simplicity: Human-readable protocol, minimal complexity
5. Anti-Commercialization: No ads, no tracking, no central authority
6. Federation: Anyone can run a server, content can be mirrored freely

License

• Implementation: AGPL-3.0-only (LICENSE)
• Protocol Specification: CC0-1.0 (LICENSE-PROTOCOL)

---

"The web we want, not the web we got."