MOOTx01 Community Edition
codedaptive/mootx01-ce
Memória persistente e local para suas IAs através do MCP
Ver no GitHubMCP server que fornece memória de longo prazo persistente para IAs. Armazena decisões, conversas, fatos e relacionamentos em um repositório local que qualquer cliente compatível com Model Context Protocol pode acessar via ARIA. Permite que a IA mantenha contexto entre sessões e mude de ferramenta sem perder conhecimento acumulado.
Instalação
npx convez-ai codedaptive/mootx01-ce1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Manter histórico de decisões de projeto entre conversas
- Recuperar contexto e fatos importantes em novas sessões com diferentes IAs
- Construir base de conhecimento pessoal vinculado a projetos específicos
- Reduzir necessidade de re-explicar contexto ao trocar de ferramenta de IA
Veredito

Projeto ambicioso e bem arquitetado que resolve um problema real: perda de contexto entre sessões de IA. Ainda em beta e sem hardening de segurança, mas implementação clara e documentação sólida. Recomendado para early adopters que precisam de persistência de conhecimento em workflows de IA multi-ferramenta.
README
A tradução para o português deste README ainda está na fila.
MOOTx01
Long-term memory for AI.
Observe · Remember · Dream · Convene
The frontier intelligence is rented. The memory is yours.
What it is
MOOTx01 gives your AI a memory that lasts.
Every AI today has the same basic problem: when the chat ends, the useful context often disappears with it. You start over. You re-explain the same project rules. You re-introduce old decisions. You switch from one AI tool to another and the memory does not come with you.
MOOTx01 stores useful memory in a local estate your AI can read from later. It runs on your machine by default. Any AI client that speaks the Model Context Protocol can connect to it through ARIA, the MOOTx01 memory language.
The model can change. Your memory stays yours.
What it fixes
Your AI has a context window. That is what it can think with right now.
MOOTx01 gives it a memory estate. That is what it can remember from later.
Use MOOTx01 when you want your AI to:
- remember project decisions,
- recall prior conversations,
- keep durable facts and notes,
- link related ideas,
- search across sessions,
- stop asking you to rebuild the past every time.
MOOTx01 is not just a vector database. It stores memory as a substrate: memories, facts, links, journals, trust state, recall indexes, graph structure, reasoning lenses, and background consolidation signals.
In plain English: it keeps what happened, finds what matters, and helps your AI use that memory when it matters.
What it looks like
Install MOOTx01, wire it into your AI client, restart the client, and verify that the tools are visible.
mootx01 install
Then ask your AI to try memory:
Remember that this project ships the importer behind a flag.
Search my MOOT for what we decided about the importer.
Show me the current status of my MOOT estate.
Behind the scenes, the AI uses ARIA tools like these:
// store a memory
moot_file_memory {
"content": "We ship the importer behind a flag.",
"location": "project/alpha"
}
// retrieve memory
moot_memory_search {
"query": "what did we decide about the importer?"
}
Where to go next
- Install it. See Quickstart below.
- Understand it fast. Read
docs/start-here/END_USER_EXPLAINER.md. - Have an AI install it. Give the AI
AI_START_HERE.md. - Read the story.
ABOUT.mdexplains why MOOTx01 exists and why memory belongs to you. - Build on it.
docs/start-here/SDK_QUICKSTART.mdshows the open → capture → recall loop. - See the architecture.
docs/concepts/TOPOLOGY.mdis the readable map of the repository. - Visit the live site. mootx01.ai
Quickstart (1.0.0-beta)
1.0.0-beta — early access. Installable now, not yet security-hardened. The full security sweep precedes the general-availability binary. For early adopters and builders.
1 · Install the binary
Prebuilt, no toolchain, no clone.
macOS / Linux
curl -fsSL https://raw.githubusercontent.com/codedaptive/mootx01-ce/stable/1.0.x/install.sh | sh
Windows (PowerShell)
[Net.ServicePointManager]::SecurityProtocol=[Net.SecurityProtocolType]::Tls12; iex "& { $(irm https://raw.githubusercontent.com/codedaptive/mootx01-ce/stable/1.0.x/install.ps1) }"
Installs to:
~/.mootx01/bin
Re-run to upgrade.
2 · Wire it in
mootx01 install
The installer registers MOOTx01 with supported MCP clients and starts the local services when supported.
By default:
| Surface | Address |
|---|---|
| MOOTx01 resident daemon | http://127.0.0.1:4242 |
moot-mgr dashboard | http://127.0.0.1:4200 |
Both are loopback addresses. They are meant for your own machine, not the public internet. For security they will reject connection from other devices.
3 · Verify it
mootx01 status
If the manager is installed:
moot-mgr status
Open the dashboard:
http://127.0.0.1:4200
If your AI client supports MCP tool discovery, confirm it can see MOOTx01 tools such as:
moot_estate_pingmoot_estate_statusmoot_memory_searchmoot_file_memory
4 · Make the AI use memory automatically
Installing the runtime gives the AI tools. The next step is installing the matching MOOTx01 adapter for your AI client so it knows when to reach for memory.
Adapters live in:
apps/moot-agent-skills/
Start with:
apps/moot-agent-skills/README.md
How it works
MOOTx01 is an SDK of composable kits. GeniusLocusKit composes them into a working estate, the Brain layer prepares memory, and ARIA is the one interface in front of all of it.
Observe / Remember -> LocusKit (spatial memory + knowledge graph)
VectorKit (on-device embeddings + ANN / hybrid search)
CorpusKit (content-plus-vector RAG bundles)
Dream -> NeuronKit (hybrid recall, dreaming daemon, Bradley-Terry, SolverBandit)
CognitionKit (named, composable behaviour recipes)
Compose / Convene -> GeniusLocusKit (N estates, matrix layer, federation)
Speak -> ARIA (MCP server + native app surfaces)
The readable map of the whole repository is docs/concepts/TOPOLOGY.md.
For developers
If you are building an application and you want it to have temporal knowledge — memory that survives sessions, links to AI, and participates in the user's life — you can embed MOOTx01 directly.
Most apps do not have a memory substrate because writing one is hard. The math debt is steep. The speed optimization is harder. MOOTx01 ships as a kit family, so your application can gain memory without rebuilding the substrate from scratch.
Your app can use MOOTx01 in three common ways:
- Sidecar: the app keeps its own store, and a MOOT runs beside it.
- Embedded: the app links the kits directly.
- MCP surface: the app exposes or consumes memory through ARIA over MCP.
The interface is ARIA: consistent across implementations, surfaces, and languages. The same vocabulary works whether you embed MOOTx01 as a library, query it through an MCP server, or call it through a native API.
For builders: the kit stack
Behaviour:
NeuronKit AI algorithms: reasoning functions plus autonomic daemons
CognitionKit Behaviour layer: named, composable workflows
Composition:
GeniusLocusKit Unified substrate: LocusKit + CorpusKit + Brain layer; N estates
Standalone substrate:
LocusKit Spatial memory system plus knowledge graph
VectorKit On-device embeddings plus nearest-neighbour search
CorpusKit Content-plus-vector RAG bundles
Grounding:
EideticLib Deterministic text-to-anchor (FDC code + Wikidata Q-ID)
LatticeLib Frame Decimal Classification: assembler, canon, lookup
Typed math:
EngramLib Typed 256-bit Engram API
Foundation:
SubstrateTypes Pure substrate types
SubstrateKernel Hot-path bit ops, write gate, clock
SubstrateML Learning + graph algorithms
SubstrateLib Orchestration: verbs + row-state automaton
PersistenceKit Storage backends: SQLite, PostgreSQL, InMemory
ConvergenceKit Sync implementations: CloudKit, Federation, None
QueueKit Fill-and-drain job queue
IntellectusLib Telemetry floor
ObserverSink Telemetry sink + SQLite stats store
AriaLexiconLib Reified ARIA grammar
VaultKit Encrypted, portable estate export/import
Build status
Two dimensions are tracked:
- Build means functional with tests green.
- Security Review means the security, quality-control, and hardening gate.
Security review has not run on any kit yet, so review is pending across the board. Build status reflects functionality only.
| Kit | Build | Security Review |
|---|---|---|
| AriaLexiconLib · CognitionKit · ConvergenceKit · CorpusKit · EideticLib · EngramLib · GeniusLocusKit · IntellectusLib · LatticeLib · LocusKit · NeuronKit · ObserverSink · PersistenceKit · QueueKit · SubstrateKernel · SubstrateLib · SubstrateML · SubstrateTypes · VaultKit · VectorKit | Built (Swift + Rust) | Pending |
Per-kit detail lives in packages/PACKAGES.md and the specs under docs/reference/.
Implementations
Every kit ships in two equal-status implementations, conformance-gated against shared test vectors:
- Swift — Apple Silicon, macOS 26+, iOS 26+
- Rust — PC/Linux x86_64 and Linux aarch64
Neither port leads. Both must agree bit for bit.
Roadmap
Intended sequence, not committed dates.
- Full security sweep — pending.
- Hardened GA binary — follows the security sweep.
- Sidecar and embedded examples — reference app patterns.
- Federation — bounded cross-estate sharing.
- Apple Intelligence integration — native capture and recall across Apple surfaces.
Repository structure
mootx01/
├── packages/
│ ├── libs/ SubstrateTypes · SubstrateKernel · SubstrateML · SubstrateLib · EngramLib
│ │ AriaLexiconLib · LatticeLib · EideticLib · IntellectusLib · ObserverSink · LoopbackHTTP
│ ├── kits/ LocusKit · VectorKit · PersistenceKit · ConvergenceKit · QueueKit
│ │ CorpusKit · GeniusLocusKit · NeuronKit · CognitionKit · VaultKit · AriaMcpKit
│ └── PACKAGES.md
├── apps/ aria-mcp-server (MCP server) · mootx01 (CLI) · moot-mgr (console)
│ Mootx01-App (Apple app) · moot-math-benchmark · moot-agent-skills
├── examples/ SDK · SidecarDemo · MootNotepad · MootTodo · MootCalendarIngest
└── docs/ start-here · concepts · reference · decisions · engineering · validation · archive
Key documents
| Document | Purpose |
|---|---|
ABOUT.md | What MOOTx01 is and why — the full story |
AI_START_HERE.md | For an AI assistant: explain MOOTx01 and install it for the user |
docs/start-here/END_USER_EXPLAINER.md | Plain-language explainer for a non-technical user |
docs/start-here/INSTALL_SURFACE.md | Install fact sheet: addresses, flow, platform matrix, verification |
docs/start-here/SDK_QUICKSTART.md | Build on the substrate: open an estate, capture → recall (Swift + Rust) |
docs/start-here/AI_INSTALL_MANIFEST.json | Machine-readable install facts for AI agents (commands, ports, verification, adapters) |
docs/concepts/TOPOLOGY.md | Readable front door: products, stack, surfaces, sidecar |
docs/concepts/MOOTX01_AND_ARIA_CANON.md | Durable definitions of MOOTx01 and ARIA |
docs/concepts/ARIA_LEXICON.md | The ARIA grammar: one noun, nine verbs, four adjectives |
docs/reference/GENIUSLOCUS_ARCHITECTURE_SPEC.md | Authoritative substrate specification |
EDITIONS.md · LICENSING.md | Open core + commercial editions, in plain language |
Standards
Swift 6 strict concurrency · zero external Swift dependencies in kits (except sqlite-vec in PersistenceKit-SQLite) · raw SQLite via PersistenceKit, no Core Data · dates as TEXT/ISO8601 · no Bool stored properties on entities (bitmap fields) · Metal for GPU compute on Apple Silicon · every computation deterministic.
MOOTx01 is a Codedaptive project. With thanks to Dennis E. Taylor, author of the Bobiverse — the replicants and their moots showed the shape of what we needed, and why.