AI product. 2026. Founder and architect. TypeScript, MCP, Rust and Axum, React.
A multi-tenant persistent memory and context platform, so a team's AI tools and agents share one auditable memory instead of seven private ones.
Every developer on a team runs their own AI coding tool, and every tool keeps its own memory. The same architectural decision gets re-explained five times a week, and nobody can say who deleted what.
I wanted one shared memory with real tenancy and a trail I could query, reproducible with a single Docker Compose command and no database server to babysit. I designed the MCP server and the React interface myself and integrated them with a Rust and Axum backend.
Any MCP client on the team reads and writes the same store, so a decision is explained once and found by everyone after that.
Store, search and delete each write an audit row in the same transaction, so the trail can never disagree with the data.
Both Rust processes live in a single pod on a K3s cluster, over one SQLite file on a persistent volume. Compose still runs the whole stack locally.
Because the front door is MCP, Claude Code and Cursor connect with a config entry rather than an SDK.
Service
TypeScript, stateless, runs on the developer machine
Turns MCP tool calls into REST calls against the API, forwarding the developer API key over HTTPS with a bearer token. Stateless by design: it can be killed and restarted mid-session.
Each request resolves API key to user to organisation before storage is touched, so tenancy lives in the query layer rather than in handler code where it can be forgotten.
Trade-off accepted
Cross-org features, like sharing a memory between teams, will need an explicit escape hatch later.
The mutation and its audit row commit together, so there is no window where a change exists without a trail, and "who deleted this?" stays a query.
Trade-off accepted
Every write pays a little extra latency. Cheap at team-memory volume, wrong for a high-throughput event store.
Coding agents already speak MCP, so exposing store, search and record_decision as tools removed all client integration work.
Trade-off accepted
REST still exists for the admin panel, which means two surfaces have to stay in sync.
Rust plus SQLite on a persistent volume means no database server in the request path. A periodic dump into a managed Postgres exists purely as a restore target, so durability does not cost operational surface.
Trade-off accepted
One pod cannot scale horizontally without replacing SQLite. I accepted that ceiling deliberately rather than run Postgres from day one.
Each capability stated twice: for the person using it, and for the engineer maintaining it
Product
Ask for a decision in your own words and get it back, whoever wrote it and whichever tool they were using at the time.
Technical
Full-text search over SQLite with FTS5, ranked and then filtered by project, type and tag. Returns truncated previews, with a separate call for the full record so an agent does not burn context on results it will discard.
Product
The rules your team already agreed on, handed to the agent before it writes anything, instead of being re-explained in every prompt.
Technical
Conventions are a separate record type grouped into categories such as architecture, database, workflow and naming. get_context returns them ahead of recent memories, so they carry more weight than any single past session.
Product
The agent can look up a symbol in the actual repository rather than guessing from memory or grepping blindly.
Technical
Repositories are indexed per organisation and queried by symbol and by path, so a lookup resolves to real source rather than to whatever someone wrote down about it.
Product
One team can hold work for several clients without their contexts bleeding into each other.
Technical
Every memory is scoped to a project, and projects can nest and carry a client. Scope is resolved server side from the API key, so a mis-scoped write is rejected rather than silently filed in the wrong place.
Product
Not everyone should be able to delete the team memory, and now they cannot.
Technical
Role-based access control over users and organisations, checked in the query layer alongside tenancy rather than in handler code.
Product
A shared memory rots quietly. This is the panel that tells you it is rotting before anybody notices.
Technical
Duplicate, stale and untagged counts computed across the organisation, so the store can be pruned deliberately instead of growing until search stops being useful.
The knowledge graph. Memories, sessions, users, collections, tags and audit events, typed and linked per project.
The migration TUI. Scan, classify, stage, review. Nothing is written until commit, and some candidates are excluded from batch approval by design.
The admin dashboard. Activity, agent usage and memory health. Tenant names anonymised.
