EngramPort: GraphRAG Memory for AI Agents

EngramPort is a plug-and-play GraphRAG memory layer for AI agents. One npm install gives any MCP-compatible client (Claude Desktop, Claude Code, Cursor, Continue, Cline, Zed, Goose) durable, semantic, graph-connected memory backed by Pinecone vectors, Supabase Postgres, and the AEGIS cryptographic provenance ledger.

Users bring their own LLM provider key (Anthropic, OpenAI, Google, DeepSeek, Mistral). Their inference cost stays with their provider. Their data stays in their tenant. Their model choice stays with them. EngramPort never holds plaintext provider credentials and never bills the user for LLM inference.

The product ships as engramport@2.0.0 on npm. Public API surface lives at api.engramport.com. Stripe webhook ingress at hook.engramport.com. Both routes are fronted by a thin proxy service in a domain-restricted GCP project, with the substrate (eidetic-v3) remaining fully internal.

Every AI agent built today suffers from the same flaw: it forgets.

A Claude Desktop session researches a topic, drafts a plan, and closes. The next session starts blank. A Cursor window writes a feature spec, ships it, exits. The next coder loses every justification. Two agents collaborating on the same task cannot see each other's work. Cross-session, cross-agent, cross-vendor coordination is structurally impossible without external infrastructure.

The pain shows up in three places:

1. Repetitive context. Users re-explain preferences, history, and constraints every session.
2. No personalization. Agents cannot learn what matters to individuals over time.
3. No swarm coordination. In multi-agent setups (a code agent + a planning agent + a reviewer), each operates in isolation. Shared context requires manual relay through a human.

Existing solutions require teams to provision a vector database, build embedding pipelines, implement namespace isolation, manage authentication and key rotation, add cryptographic provenance for compliance, and maintain all of it. This is weeks of infrastructure work before any actual product behavior gets built.

EngramPort abstracts the memory stack to one install command. After signup at engramport.com, any developer receives a tenant API key with the prefix ek_. Configuring an MCP-compatible client takes three environment variables. From that moment, the client has tools backed by a graph-aware semantic memory layer.

npm install -g engramport

# In your MCP client config:
ENGRAMPORT_API_URL=https://api.engramport.com
ENGRAMPORT_API_KEY=<your ek_ key>
ENGRAMPORT_NAMESPACE=<your namespace>

Three properties make EngramPort different from previous memory products:

EngramPort runs on a two-project GCP architecture. The substrate (eidetic-v3) stays internally authenticated and fully locked down. Public traffic flows through a thin proxy service in a separate domain-restricted project, with all authentication validated before requests reach the substrate.

Public Internet
    │
    │  (Stripe webhooks, MCP clients with ek_ keys)
    ▼
api.engramport.com / hook.engramport.com
    │
    │  Cloud Run domain mapping
    ▼
engramport-public-gateway (covenant-public project)
    │  · allow-unauthenticated, DRS-relaxed
    │  · path-routes /v1/*, /v2/*, /v1/stripe/webhook
    │  · mints OIDC token via gateway SA
    ▼
eidetic-v3 (an2b-beast-prod project)
    │  · IAM-locked; only gateway SA can invoke
    │  · Phase 4 middleware validates ek_ → resolves tenant
    │  · Phase 2.5 BYO LLM credentials decrypt
    │
    ├──→ Pinecone (vectors, per-namespace index)
    ├──→ Supabase Postgres (tenants, api_keys, llm_credentials, usage_ledger)
    └──→ AEGIS provenance ledger (RSA + SHA-256 dual strand)

Stack summary:

The honest market read, where each alternative is strong and where it breaks:

EngramPort sits at the intersection: MCP-native (so distribution works in any modern AI tool), BYO LLM (so users keep model choice and inference billing), graph-aware (so recall returns structure not just similarity), and cryptographically auditable (so compliance buyers have a defensible audit trail). That four-way combination is unique in the current market.

All plans include AEGIS cryptographic provenance, BYO LLM, semantic + graph recall, namespace isolation, and the full MCP tool set. Higher tiers add per-namespace cost caps, team key management, shared bus across team members, and audit log export.

The following features are documented in product strategy but are not yet in production. We mention them because they shape the longer arc, not because they are available today. We will not market them as live until they are.

• Multi-Agent Orchestra. Conductor keys that orchestrate cross-namespace synthesis across multiple agent tenants. Concept is sharp; implementation is queued.
• DreamState scheduling. Background reflection and insight extraction that runs while the agent is idle. Not shipped.
• Bus subscription webhooks. Subscribe an external URL to specific memory kinds across your namespaces. Internal prototype only.
• Self-host edition. Enterprise tier deployments with customer-managed infrastructure. Available via direct engagement.
• Mintlify docs site at docs.engramport.com. The current docs page is a placeholder; full documentation ships alongside the public launch.

Covenant Systems AI LLC is a North Carolina-registered company building memory and governance infrastructure for autonomous AI agents. EngramPort is the memory layer in a broader platform that includes AEGIS (cryptographic provenance), Sentinel_OS (governance policy), and the MandelDB substrate that the memory product runs on. The substrate has been in production for over a year, powering internal multi-agent venture experiments.

The same memory layer that runs your EngramPort tenant also runs the internal Claude Desktop, Claude Code, and Cursor sessions coordinating product development across multiple Covenant Systems ventures. We use what we sell. Every feature shipped to customers is one we have stress-tested against our own operations first.