EvaluatedApplications.PleromaMind 2.0.0

PleromaMind

A persistent conversational unit built on exact holograms. It starts empty, learns every exchange it hears and says along with any text you teach it, takes bounded and fading feedback on its choices, forgets a conversation exactly, and rebuilds its whole state from its journal.

Upgrading from 1.0.0

2.0.0 removes the built-in voice. A unit starts empty and knows only what you teach it.

• Removed: Voice, SeedSpec, the Unit.Create / Unit.Open / Unit.OpenOrCreate overloads that took a voice, the command-line verbs learn, build-voice and frames, and the always-zero voice fields: OrderTerm.VoiceN and the voice entries of the Unit.CountOf result, which is now (LiveCount, LiveN).
• Replaced by: Unit.Create(dir, new ModelDesign { ... }), Unit.Open(dir) and Unit.OpenOrCreate(dir, design), where the design and the vocabulary are saved with the model; Teach, TeachFile, Ingest and Read for your own text; and LearnStep for the optional learned layer.
• Nothing the voice supplied (text, word list, primer) ships any more. Memory depends on the design and on the text you ingest; see ModelDesign.Estimate.
• A unit folder created by the 1.0.0 build does not open with Unit.Open in 2.0.0: it holds no saved design, so Open throws a FileNotFoundException for design.json and leaves the folder unchanged. Create a new unit and teach it again.

What it does

