Glossary

Definitions.

The vocabulary of deterministic AI — defined in long form, in Lexi's voice, without filler.

Written by Lexi Nicole Neter, Physicist & Founder, HialaraUpdated May 16, 2026

Deterministic AI

Deterministic AI is artificial intelligence whose outputs are reproducible by construction: given the same input and the same memory state, the system produces the same output every time, and every reasoning step is recorded in a way that can be replayed and verified. It is the opposite of the dominant paradigm, in which large language models sample outputs from a probability distribution and produce subtly different answers across runs. The point of determinism isn't to make AI rigid; it's to make it accountable. When an answer can be reproduced, it can be audited. When an audit is possible, errors become visible instead of hiding behind plausible-sounding variation. Deterministic AI doesn't require giving up the generative capabilities of modern models — generative components can sit inside a deterministic system as long as their inputs, parameters, and outputs are recorded. What changes is the substrate underneath: memory persists, reasoning is logged, and the agent's behavior over time can be inspected like any other engineered system. This matters most for work where consistency and traceability are not optional: research, compliance, scientific discovery, long-running agents, anything where "sounds right" is not the bar. Deterministic AI is the architectural answer to the question of why probabilistic systems cannot, on their own, support the kind of trust that high-stakes thinking requires.

Probabilistic AI

Probabilistic AI is the broad category that includes most modern large language models — systems that, given an input, sample an output from a learned probability distribution. The same prompt run twice will often produce different answers, sometimes subtly, sometimes substantially. This is not a flaw in the engineering; it is a property of the architecture. Probabilistic models are optimized for fluency, generalization, and creative variation, all of which require the system to choose among many plausible continuations rather than commit to one. For a lot of work, this is exactly right: drafting, brainstorming, summarization, single-shot generation. For other kinds of work — long-running projects, regulated decisions, multi-step reasoning that has to stay consistent across weeks — probabilistic outputs are a liability. The drift is silent. You ask the same question Tuesday and Friday, get two reasonable-sounding answers, and have no way to know which one to trust. Probabilistic AI also cannot, in any rigorous sense, audit itself. When asked how it reached a conclusion, it generates a plausible explanation, not a recorded trace. None of this disqualifies the technology; it just clarifies where it belongs. Probabilistic models are excellent generative tools. They are not, by themselves, infrastructure you can build serious thinking on. That's what deterministic systems are for.

Persistent memory

Persistent memory is long-term storage for an AI agent — context that survives across sessions, process restarts, and even model upgrades, because the memory lives outside the model rather than inside its context window. Most products that advertise "memory" today are doing something more modest: they save a small profile and reinject it into each new prompt. That helps with tone, but it isn't really memory; it's preferences. Persistent memory means there is an actual store where every meaningful fact, every concluded thread, every decision is durably recorded, indexed for retrieval, and versioned so prior states can be reconstructed. The agent can come back to it weeks later and find the work intact. The user doesn't have to re-explain themselves. The conversation that started in March can be continued in October, with the same context active. Persistence is the precondition for an AI that can act as a thinking partner instead of a request handler. Without it, every interaction starts from zero and serious work is impossible. With it, an AI can do something completely different: hold the shape of a project, surface what was already settled, and let your thinking compound instead of resetting every time you log back in.

Memory architecture

Memory architecture is the system that determines how an AI agent stores, retrieves, updates, and verifies context over time. It is the design decision that decides what kind of cognition is even possible. A memory architecture answers four questions. First, persistence: does memory survive sessions, or is it ephemeral? Second, structure: is memory stored as opaque embeddings, as typed entities and relationships, or as symbolic facts? Third, retrieval: do we surface context by similarity search, by deterministic lookup, by graph traversal, or by some combination? Fourth, integrity: can we prove what was remembered and when, or is the store opaque even to ourselves? Most current AI products skip the architecture entirely. They use the model's context window as a working scratch pad and simulate memory by re-injecting summaries into each new prompt. That works at small scale and breaks at scale. A real memory architecture is engineered the way a database is engineered — with explicit schemas, consistency guarantees, and write semantics — because that's what the work requires. Hialara's memory architecture combines a structured memory graph as the system of record, deterministic retrieval as the default, optional vector indices for fuzzy similarity, and cryptographic signatures on every memory event so the entire history is verifiable.

Structured memory graph

A structured memory graph is an AI memory representation in which facts, entities, and the relationships between them are stored as typed nodes and edges rather than as opaque embeddings. Every node carries explicit provenance — where it came from, when it was written, what produced it — and every edge has a typed relation: "caused," "contradicts," "refines," "depends on." The advantage over a flat vector store is that retrieval is deterministic. You can ask the graph a specific structural question ("what conclusions depend on this assumption?") and get the same answer every time. You can traverse it, audit it, and reason over it in ways that similarity search cannot support. Structure also gives you the ability to detect contradictions, track how a position evolved, and replay how a conclusion was reached. None of this requires giving up vector search; embeddings can be layered over the graph as an index for fuzzy recall. But the graph is the system of record. It's what the agent comes back to when it needs to be sure. Structured memory graphs are how you build AI cognition that actually compounds — not as a pile of remembered text, but as a connected, queryable substrate that the agent's reasoning can stand on.

