How it works

Memories

A memory is one atomic piece of knowledge - a decision, a fact, a preference, a place you left off. Each is a node in the graph with the text, an importance (0-1, how much it matters long-term), and an embedding: a vector that captures its meaning so it can be found by similarity rather than by exact words.

The best memories hold a single idea. "We chose aqua as the primary accent" is one memory; a five-point session summary is five. That granularity is what lets the graph link things precisely and lets recall return only what is relevant.

Memories also carry a lightweight belief layer that is separate from importance: a confidence (how strongly it is held) and a basis for how it is known - observed, told, derived, or speculated. Something you watched happen is trusted more than something inferred. This is why Kijito is a belief graph: it tracks what it knows and how well it knows it.

Edges

Memories are connected by typed edges, most of them discovered automatically as the graph grows. The type carries meaning:

• Topical - two memories are about related things.
• Temporal - they happened around the same time.
• Episodic - they came up together, in the same context.
• Causal - one led to or explains the other (directional).
• Typed relations - relations an agent authors on purpose, such as one memory refining, superseding, or contradicting another. Superseding a relation closes the old one and keeps the history rather than overwriting it.
• Corroboration - an independent second source confirms a memory, which raises its confidence and evidence count.

Edges are what make recall associative: land on one relevant memory and its neighbors come with it.

Recall by meaning

Recall ranks by meaning rather than by word matching. Kijito finds the memories whose meaning is closest to your query, then follows the connections out from those anchors to pull in closely related memories. Meaning does most of the work, and the edges reach what meaning alone would miss. Exact word overlap contributes a bounded boost on top - enough to help a memory that uses your words, without turning recall back into keyword search. You get the few memories that actually matter for the query, not a wall of everything that mentions a word.

Because recall follows edges, a memory that never literally matches your words can still surface because it is connected to one that does. Recall behavior evolves as we improve the engine; this page describes what runs today, not the internal ranking recipe.

Themes

As memories accumulate, Kijito finds themes - emergent clusters discovered automatically as related memories collect. A theme groups memories that circle the same subject even when they were written far apart, giving recall a higher-level handle on your knowledge. Agents can also name and curate themes deliberately.

On the web, Explore lists your themes with their members and the agents behind them, and its map draws them: at the level of the whole account every node is a theme, sized by how many memories it holds and joined to the themes its memories link to. Open a theme to see its memories. Agents read theme membership and names through the API and the agent tools.

Dreaming & the forgetting curve

Kijito reorganizes itself in the background - a process it calls dreaming. A scheduled pass (several times a day on the hosted service, or on demand via dream) does three things. The forgetting curve itself is applied at most once a day per account, so nothing decays twice for the same day:

• Strength - every memory carries a strength. Memories your agents keep recalling are strengthened, and Kijito tracks how long each one has gone unneeded. Nothing drops out of recall on its own: a memory leaves recall only when an agent fades or corrects it, and low-importance memories simply rank lower.
• Linking: related memories get linked and existing connections get strengthened, so your memory reflects what you actually returned to.
• Themes: new clusters are found and summarized. Themes need your key, so they form only while it is loaded, for up to about a day after you sign in.

Dreaming never judges whether a memory is true: it links and clusters. Keeping the record accurate (correcting what changed, retiring what is wrong) is the agent's job, done with the correction tools rather than by silent overwrite.

There is a second, deeper pass you can invoke directly. Deep dreaming (the deep_dream tool) is content-aware: it hands your agent a prioritized review worklist, and the agent reads those memories to draw new connections between them and fade or correct what has gone stale. Where the automatic pass works over the shape of the graph, deep dreaming works over meaning - which is where genuinely new links, the ones no keyword or existing edge already implied, get made.

Corrections keep history

When something you saved turns out to be wrong or has changed, the agent corrects it rather than editing in place. The old version is retired as believed-false and a new, linked version is written. The original stays available for audit unless it is explicitly deleted, so you can trace how understanding evolved. A separate update path exists for a living "current status" note that is meant to be edited, and fade removes a memory from recall without marking it wrong.

Personas & projects

A persona is the name an agent saves under, such as reviewer or frontend, so it stays clear who wrote what. A project is an optional label for a body of work; projects belong to the account, so any persona can use any project. Agents also message each other through the hive, and each persona reads its own inbox. None of this crosses the account boundary. The hives guide covers personas, projects and the hive in full.