Interface-Agnostic AI Memory Layer

How do you govern AI memory and spend across multiple AI tools?

Put a memory and governance layer between people, their AI clients, and the providers underneath. BrainMate captures turns from 6+ clients, extracts durable insights, scopes them by tenant and project, enforces policy through a guard pipeline, and writes a hash-chained audit and cost ledger — so context, decisions and spend stay continuous and verifiable.

Alex Scharifker · Founder, product architect, and systems lead

BrainMate / BrainMesh OS is Alex Scharifker's AI memory and governance system. It is unrelated to similarly named public products.

AI Clients Unified

35+

MCP Tools

Hash-chained

Audit Trail

Problem

BrainMate / BrainMesh OS

People now work across five or six AI tools — Telegram, Claude, ChatGPT, Cursor, n8n, their own console — and every one of them starts from zero. Context, decisions and spend are fragmented across windows, and nothing about what the model was told or what it cost is auditable after the fact.

System

How the system is put together

Sources in, deterministic logic in the middle, AI restricted to interpretation.

Data sources

Conversation turns from every connected client
Chrome extension capture of ChatGPT, Claude and Gemini web sessions
Telegram, Gmail, Drive, Sheets and n8n integrations
Project, scope and artifact stores
Audit, telemetry and cost logs

Layers

Cross-client capture
Identity, tenant and project scoping
Insight extraction and retention
MCP tool host and public REST API
Guard pipeline and policy
Hash-chained audit and cost ledger
Telemetry, rollups and governance scoring

Deterministic logic

Row-level access and scoping policy
Scoped API keys, rate limits and request logging
Per-call cost, token and latency instrumentation
SHA-256 chained, verifiable audit trail
Schema-validated telemetry and webhook ingress

Where AI is used

Interpretation only — never the source of a number
Grounded answers that cite the memory evidence behind them
Blocked from answering when inputs are insufficient

Decision loop

Capture turns from every client
Extract durable insights, expire raw transcripts
Guard, route and price the call
Log for audit, recall on the next session

My role

Product definition and platform architecture
Memory model: extraction, retention, curation, recall
Governance model and integrity rules
MCP tool surface and public API design

Architecture

The architecture case file

Layer-by-layer architecture, deterministic model, AI guardrails, and the decision loop.

People work across five AI tools and start from zero in each one. BrainMate is the layer underneath them: it keeps one memory across every client, decides what context each call gets, and records whether the answer can be trusted.

Capture→Unify→Extract→Govern→Recall

Key takeaways

—One memory layer across every AI client — Telegram, Claude, ChatGPT, Cursor, n8n, the console — instead of a separate history per tool.
—Exposed through a single MCP tool host and a versioned REST API, both key-scoped, rate-limited and request-logged.
—Turns are short-lived; extracted insights persist — so context compounds instead of bloating.
—Every governed call is policy-checked, priced, and appended to a hash-chained audit ledger that can be verified.
—Cost, latency and guard outcomes are instrumented per call and rolled up into a 0-100 governance score.

Architecture Principle

Memory should belong to the person, not to whichever chat window they happened to open.

One memory layer behind every AI client, instead of a separate history per tool.
Scoping is enforced at the data layer; the client cannot widen its own access.
A single governed egress point means cost, policy and audit are structural, not optional.

Capture everywhere

Telegram, Claude Desktop, Cursor, n8n, the web console, and a Chrome extension that reads ChatGPT, Claude and Gemini web sessions all write turns back to one store.

Resolve to one identity

Every turn, from every client, resolves to the same user, workspace and project before it is stored. Isolation is enforced by row-level policy and security-definer role functions, not app code.

Expose one surface

Interface

Memory is served back through a single MCP tool host (~35 tools) and a versioned REST API, both authenticated with scoped, hashed API keys or OAuth, both rate-limited and request-logged.

Route through one proxy

No client talks to a provider directly. Anthropic-shaped and OpenAI-shaped endpoints are compatibility shims onto one governed proxy, so model choice is an operator decision, not a code change.

Continuity as the payoff

Payoff

Start a thread in Telegram, finish it in Cursor, audit it in the console. The context follows the person, not the tool.

Outcome

What changed

A memory and governance layer that sits between people, their AI clients, and the providers underneath.
Continuity across tools: start a thread in Telegram, finish it in Cursor, audit it in the console.
Built as the platform pattern behind applied systems like MISH, where output must be grounded and traceable.