One core. Clear responsibilities.
AetherMind now has a central implementation in aethermind-engine. Start with that core, then follow the distinct roles of the coordinator, primitive specification, harness adapter, and research repositories.
The next chapter
A shared engine.
Continuity beside the work.
AetherMind is evolving around a central core. The new aethermind-engine repository brings the continuity implementation together: one library, a CLI, and an optional MCP server.
The code has a central home. Each project keeps its own append-only layers, corrections, and texture. Writers run on the host that owns those files.
Start with the engine.aethermind/Layers · texture · events · evidence pointers
Repository roles in the evolving architecture. Check each source for its current integration status.
Repository field guide
Six repositories. A central starting point.
Expand a row for the short answer. Each full guide explains what the repository is, what makes it distinct, when to use it, and what it should not be mistaken for.
Use the continuity system
aethermind-engineCentral continuity corePublic source · noncommercial license
The central AetherMind implementation: a Python library, command-line interface, and optional MCP server for append-only continuity layers beside the project they describe.
The engine brings the continuity implementation into one core. Its repository contains the format contract, layer and texture operations, auditing, briefs, and optional summary-tree support. Coordinators and harness adapters have distinct integration roles around that core.
Start here to use the current core directly, inspect its format contract, or build an integration around the library, CLI, or optional MCP server.
Each project owns its continuity files. Installation leaves services stopped; MCP and summary compaction are optional and explicitly configured. The AetherMind Noncommercial Public License permits noncommercial use, copying, modification, and sharing; commercial use requires separate permission.
aethermindLocal-first coordinatorPre-release, source-available
The cross-harness AetherMind coordinator. It wakes supported agents into project-local continuity and returns bounded, caller-driven context from the work beside them.
The coordinator provides product-level wake and coordination surfaces. The central implementation now has its own repository, aethermind-engine. Check the coordinator README for its current integration and release status before installing.
Use it when work moves between supported AI environments and you want one local coordinator, explicit provenance, and bounded recall rather than another hosted memory account.
It is not a cloud memory service or a generic transcript archive. It is source-available pre-release software, so the current README and support boundary are the authority before installation.
aethermind-primitiveContinuity primitive and specificationMIT open source primitive
The MIT-licensed, harness-neutral continuity primitive: an append-only project-local store, a reference library, validators, and a command-line interface for writing layers beside work.
The primitive repository documents the portable continuity foundation and its reference implementation. Start with aethermind-engine for the new central core, and consult this repository when inspecting the primitive contract or an existing primitive installation.
Use it to inspect the primitive format and validators, or maintain an existing integration that explicitly targets this repository. New core exploration starts with aethermind-engine.
It is not a task manager, a chat log, or a retrieval index. The store holds only load-bearing decisions, corrections, uncertainty, friction, evidence, and verification posture.
aethermind-hermes-pluginHermes reference adapterApache-2.0 reference adapter
An Apache-2.0 Hermes plugin that initializes a compact project-local AetherMind store, reads the relevant brief at session start, and exposes continuity tools during the session.
This repository packages the primitive for one harness. It is a narrow reference adapter, not the harness-neutral primitive and not proof that every Hermes deployment has native continuity support.
Use it when Hermes is the active agent environment and you want project-rooted orientation and lifecycle hooks without turning the project into a prompt transcript.
A remote service. The plugin keeps its continuity record beside the project and does not send that record to a hosted AetherMind account. It is a narrow Hermes adapter, while the project’s source records remain authoritative.
Inspect the evidence
aethermind-first-benchmark-proofPublic redacted evidence packetPublic snapshot · 26 May 2026 · commit 9272d62Historical evidence packet
A public-safe, redacted report of early AetherMind onboarding work: its methodology, aggregate observations, and the boundaries that keep the result from saying more than it can.
- Published
- Version
- No tagged release
- Source record
- Commit 9272d62
This is evidence, not software. It lets readers inspect an early orientation signal and its limits without mistaking an exploratory packet for a released benchmark or a product feature.
Use it when you want to inspect the exploratory setup, understand what was measured, or see why the project does not make portable outcome claims from it.
It is not an installer, an independent replication, or a general performance verdict. Raw prompts, recordings, private paths, and condition details are deliberately absent.
hermes-continuity-control-planeBounded local control-plane prototypeLocal adapter and kernel prototype
A small MIT-licensed local prototype that explores continuity envelopes, an append-only event ledger, narrow gate policy, and a Hermes-style integration surface.
This is adjacent architectural research, not the AetherMind store primitive or current coordinator. It tests a bounded local control-plane model without claiming native Hermes integration, production readiness, or a general memory system.
Use it when you are studying local continuity gates and control-plane behavior, or want to inspect the prototype's Python tests and contract boundaries.
It is not a context engine, bulk prompt injector, federated memory provider, or proof that compression and resumption are solved in production.