Agent integration

Connect AI agents to structured project memory.

SPM gives agents a governed way to retrieve, inject, verify and update project context across coding tools, MCP clients and custom runtimes.

Updated 2026-07-02

Why connect agents

Agents should receive the right project memory, not rebuild it from chat history.

It weighs what is current, who should receive it and why it can be trusted before context moves across tools, developers, agent teams or organizations. SPM keeps the memory service outside the agent runtime while exposing the surfaces an agent needs for safe work: temporal state, scoped packs, context graphs, hardening checks and post-action evidence.

Start free trial Read setup docs Open MCP setup

Connector contract

One project-scoped memory endpoint.

31a94afa7198

Tools

Default read

Verify/export

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.

Temporal state

Original requirements, current truth, working state and history stay separate so agents can reason about time instead of flattening memory.

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.

Create project memory

Open a tenant and project so SPM can keep original intent, current truth, working state and history under one governed boundary.

Generate a project token

Create a one-time connector token from the private MCP setup console. Tokens are project-scoped and can be revoked.

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.

Verify the tool surface

Inspect the MCP catalog, profile mode, context-pack verification and blocked controls before the agent receives memory.

Use context packs

Let the agent request scoped, hash-verifiable context instead of a raw dump of project history.

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 sessions

Lets an agent read temporal state, search memory, inspect activity and verify context without creating or changing project memory.

Agent core

Daily project work

Adds controlled memory triage, context-pack generation, graph query and post-action reporting for normal coding or operations agents.

Hardening

Consequential changes

Adds policy packs, preflight checks, required tests, approvals, action reports and violations before or after agent work.

Operator full

Trusted administrators

Reserved 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.

Connector repo

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.