What should be remembered?
Not every message deserves durable storage.
International AI Awards 2026 · Best AI Tool · Gold Winner
Auditable long-term memory for AI agents
MAPI preserves decisions and context across sessions while keeping durable memories traceable, reviewable, versioned and reversible.
It gives AI agents continuity without turning their memory into an unaudited black box.
- Local-first
- Project-scoped
- Preview-first
- Auditable
Current release status
- MAPI Core
- Public Release Candidate / Developer Preview
- Polaris / MAPI VPS
- Controlled Developer Preview
- MAPI Windows
- Alpha
International AI Awards 2026
Best AI Tool · Gold Winner 2026
MAPI received Gold Winner recognition in the Best AI Tool category at the 2026 International AI Awards.
Official certificate issued 31 August 2026
View the official winner page
Official INAI certificateIssued to Michal Chlewicki for MAPI as Gold Winner in the Best AI Tool category.Open the certificate
Why MAPI
Retrieval is not the same as trustworthy memory
AI agents can retrieve similar text, replay conversation history or load a summary. Long-running work needs more: decisions become scattered, summaries can mix facts with interpretation, and retrieval can surface an obsolete policy without knowing that it was replaced.
Why should it be trusted?
A memory needs provenance, scope and confidence, not only text.
What happens when it changes?
New decisions should not silently erase their predecessors.
What happens when sources conflict?
The system should surface uncertainty instead of inventing certainty.
MAPI is not another memory database. It is a control layer for deciding what an AI agent should remember, why that memory is trusted and how it can safely change over time.
Three pillars
Continuity with controls attached
Persistent continuity
Restore important decisions, constraints and open questions across sessions without replaying an entire conversation history.
Traceable memories
Keep source, project scope, confidence, ownership and lifecycle state visible alongside remembered content.
Controlled change
Review candidates, preserve decision lineage, surface conflicts and inspect supported changes through preview, audit and rollback workflows.
How it works
A governed memory lifecycle
- 01
Capture
An agent or integration proposes candidate memories from current work.
- 02
Review
A human or operator decides what deserves durable storage.
- 03
Store with context
Confirmed memories retain source, scope, confidence, ownership and lifecycle state.
- 04
Restore
A future session retrieves only the relevant project context.
- 05
Update explicitly
Changed decisions are versioned; contradictions remain visible until reviewed.
- 06
Audit and inspect
Supported operations can be previewed, recorded and evaluated through rollback previews.
Synthetic local demonstration
Five steps from conversation to governed continuity
The demonstration uses a completely synthetic project called Northstar Booking, a fictional product owner named Alex Morgan and a fictional AI assistant named Nova.
These are screenshots of an isolated deterministic demo. No private memories are present, and the local demo server is not publicly hosted.
Demo view 1
Restore
A new session restores confirmed constraints while facts, uncertainty and next steps remain separated.
Open screenshot at full size
Demo view 2
Capture review
Four confirmed project decisions are approved; an undecided SMS idea is rejected before durable storage.
Open screenshot at full size
Demo view 3
Supersession
The 12-hour rule becomes active while the previous 24-hour decision remains preserved as history.
Open screenshot at full size
Demo view 4
Lineage close-up
Forward and reverse pointers connect both decision versions through an explicit active link.
Open screenshot at full size
Demo view 5
Conflict review
A conflicting 48-hour enterprise note stays unresolved instead of being promoted to truth.
Open screenshot at full size
Demo view 6
Audit and rollback preview
The recorded run exposes affected items; rollback preview inspects the reversal scope with zero mutation.
Open screenshot at full sizeReproducible proofs
Inspect how MAPI preserves decisions and conflicts
MAPI includes deterministic, reproducible scenarios for decision supersession and conflicting-source provenance. They use synthetic data and run without an external language model.
Proof 1
Decision change without losing history
A project first uses SQLite and later changes the decision to PostgreSQL. MAPI returns PostgreSQL as the current state while preserving the earlier SQLite decision and the relationship between them.
- Current: PostgreSQL
- Previous: SQLite
- Relation: supersedes
- Synthetic data
- No external model
Proof 2
Conflict without silent overwrite
Two sources provide different values for the same project fact. MAPI preserves both records and their provenance, and exposes the conflict instead of silently choosing one version.
- Both records preserved
- Provenance preserved
- Conflict visible
- No silent overwrite
- Synthetic data
- No external model
Architecture
A memory control plane between the agent and long-term context
MAPI exposes a stable MCP and API tool surface for capture, retrieval, restore and governed lifecycle operations. The durable store keeps content together with provenance, scope, confidence, ownership, links and lifecycle state.
MAPI can complement semantic retrieval, RAG and vector databases. It does not replace them; it governs the durable memory they may later expose to an agent.
Open the architecture diagram at full sizeComparison
A different layer of the memory stack
| Approach | Useful for | Usually does not manage |
|---|---|---|
| Vector store | Semantic similarity search | Lifecycle, review, conflicts and audit |
| RAG | Adding external context to a model request | Durable decision governance and lineage |
| Chat history | Preserving the raw conversation | Active project memory and explicit state |
| Automatic summaries | Compressing long exchanges | Provenance and separation of fact from interpretation |
| MEMORY.md | A simple human-readable record | Scale, scope, confidence and controlled updates |
| MAPI | Governed durable memory and continuity | Still requires technical integration and onboarding |
MAPI works alongside retrieval systems. It controls how long-term agent memory is selected, trusted and changed.
Intended users
Built for work that lasts longer than one session
Coding agents
Preserve architectural decisions, constraints, ownership and unresolved questions across implementation cycles.
Multi-agent systems
Give cooperating agents a shared but governed memory layer instead of an uncontrolled pool of summaries.
Local and private assistants
Keep durable memory under operator control and restore only the required project scope.
AI governance teams
Add provenance, explicit lifecycle states, conflict visibility and auditable changes.
Research and infrastructure teams
Explore persistent agent continuity without treating similarity as a complete memory model.
Responsible claims
What MAPI does not claim
MAPI provides a more inspectable foundation for long-term context. Memory quality still depends on source quality, capture rules, operator decisions and client integration.
- Consciousness
- Infallibility
- Hallucination-free AI
- Automatic proof of truth
- Automatic resolution of every conflict
Deployment variants
One MAPI core, two current deployment paths
The memory and governance model stays shared. What changes is where MAPI runs and how it is operated.
Server variant · controlled developer preview
Polaris / MAPI VPS
A working server variant for organizations that need a persistent remote MCP endpoint on their own VPS. It includes authenticated remote access, onboarding, backups, maintenance and controlled server deployment, but it is not presented as a mass-market SaaS.
Local variant · alpha
MAPI Windows
A local Windows package being prepared for simpler installation and use on the operator's own computer. Packaging, installer work and user validation are still in progress.
Project status
A shared core with clearly separated release stages
MAPI Core is a Public Release Candidate / Developer Preview. Polaris / MAPI VPS is a working controlled developer-preview deployment, while MAPI Windows remains in alpha during packaging, installer work and user validation.
The two variants share the memory model, but their deployment and operating boundaries are different.
License and deployment
Open-source core, paid deployment service
MAPI Core is open source under the Apache 2.0 license. MorenaTech's price from PLN 3,500 + VAT is for a scoped deployment service, not for access to the repository. Depending on the agreed scope, the service can include installation, configuration, secure endpoint and access setup, MCP integration with a selected AI client, onboarding, launch tests and agreed support.
Creator
Created from a QA perspective
MAPI was created by Michał Chlewicki, a software tester and automation engineer with professional experience dating back to 2011, including eight years at Intel.
His quality-assurance background shaped the project around traceability, failure analysis, explicit state transitions and controlled changes rather than opaque automation.
AI agents need more than recall. They need accountable continuity.
Review the project materials or contact MorenaTech about MAPI and governed agent-memory infrastructure.
Related materials
Move from the topic to a service, implementation, and practical guidance
These links come from MorenaTech's explicit content graph and lead to materials in the same area.