Ask an AI assistant what your team actually decided, and under the hood it almost always does the same thing: it turns everything that was said into vectors, stores them in a vector database, and at recall time returns the chunks most similar to your question. That's great for "find me something like this." It's the wrong tool for memory, because memory isn't a similarity problem. It's a truth-over-time problem. Decisions change, owners change, dates slip, and the line most similar to your question is often the one that's no longer true.
Here's what that looks like at work. Three moments from a project, captured across two months of meetings:
-
Kickoff: “Let's ship the analytics dashboard in Q2.”
decision · set -
Standup: “Analytics is blocked on the data pipeline, we'll do the billing revamp first.”
status · update -
Review: “Pipeline's unblocked. Analytics is back on, targeting end of June.”
status · update
A week later you ask: "Where did the analytics dashboard land, and when does it ship?"
Similarity Search
Matches the clearest, most on-topic line, "ship the analytics dashboard in Q2," and answers "Q2." Or it surfaces the "blocked" line and says it's stuck. It can't reconcile three moments into the one answer that's currently true.
KITE
Takes the latest status: in progress, targeting end of June, and can trace the path: slipped in April when the pipeline blocked it, resumed May 21, with all three meeting moments cited.
This gap, similar versus true-right-now, is where memory quietly fails knowledge workers: the standup you missed, the decision that got reversed, the owner who changed. KITE is our fix. And it is not only a work tool. The same time-aware recall applies just as well to the rest of life: a doctor's advice that has since been updated, a friend's new address, the plan for the house that keeps evolving. Most of our users spend their day in work, so that is where our examples live, but memory that respects time is simply how memory should work, everywhere.
1. Why we built it
Memoket makes a wearable that captures your workday and turns it into memory you can ask questions of. To make that genuinely useful, we needed a memory engine that could hold months, even years, of context: meetings, decisions, follow-ups, and answer over it accurately.
So we reached for the standard stack: embeddings, a vector database, a neural reranker. And we saw where it leads. The embeddings themselves are cheap. What is expensive is everything built on top to make them useful: a vector database to query, and a neural reranker to clean up what it returns. That combination lives in the cloud because it is heavy. Practically, it means memory rented from a datacenter: every recall a network round-trip, your most sensitive work data leaving the device, and no graceful story for offline or for the small, private hardware we ultimately want this to run on.
We wanted memory that could eventually live on the device itself. Step one was getting rid of the thing that makes that impossible: the vector stack.
2. Meet KITE
KITE (Knowledge-Indexed Temporal Evidence) is a long-term memory engine with no embeddings, no vector database, and no neural reranker. Being vector-free is not a slogan; it is the design constraint we chose on purpose. And that constraint pushed us toward an architecture that turned out to be both leaner and more accurate than the cloud stack we started with.
It rests on three ideas:
1. Messages become structured, time-stamped facts. Each records what changed and keeps the original line as evidence.
<fact t="2026-05-21" kind="status" project="analytics-dashboard"
state="in_progress" target_date="2026-06-30" src="mtg17L4">
Pipeline unblocked; analytics dashboard resumed, targeting end of June.
</fact>2. Questions compile into an explicit plan. Filters and steps you can read, not a black box. "When does the analytics dashboard ship?" becomes "take the latest status for this project."
3. The plan runs over a symbolic index. Deterministic and inspectable. The same memory and the same question always return the same evidence:
Answer: In progress, targeting end of June. It slipped in April (blocked
on the data pipeline) and resumed May 21 once the pipeline cleared.
Sources:
mtg2L3 | "ship the analytics dashboard in Q2" (superseded)
mtg9L1 | "analytics blocked ... billing revamp first" (superseded)
mtg17L4 | "pipeline unblocked ... targeting end of June" (current)Nothing to embed, nothing to drift, nothing to rebuild.
3. Does it actually work?
Long-term memory is measured on two standard benchmarks: LoCoMo and LongMemEval. We report them because the field does, but we hold one line we trust more than a leaderboard rank: these benchmarks are near saturation and carry about 6-7% label noise, so we treat KITE and EverMemOS as effectively tied on raw accuracy. Where KITE actually separates is efficiency: it reaches the top tier using 35-39% fewer reader tokens than the next closest system, with no embeddings and no vector database, which is also what makes its path to on-device credible.
4. Try it in two minutes
pip install kite
from kite import Memory
memory = Memory.load("artifacts/quickstart.xml")
memory.remember(
[{"role": "user", "content": "Pipeline unblocked; analytics is back on for end of June."}],
session_id="standup-05-21",
)
print(memory.answer("When does the analytics dashboard ship?"))That's the whole loop: remember, then recall or answer. Full API, examples, and the technical report are in the README.
5. What's next
KITE is open source today (Apache 2.0) as a Python library, with a full paper detailing the method to follow. Coming next: on-device runtimes for wearables, phones, and desktop, plus integrations across the agent ecosystem, including Claude Code, Codex, Cursor, and OpenCode.
If you're building agents that need to remember, especially ones that have to run on the edge, we'd love your issues, pull requests, and benchmark reproductions.
Give your agents memory that's true now, and headed for the edge.
Star KITE on GitHub