Durable project memory
Keeps source-linked items, raw evidence references, summaries, decisions, policies, agent activity and context packs inspectable across runs and tools.
Durable, shareable and governed project memory for AI agents
Give every agent and collaborator the project knowledge they actually need.
SPM preserves requirements, decisions, completed work and source evidence across tools; weighs relevance, time and authority; and shares only the context each agent, teammate or partner is allowed to use.
Every agent can continue with what matters, what still holds, what has already been done and what it is authorized to see.
SPM project truthhash verified
Requirements
Original memory
Truth
Current state
Run context
Working memory
Trace
History
Temporal validity
strictLatest note marked as working hypothesis
Higher-authority security rule remains project truth until reviewed.
Authority
security owner95%
agent shortcut61%
Backend pack
code, errors, tests
Partner pack
safe handoff only
Support brief
approved narrative
context pack hash
summary-only handoff
revocable entitlement
Continue project work across agents and tools without rebuilding requirements, decisions or completed work.
Rank memory by relevance, time, authority and source instead of treating every note as equally important.
Share a restricted project view with a teammate or partner, then inspect, expire or revoke it.
Product demo
See one project continue across agents, teammates and a partner without losing context or exposing the whole project.
A software team assigns consequential work, reuses authorized knowledge from another project, hands verified progress to a second agent and shares a restricted integration pack with a partner.
A product owner assigns API retry work and brings in authorized context from a related identity project.
Codex receives current requirements, completed work and required tests; an older incompatible decision remains visible as history.
Another developer continues in Claude or Cursor, while a partner receives only the approved, expiring integration pack.
Why it matters
The next agent receives what still matters, what has already been done and what it may see, with source evidence attached.
Product model
One durable memory, evaluated before it reaches the next agent.
SPM preserves raw source references and compact summaries, separates original intent from current and historical state, and prioritizes the memory that matters for the task.
Smart prioritization
Ranks what matters by relevance, source, time, authority, confidence and task intent so agents do not treat every memory item as equally important.
Temporal validity
Keeps original, current, working and historical memory separate, then weighs recency, evidence and superseding state before promoting project truth.
Authority-aware memory
Lets owner, security, product, agent and external inputs carry different weight, preserving low-authority input as reviewable context when needed.
Scoped sharing
Builds separate memory views for backend work, release risk, partner handoff, support brief or any authorized audience from one governed project memory.
Queryable graph
Connects requirements, decisions, agents, shares, policies, sources and events so memory can be queried by topic, tag, audience or relationship.
Agent-ready context packs
Compiles scoped memory, summaries and evidence into compact portable packages for MCP, API and CLI consumers.
Agent hardening
Records project policies, preflight decisions, required tests, approvals and violations around agent actions.
Governed sharing
Shares context with provenance, safety previews, entitlements, access logs and revocation.
Marketplace substrate
Lets valuable context packs become listed, licensed and distributed with source and usage controls.
Project truth layer
One project memory can produce different authorized views.
A coding agent can receive implementation history and required tests while a partner receives only approved integration facts. Both views remain tied to the same sources, decisions and audit trail.
Mixed project input
Backend defect, auth middleware and required tests.
Partner handoff requires integration facts and protected commercial boundaries.
New agent note suggests a shortcut against an older security rule.
Scoped memory views
Backend agent
code, errors, restrictions and tests
Partner handoff
safe facts, provenance and revocation
Support brief
approved impact and current status
Memory is prioritized before it moves
SPM weighs relevance, source, authority, temporal layer, confidence and unresolved tensions before memory becomes agent-ready context.
One project memory can produce many safe views
A backend agent, support lead, partner and release reviewer can each receive a different governed memory pack from the same underlying project memory.
Every shared pack can be inspected
Context packs carry provenance, policy decisions, hashes, expiry, entitlement state and revocation signals so shared memory remains inspectable.
LLM use is focused on memory judgment
LLM-assisted triage, summaries and consolidation help classify mixed user input, detect stale or conflicting context and keep packs compact for agent runs.
Workflow
From project activity to the memory the next agent can use.
01
Capture
Ingest requirements, decisions, code context, policies, run logs and source material with provenance.
02
Evaluate
Weigh recency, authority, evidence and temporal layer before promoting memory into project truth.
03
Compose
Build the exact memory view an agent, teammate, partner or support flow is authorized to use.
04
Deliver
Send compact context packs to MCP tools, API consumers, CLI workflows or another authorized agent.
05
Verify
Check source, hashes and policy state, then inspect delivery, acknowledgement, action, expiry or revocation.
Use cases
Use the same project knowledge without giving everyone the same access.
Start with one developer moving between tools, then extend the same memory model to a team or an external partner.
One developer, several agents
Continue the same project across Codex, Cursor, Claude, local CLI work and multiple repositories without rebuilding project state in every tool.
A team sharing project memory
Give product, backend, security, release and support the same durable memory while each role receives the view it needs.
A governed partner handoff
Share implementation facts, decisions and checklists without exposing pricing, internal roadmap, private security notes or unrelated project history.
Deployment options
One memory product, multiple deployment paths.
- Runs locally for builders who want private project memory beside their agent tooling.
- Scales into a hosted team console with projects, quotas, invoices and governance trails.
- Supports private deployment patterns for organizations with stricter data boundaries.
- Turns governed context packs into marketplace-ready assets with provenance and entitlement logs.
Trust layer
Governance is part of the memory object, not an afterthought.
Private tenant boundary
Role and scope checks
Temporal hash chains
Context pack verification
Source provenance
Safety previews
Entitlement logs
Retention controls
Legal holds
Provider budgets
Commercial packaging
Deploy SPM where project memory needs to live.
Core Local / MCP
Builders and small agent teams
Local or small-team SPM with CLI, MCP, context packs, strict quotas, 1 EUR hosted AI credit or BYOK.
Team SaaS
Product and engineering teams
49 EUR/month hosted dashboard, agent integrations, temporal memory, sharing, governance basics and 12 EUR hosted AI credit.
Business
Teams with governed agent workflows
199 EUR/month advanced permissions, audit logs, higher quotas, private context sharing, provider budgets and 60 EUR hosted AI credit.
Enterprise
Security-conscious organizations
Private deployment with SSO, BYOK or contracted dedicated AI budget, legal controls, SLA and support.
Marketplace
Context publishers and buyers
99 EUR/month listings, entitlements, licensing, access history and revenue-share-ready context distribution.
Next step