Temporal state
Original requirements, current truth, working state and history stay separate so agents can reason about time instead of flattening memory.
Agent integration
Give each agent the project knowledge it should actually use.
Connect Codex, Claude, Cursor, OpenClaw or a custom runtime to durable project memory that preserves completed work, evaluates what still holds and respects each authorized boundary.
Updated 2026-07-02
Why connect agents
Continue the project across agents without rebuilding context or exposing the whole project.
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. The memory remains outside the agent runtime while MCP, API and CLI expose temporal state, scoped packs, context graphs, hardening checks and post-action evidence.
Connector contract
One project-scoped memory endpoint.
Tools
119
Default read
75
Verify/export
21
spm_temporal_statetemporal_memoryread
spm_temporal_context_packtemporal_memoryread
spm_temporal_context_pack_verifytemporal_memoryverify
spm_context_boundary_packcontext_boundariesread
spm_temporal_graph_querytemporal_memoryread
spm_memory_triagememory_agentwrite
spm_agent_preflightagent_hardeningwrite
spm_agent_action_reportagent_hardeningwrite
spm_memory_maintenance_runmemory_maintenancewrite
spm_trust_remediation_plantrust_governanceread
What agents can use
SPM exposes memory as temporal, scoped and verifiable surfaces.
Context graph
Agents can traverse requirements, decisions, sources, policies, context boundaries, shares and prior actions by topic or tag.
Scoped packs
Backend, support, partner, release or security agents receive the memory they need with hashes, provenance and expiry.
Memory triage
LLM-first triage structures, summarizes, tags and relates mixed project input before it becomes durable memory.
Policy preflight
Hardening tools return applicable policies, required tests, approvals and blockers before an agent performs risky work.
Trust remediation
Launch and governance blockers are readable by agents through a safe trust plan with acceptance criteria and verification endpoints.
Setup path
From project memory to active agent connector.
01
Create project memory
Open a tenant and project so SPM can keep original intent, current truth, working state and history under one governed boundary.
02
Generate a project token
Create a one-time connector token from the private MCP setup console. Tokens are project-scoped and can be revoked.
03
Install the connector
Use the public connector package, local CLI, remote MCP endpoint or exported ZIP recipe for Codex, Cursor, Claude Desktop or a generic MCP client.
04
Verify the tool surface
Inspect the MCP catalog, profile mode, context-pack verification and blocked controls before the agent receives memory.
05
Use context packs
Let the agent request scoped, hash-verifiable context instead of a raw dump of project history.
06
Report outcomes
Record decisions, tests, violations, approvals and post-action evidence back into temporal project memory.
Profiles
Choose the smallest profile that fits the agent run.
Agent read-only
Safe recall sessionsLets an agent read temporal state, search memory, inspect activity and verify context without creating or changing project memory.
Agent core
Daily project workAdds controlled memory triage, context-pack generation, graph query and post-action reporting for normal coding or operations agents.
Hardening
Consequential changesAdds policy packs, preflight checks, required tests, approvals, action reports and violations before or after agent work.
Operator full
Trusted administratorsReserved for trusted operators who need broader MCP coverage. Billing, payments and destructive controls remain outside agent connectors.
Client targets
Works with MCP clients and direct API consumers.
Codex-style coding agents
Use SPM before and after consequential code changes: retrieve project truth, run hardening preflight, receive tests and report evidence back to memory.
Cursor and local IDE agents
Keep local work connected to the same temporal project memory without copying private project history into every prompt.
Claude Desktop and MCP clients
Connect through a standard MCP server with scoped profiles, project tokens and verifiable context-pack handoffs.
Custom agent runtimes
Call the API or exported connector recipes directly when the runtime needs a controlled memory service rather than an embedded memory store.
Public distribution
Publish the connector, keep the memory private.
The public connector can be listed and inspected without exposing SPM tenant data. Real project memory still requires account creation, project authorization, scoped token delivery and revocable access.
Public artifact
Connector package, recipes, schema, README and smoke tests can be public.
Private memory
Tenant data, context packs and tokens remain authenticated and project-scoped.
Verified handoff
Every pack can be checked by hash, provenance and policy state before injection.