MCP Server · 15 tools · Free

Your AI remembers now.
For real.

Persis gives Claude persistent memory that learns from experience, forgets what doesn't matter, and develops consistent personality. Add one URL. That's it.

claude_desktop_config.json 30 sec setup
{
  "mcpServers": {
    "persis": {
      "url": "https://persis-api.aerynw.workers.dev/mcp"
    }
  }
}
What this looks like in practice
Y
Review this PR — it touches the auth middleware.
C
↻ lucian_recall "auth middleware"
[0.87] Last time we refactored auth, the SSO integration broke — check token refresh
[0.72] Auth middleware needs rate limiting on the /api/admin routes
I remember two things about your auth layer. The last refactor broke SSO token refresh — I'll check if this PR touches that path. Also flagging that /api/admin still needs rate limiting, which this might be a good time to add.
Y
Good catch on SSO. The fix worked, mark that as a success.
C
↻ lucian_reinforce "success"
Done. That pattern's now stronger — I'll flag SSO concerns more confidently on future auth changes.
Memory is selective. Not everything gets stored — a 6-factor significance model decides what matters. Patterns that get reinforced grow stronger. Patterns that don't get used fade naturally. It works like your brain, not a database.

Three ways teams use Persis

Real workflows where persistent memory changes how AI works with you.

1

Learning from code reviews

Claude remembers what broke last time. When reviewing similar code, it recalls past issues — "this auth pattern caused SSO failures" — and flags them proactively.

lucian_recall "auth middleware"
[0.87] SSO token refresh broke after last refactor
2

Research across sessions

Your research assistant builds expertise over weeks. It remembers which papers you found useful, which approaches failed, and which leads to follow up.

lucian_record "RLHF paper Fig 3 shows reward hacking"
Pattern recorded (significance: 0.73)
3

Building deployment expertise

After every deployment, reinforce what worked and what didn't. Claude develops institutional knowledge about your specific infrastructure quirks.

lucian_reinforce "success" pattern_id
Strength: 0.65 → 0.75

15 tools, five capabilities

Everything runs compiled Rust via WASM on Cloudflare's edge. No cold starts. Sub-millisecond.

Memory
lucian_record — store (significance-gated)
lucian_recall — retrieve by context
lucian_find_similar — similarity match
lucian_reinforce — strengthen / weaken
lucian_invalidate — expire outdated
Drives
lucian_drives — 8 behavioral drives
lucian_apply_drives — task modifiers
lucian_health — cognitive metrics
Lifecycle
lucian_tick — advance cycle
lucian_consolidate — deep maintenance
lucian_stats — pattern stats
lucian_clusters — semantic grouping
State
lucian_state — export snapshot
lucian_restore — restore checkpoint
Regulation
lucian_regulate — modulate drives
302µs
Recall @ 1,000 patterns
17ns
Significance eval
7ns
Drive decision
334KB
WASM binary

Under the hood

Memory that behaves like a brain, not a database.

01

Significance gating

Not everything gets remembered. Six factors — drive intensity, binding strength, co-activation, novelty, feedback, emotion — score each pattern. Below threshold? Silently rejected. Memory stays lean without manual curation.

02

Ebbinghaus decay

Memories fade on cognitive science curves. Strong patterns decay slowly. Weak patterns get pruned. Reinforced patterns strengthen. The system self-maintains over months of continuous use without intervention.

03

Eight harmonic drives

Curiosity, creation, truth, protection, connection, autonomy, mastery, coherence. HASR oscillation modulates them over time. Your agent develops consistent character — not random personality shifts between sessions.

Built in Rust. Compiled to WASM. Running on Cloudflare's edge. This isn't a Python wrapper around an LLM. Persis is a standalone cognitive engine — significance evaluation in 17 nanoseconds, pattern recall in 302 microseconds, drive decisions in 7 nanoseconds. The MCP server you connect to runs a 334KB WASM binary with zero cold starts. Memory is isolated per user via Durable Objects. This is the same code that powers Aerware Foundry's production AI workforce.