• A model you design. Unit.Create(dir, new ModelDesign { ... }) builds a fresh, EMPTY model: no voice and no primer. Its alphabet is Prism's 320 tokens (96 characters, 224 default words and chat tags) plus ExtraSubwords minted by Prism's own rule from the .txt files of MintFolders (MintTokenizer.Mint). STOP (id 95) ends a turn. The design (exact orders, conversation orders, conversation memory, temperature, reply cap) and the vocabulary are saved with the model and restored by Unit.Open(dir). ModelDesign.Estimate(bytes) returns the estimated memory by formula, without running anything.
• Token identity. Each token is its residue pair on two coprime cycles whose product covers the vocabulary (chosen from the vocabulary size), the identity of a Pleroma page.
• Chat format. A turn is user: text or prism: text followed by STOP. Unit.Say continues <history>user: text STOP prism: and ends at STOP or the design's cap. A reply never contains a speaker tag.
• Learned memory. Everything heard, said, taught and ingested is counted exactly for contexts of up to the design's longest order, per conversation, in sorted token indexes: about 10 bytes per token, roughly 7 to 8 MB of memory per MB of text ingested. Memory grows with the text you teach; it does not depend on the number of orders. ModelDesign.Estimate(bytes) gives the figure by formula (an estimate from 50 MB samples, not a promise). A choice mixes the design's exact orders (and order 0 as the floor), with backoff shares per (order, log2 bucket of n).
• Conversation memory. For the design's conversation orders (default 8, 12, 16), the counts of what followed the same last tokens earlier in this conversation are mixed in with their own trust. Long matches earlier in the same conversation are counted and mixed in, so a fact taught early can be picked up again later in the conversation. CalibrateConversation(text or tokens) fits one trust per conversation order on a calibration text with the unit's own solver, journals it (replayed on open, kept by checkpoints, part of the state hash and of Replay), and from then on chat (Say, SayCandidates, Explain) and ScorePassage use it for the conversation rows; a unit never calibrated behaves exactly as before, and UseConversationTrust = false switches it off at runtime. CalibrateConversationFromHistory(conversation) calibrates from the conversation's own history once it holds 4,000 tokens, and otherwise declines with a plain message.
• Learned layer. With ModelDesign.LearnedLayer (default on) the model has a sharing layer over the tallies: tokens are sorted into ClassCount classes by what follows and precedes them, a context of ClassOrders tokens is read as the sequence of its classes, so contexts that share structure share one tally. Unit.LearnStep(budget, heldOut) is the only thing that learns it, and it runs only when called: it refines the classes from the bigram statistics, then solves the trust of every context length in log space on leave-one-out counts (Phasor's streamed per-harmonic solve, Gauss-Newton, warm-started), for the plain tally and for the learned mixture, and journals both, so steps add up and Open restores them. Unit.Compare(text) scores the same held-out text with the plain tally and with the layer (bits per character, same scoring); Unit.LearnedStats shows the classes with their commonest tokens, the tables' size and the last comparison; Unit.LearnedLayer = false returns exactly the plain tally. Explain lists the layer's terms (source "learned") with their share. The layer starts empty and does nothing until its first step.
• Teach and ingest. Teach(prompt, response, conversation, weight) learns one exchange in the chat format. TeachFile learns a file of user: / prism: lines by reference. Ingest(path, offset, length) learns a byte range of a text file by reference: the journal holds only (file, offset, length, hash). The pure work of many 1 MB slices (hash, tokenise, build the sorted run) runs at once across the cores, at most twice the core count in flight, and the sorted runs are joined by linear merges that are themselves cut across the cores; the journal write and the learning stay serial in slice order, so a parallel ingest reaches the state of a serial one. Pass a CancellationToken to stop at the next slice boundary; the returned count is where to resume, and a resumed ingest reaches the same state as an uninterrupted one. Read(text) of long text is written to the unit's texts folder and journaled by reference.
• Pick one of N. SayCandidates(conversation, message, n) returns N distinct sampled replies and changes nothing. Pick(conversation, message, chosen, rejected) then learns the chosen exchange, approves it, and disapproves the rejected replies as text the unit did not say (Accept, ApproveText and DisapproveText do the parts).
• Feedback. Approve and Disapprove multiply the choice shares of the pairs by 2^(S/H). The effect is bounded, fades to exactly 1 within the horizon, and never touches the memory.
• Forget. Forget(conversation) drops a conversation's memory and events exactly.
• Journal and recovery. The events log of a HoloDb PleromaPageStore is the journal: each event is durable before it is applied. Checkpoint writes the memory; Unit.Open loads it and applies again the events after it, so a crash between an event and its learning is repaired exactly once.
• Solve. Solve(theta) installs a re-solved share vector as a journaled event; replay restores it exactly. theta holds the backoff log-shares: one number for each context length (order 0, the exact orders, the class orders when the layer is on, then the conversation orders) and each log2 bucket of the context's count, nine buckets per row, ThetaLength numbers in all. SolvePlain(theta) does the same for the layout without the class rows.
• In-passage scoring. Unit.ScorePassage(text, design?) scores a passage token by token from the memory plus a conversation term built online from the passage's own earlier tokens (the optional design overrides only ConversationMemory and ConversationOrders, so short orders such as 3, 4, 6 can be tried without rebuilding the unit). It returns bits per character and nats per token, changes nothing (no journal event, same state hash) and is deterministic. The memory rows of the trust are the unit's; a conversation row keeps its value when the unit's design has that order, else the fixed conversation default, because no learning step solves the conversation rows. With conversation memory off it equals Score. The in-passage counts are held in a host dictionary.
• Inspection. Unit.Explain returns the final shares and, for each context length (and the conversation's), the context, the counts, the trust and its share of the mixture, the top next tokens, and the feedback multipliers. Unit.Stats returns conversations, runs, tokens, bytes, characters learned, bytes per megabyte, compactions, and the journal and process memory.
• Organs. Organs.All lists the unit's twenty-six grid cells, which are active and which are declared stubs with their reasons.

Use

using PleromaMind.Engine;

var design = new ModelDesign { ExtraSubwords = 0, ExactOrders = new[] { 1, 2, 4, 8 } };
using var unit = Unit.OpenOrCreate(dir, design);
unit.Ingest(textFile, 0, long.MaxValue);
unit.Teach("What is your name?", "My name is Lily.");
var options = unit.SayCandidates("c1", "Hello! Who are you?", 3);   // changes nothing
unit.LearnStep(2, heldOutText);                                       // learn the classes and the trust; unit.Compare(heldOutText) scores held-out text with and without it
unit.Pick("c1", "Hello! Who are you?", options[0], options.Skip(1));
Console.WriteLine(unit.Say("c1").Text);
unit.Checkpoint();

Requirements

The model starts empty. Teach it from text you have the right to use; the package ships no text and no voice. Put .txt files in MintFolders if you want minted subwords.

License

Proprietary — this package ships the compiled library only; see LICENSE for the full terms. Installing and using unmodified copies for internal evaluation and non-commercial development or testing is licensed; commercial, production, or revenue-generating use requires a separate commercial licence from the owner. No feature on this page is gated behind a tier or a licence key — every capability described works identically with or without one. Copyright (c) 2026 Dongyang Stephen Chen, trading as Evaluated Applications. All rights reserved.