Layer

A local product-decision memory system for AI coding agents.

GitHub · cargo install decision_cockpit --bin mcp

Layer stores documents, decisions, assumptions, evidence, drift signals, and memos. An MCP-capable agent proposes structured candidates and signals; you review and accept them in a built-in dashboard.

The app is not the agent. It is the agent's product-memory operating system.

  Cursor / MCP client
         │
         ▼
    ┌─────────┐     ┌──────────────────┐
    │   mcp   │────▶│ Postgres (Docker)│
    │ binary  │     └──────────────────┘
    └────┬────┘
         │  http://localhost:3000
         ▼
   embedded dashboard

One self-contained binary includes the UI, API, MCP server, and Docker Compose definition. No separate frontend deploy. No env-file required.

Install

Requirements: Docker Desktop (running).

cargo install decision_cockpit --bin mcp

The crates.io package is decision_cockpit; the installed binary is mcp (typically ~/.cargo/bin/mcp).

Connect to Cursor

Add to .cursor/mcp.json (project or global):

{
  "mcpServers": {
    "layer": {
      "command": "/Users/you/.cargo/bin/mcp"
    }
  }
}

Use the full path to your mcp binary. Then enable the server in Cursor Settings → MCP.

On first connect the binary will:

1. Start Postgres via embedded Docker Compose (or reuse an existing container)
2. Run database migrations
3. Serve the review dashboard at http://localhost:3000

Ask the agent to open the dashboard (open_dashboard tool), or visit that URL yourself.

Workflow

Key rule: the agent never writes canonical truth directly. It creates candidates, drift signals, and memo drafts. You confirm what becomes real.

Linking the decision graph

When extracting assumptions, actions, or evidence, include relates_to_decision_id in the candidate payload so accepting auto-links the entity to a decision. Or call create_relation / use the dashboard linker afterward.

Document status

Documents move through new → extracted → archived. Agents can fetch only new documents to avoid re-mining context that was already processed.

MCP tools

Enum values are passed as strings (e.g. candidate_type: decision, assumption, action, evidence).

Example agent prompts

Extraction

Read documents with status "new". For each item found, create extraction candidates.
Do not create canonical decisions directly. For assumptions/actions/evidence, set
relates_to_decision_id in the payload when you know which decision they support.

Drift

Read the latest document, list decisions, inspect their context, and create drift
signals where new evidence contradicts or challenges existing decisions.

Memo

Read relevant memos and decision context, then create or update a memo draft
addressing the acknowledged drift signal. Mark final when complete.

Configuration

All settings are optional — defaults work for local development.

Copy .env.example to .env when developing from source.

HTTP API

The dashboard and api binary share the same REST API at http://localhost:3000.

curl -X POST http://localhost:3000/documents \
  -H "content-type: application/json" \
  -d '{"title":"Sprint notes","source_type":"meeting_note","raw_text":"We agreed to ship MCP-first distribution."}'

Build from source

For contributors or pre-release builds:

git clone https://github.com/Pulko/layer
cd layer

# Dashboard must be built before cargo build (embedded at compile time)
cd frontend && npm install && npm run build && cd ..

cargo build --release --bin mcp

Other binaries:

cargo run --bin api      # HTTP API + dashboard only
cargo run --bin mcp      # MCP + dashboard (stdio)

Dev tips

• Frontend hot-reload: cd frontend && npm run dev with COCKPIT_FRONTEND_DIST=./frontend/dist
• Skip Docker bootstrap: COCKPIT_AUTO_DOCKER=false (bring your own Postgres)

Architecture

src/
  assets.rs       # Dashboard embedded via rust-embed
  bootstrap.rs    # Docker Compose + DB readiness
  domain/         # Entities and enums
  services/       # Business logic (shared by HTTP + MCP)
  http/           # Axum REST API
  mcp/            # MCP tool server (rmcp)
  bin/mcp.rs      # Primary entrypoint
  bin/api.rs      # Standalone HTTP server
migrations/       # SQLx migrations
frontend/         # React dashboard (built into binary)

Both mcp and api link the same library crate. MCP is the intended runtime for agent-driven workflows.

Security

Layer is designed for local, single-user use:

• Dashboard URL is http://localhost:3000; API binds to 0.0.0.0:3000 by default (set API_BIND_ADDR to restrict)
• Uses default Postgres credentials (cockpit / cockpit) suitable for local Docker only
• No authentication layer

Do not expose the HTTP port or database to untrusted networks without hardening.

License

MIT — see LICENSE.