Vector memory

Vector memory stores information as high-dimensional embeddings — numerical representations of meaning produced by a neural model — and retrieves by similarity search: given a new query, find the stored vectors closest to it in embedding space and return the associated text. It is fast, flexible, and works well for fuzzy recall. It is the foundation of most retrieval-augmented generation systems in production today. It is also approximate by construction. Two semantically similar queries can return different sets of results depending on the indexing parameters, the embedding model's version, and the precise contents of the store at the moment of retrieval. That non-determinism is fine when the goal is fuzzy semantic search. It becomes a problem when the goal is reasoning that has to be reproducible. Vector memory also lacks explicit provenance: each embedding is opaque, and the relationships between stored items are implicit in the geometry rather than encoded in the schema. You can ask a vector store "what's similar to this," but you cannot directly ask it "what depends on this" or "what contradicts this." Vector memory is a powerful tool. It is not, by itself, a memory architecture — it's a retrieval index that needs structure underneath it to support deterministic agent cognition.

Replayable reasoning

Replayable reasoning is reasoning whose every step is recorded at the moment it happens, in enough detail that the entire chain can be re-executed later to verify how a conclusion was reached. Given the same inputs and the same memory state, replaying the trace produces the same intermediate steps and the same final answer. The point is not nostalgia; it is verification. With a replayable trace you can audit an AI's reasoning the way you would audit a financial transaction, diff two versions of the same answer to see exactly where they diverged, or use a stored trace as a regression test against future behavior. Replayable reasoning is what makes the difference between trusting an AI because its tone is confident and trusting it because the chain of reasoning is open to inspection. It also changes how errors are caught. Without a trace, a wrong answer is a black box and you can only argue with the conclusion. With a trace, you can find the exact step where the reasoning went off, fix it, and prove the fix held. For long-running agents, regulated workflows, and any system whose decisions have to be defended later, replayable reasoning is not a feature — it's a prerequisite for being usable at all.

Cryptographic memory integrity

Cryptographic memory integrity is the property that every memory event in the system is signed at the moment of write, so any later alteration is detectable. The signatures chain — each new event commits to the state of the prior events — which means the entire memory log is tamper-evident as a whole, not just per entry. The practical effect is that you can prove what the agent knew at any point in its history. Nothing can be quietly edited after the fact without breaking the chain. For regulated work, this is the difference between a system you can put in front of an auditor and a system you can't. For collaborative work, it's the difference between trusting the record and arguing about it. For the agent itself, it's the difference between reasoning over a substrate that is verified and reasoning over one that is assumed. Cryptographic integrity is not about security in the narrow sense; it's about epistemic discipline. It forces honesty about what was remembered and when, and it gives downstream systems — compliance reviewers, autonomous workflows, multi-agent supervisors — a basis for trusting the agent's recall. Most AI products treat memory as scratch paper. Hialara treats it as a ledger.

AI agent cognition

AI agent cognition is the full set of capabilities an autonomous AI system needs to act coherently over time: perception, memory, reasoning, planning, and the ability to update its own internal state as the world changes. The phrase matters because most current AI products are not really agents in this sense — they are request handlers, with no internal state that persists between calls. An agent has to do more than answer; it has to remember what it answered, hold a model of the situation it's operating in, and adjust as that situation evolves. That requires cognition as infrastructure: a memory layer that persists across sessions, a retrieval system that returns the same context twice, a reasoning trace that can be inspected, and an orchestration layer that decides what gets written, what gets surfaced, and how conflicts are resolved. Without those, you can build a convincing demo of an agent for ten minutes. You cannot build one that is still trustworthy after a month. AI agent cognition is the engineering problem of moving from impressive single interactions to reliable long-horizon behavior — and it's what Hialara's substrate is designed to make possible.

Memory orchestration

Memory orchestration is the coordination layer that decides, on every turn, what the agent writes to memory, what it reads back, when memories are consolidated, and how conflicts are reconciled. It sits between the raw stream of inputs and the structured memory store underneath, and it turns conversational noise into a durable, queryable cognitive substrate. Orchestration is where the hard decisions live. Not everything an agent encounters is worth remembering, and the wrong write policy floods the store with low-value entries that make later retrieval worse. The right one captures what is genuinely informative — claims, decisions, contradictions, references — and lets the rest go. Orchestration also separates short-horizon working memory (the active thread of a conversation) from long-horizon semantic memory (what the agent knows about the project as a whole), and decides when to promote one to the other. When two memories conflict, orchestration resolves the conflict via explicit policy rather than implicit re-sampling: the new claim overrides the old, both stand under different conditions, or the contradiction is flagged for the user. The quality of an AI's long-term cognition is almost entirely set by the quality of its memory orchestration. Without it, even a perfect storage layer is unusable.

Context window

A context window is the maximum span of text — measured in tokens — that a language model is allowed to read in a single inference call. Everything the model knows about the current situation has to fit inside it. Whatever doesn't fit gets dropped. Context windows have grown dramatically in the past few years, from a few thousand tokens to hundreds of thousands and in some cases millions, and that growth has been treated, especially in marketing, as if it solves the memory problem. It does not. A larger window is still ephemeral: when the request ends, the window is gone. It is also expensive — every token costs compute on every call — and quality degrades as the window fills. Most importantly, a context window is not memory; it is the model's working scratch pad on a single request. Conflating the two is one of the most common mistakes in AI product design. Real memory lives outside the model, in a persistent store with its own retrieval semantics, and the context window's job is to hold the small slice of that store relevant to the current turn. Bigger windows are useful. They are not a substitute for a memory architecture.

Second brain

A second brain, in the way the term is usually used, is an external store of notes, references, and ideas that augments your own memory — Zettelkasten, Roam, Obsidian, Notion, whatever the current tool is. It is a filing cabinet that you, the user, are responsible for organizing, searching, and connecting. The metaphor is appealing and the tools are useful, but they share a limitation: they are passive. They wait for you to come back, find the right note, and reconstruct the context yourself. A real second brain — the version the metaphor implies — would do more than store. It would remember what you concluded as well as what you wrote, surface the relevant prior thinking when you start a new thread, hold the shape of long projects across months, and notice when a new idea contradicts or refines an old one. That requires AI cognition with persistent memory, structured retrieval, and reasoning that can connect threads, not just a better text editor. Most "second brain" products are still filing cabinets in nicer clothes. The version Alara is built toward is something different: a thinking partner that actually carries the load between sessions instead of handing it back to you every time you log in.

EEAT

EEAT — Experience, Expertise, Authoritativeness, Trustworthiness — is Google's framework for evaluating the quality and credibility of online content. It is most often invoked in the context of search ranking, but it really describes a set of signals that any sophisticated answer system (search engine, AI assistant, citation tool) uses to decide which sources to surface. The signals are concrete. Experience: is there evidence the author has actually done the thing they're writing about? Expertise: do they have the background to be writing about it credibly? Authoritativeness: is the source — the site, the publisher, the person — recognized in the relevant domain? Trustworthiness: is the content accurate, transparent about its sources, and free of obvious incentives to mislead? For content meant to be cited by AI systems as well as ranked by search engines, EEAT is the difference between being one of many results and being the source that gets quoted. The practical implications are mundane and important: name the author, link to credentials, date the content, cite sources, write definitions in declarative language that can be lifted as direct answers. None of it is exotic. It's just the discipline of taking authorship seriously in a world where the audience is now half humans and half machines.

AEO — AI Engine Optimization

AEO, or AI Engine Optimization, is the discipline of structuring content so that AI answer engines — ChatGPT, Claude, Perplexity, Gemini, and the next generation of systems that synthesize answers from sources rather than returning a list of links — can extract, cite, and attribute it accurately. It is the successor to traditional SEO in the same way that answer engines are the successor to keyword-matched search. The mechanics overlap with SEO but the emphasis is different. AEO rewards declarative definitions over keyword-stuffed paragraphs, named entities that can be resolved to a canonical identifier, structured data (JSON-LD: FAQPage, Article, Organization, Person, DefinedTerm) that gives the answer engine an unambiguous schema, consistent claims across pages so the engine doesn't have to choose between conflicting versions, and clear authorship so EEAT signals attach to the right person. AEO also rewards being the source of the definition rather than a paraphrase of it. AI systems prefer to cite the page that originates a term to the page that summarizes someone else's origination. The practical work of AEO is unglamorous: write the thing precisely, mark it up correctly, and make sure the same definition appears wherever the term shows up. That's most of the game.

Knowledge graph

A knowledge graph is a structured representation of entities and the relationships between them — people, places, concepts, events — stored in a form that machines can traverse and reason over. Google's Knowledge Graph is the most familiar example, but the pattern shows up everywhere: enterprise knowledge bases, product catalogs, scientific ontologies, and increasingly, the memory layer of AI agents. The defining feature is that everything is typed. A node is not a blob of text; it is an instance of a specific kind of thing (Person, Organization, Concept, Document) with defined properties and defined relationships to other nodes. That structure is what makes the graph queryable. You can ask precise questions — "what concepts depend on this assumption," "who founded this organization," "what conclusions in this project contradict each other" — and get deterministic answers, not approximations. For AI memory, knowledge graphs solve a problem that flat vector stores cannot: they preserve the shape of reasoning, not just the surface of language. Hialara's memory layer is built around a structured graph for this reason. Vector retrieval can sit on top as an index for fuzzy similarity, but the graph is what the agent reasons over. It's the difference between an AI that recalls text and an AI that knows things.

Where these terms show up in the wild

Read the architecture page for how Hialara puts these primitives together, the FAQ for plain-language Q&A, or the blog for essays that go deeper on each concept.