For AI Agents

Memory that knows when a fact stopped being true.

Bi-temporal memory for AI agents. Ask what was true on any past date. EU-hosted, your users in control.

# 1. Connect (reads KORELY_API_KEY from the env)
from korely_memory import Korely
korely = Korely()

# 2. Remember what your agent learns about a user
korely.add("Maria is on the Pro plan, billed yearly.", user_id="maria")

# 3. Later it changes, and Korely resolves the contradiction
korely.add("Maria downgraded to Free.", user_id="maria")

# 4. Pull a prompt-ready block, current truth only
ctx = korely.get_context(query="what plan is Maria on?", user_id="maria")
# ctx.context → "Maria is on the Free plan" (Pro invalidated, not deleted)

One key authenticates the SDK, CLI, and REST API. Get your key → · Read the docs →

Wire it into the stack you already use

Any agent that speaks REST, the SDK, or the CLI. All integrations →

Proof, not promises

Storing a fact is easy. Returning the current one is where memory breaks.

A fact changes; the question is whether your agent serves the new value or last month's. We measure that on LongMemEval, the public benchmark for long-term agent memory, and the two axes Korely is built to win are the two production agents fail most.

Knowledge update

Return the fact that's true now, not the one it used to be.

A customer downgrades, a deal moves stage, a preference flips. Korely supersedes the old value the moment the new one arrives, so the next read is current.

Temporal reasoning

Answer "what's most recent" and "what was true before X."

Every fact carries a validity window. Ask for today's truth, or time-travel to any past date with as_of — the reasoning similarity search can't do.

We run an open harness: same questions, same reader model, the same neutral judge across every system, and only the memory layer changes. The method is public today; we're publishing the scored numbers and the full per-question transcripts as we finish the rebuilt, fair harness, so you can audit every result rather than take a figure on faith.

Read the methodology & what we publish →

How it works

Three steps to memory that survives the session

01 Get your key

Sign up, get a kor_live_ key

Join the early-access cohort and we issue your API key. One key authenticates the REST API, both SDKs, and the CLI. Every surface, same store.

02 Connect

Install the SDK, or call REST

pip install korely-memory or npm install korely-memory for Python and Node — the same package ships the korely CLI. Prefer no dependency? Call the REST API from any language.

03 Remember + recall

add() once, get_context() forever

Your agent writes what it learns with add(), scoped by user_id. Any later session, even a different agent on the same key, pulls a prompt-ready block back with get_context().

Why Korely

What makes Korely different

Append-and-match memory keeps every version of a fact and lets similarity pick one. Korely stores typed facts in time: the current truth, the full history, and a navigable graph, included on every tier, not removed and not upsold.

facts for user "maria" json
# What's true right now?
korely.get_facts(user_id="maria")
[
  { "predicate": "subscribed_to", "object": "Free plan",
    "valid_from": "2026-06-14", "invalid_at": null },   // current
  { "predicate": "subscribed_to", "object": "Pro plan",
    "valid_from": "2026-01-02", "invalid_at": "2026-06-14" }  // superseded, not deleted
]

# Time-travel: what was true back in March?
korely.get_facts(user_id="maria", as_of="2026-03-01")
# → "Pro plan" (the Free fact didn't exist yet)

Point-in-time queries

Every fact carries a validity window. Ask for the current truth, or pass as_of to see what your agent knew on any past date.

Contradictions resolved

When a fact changes, the old value is invalidated with a timestamp, not duplicated. Your agent reads the current truth, and the history stays queryable.

A graph, included

Facts are typed subject – predicate – object triples: a navigable entity graph on every tier. Follow what connects to whom, no extra add-on.

See, correct, forget

Every memory is an inspectable typed fact. Correct it, or erase a whole user with one call. Korely-app users also get a Memory Panel over the same store.

EU-sovereign by default

Hosted in the EU (Helsinki) on every tier, GDPR-native, no US CLOUD Act exposure. Where the regulated buyer needs it to be.

Flat, read-generous

Reads cost us almost nothing, so we don't meter them like writes. Flat monthly pricing, no overage bill that explodes on a busy week.

What Korely does

One memory layer, every shape your agent needs

Semantic vector recall, a typed knowledge graph, and bi-temporal facts, in one store. REST, SDK, and CLI for any agent.

Capability
How Korely does it
Memory model
Semantic vector recall over memories, a typed entity graph, and bi-temporal facts, in one store. Contradictions resolved on write.
Time + truth
Bi-temporal facts (valid_from / invalid_at). Point-in-time queries with as_of; contradictions invalidate, never delete.
Where memories live
A managed cloud store (Postgres + pgvector), with EU data residency.
Agent integration
REST API, Python + Node SDK, and a CLI (it ships inside the Python package).
Retrieval
Semantic vector search over stored memories, plus deterministic lookup of typed facts and entity relations. No model on the read path.
SDKs
Python and Node.js, plus REST from any language. The CLI installs with the Python package.
Hosting
EU-hosted on every tier. No overage billing, ever.
Pricing model
Flat, predictable pricing. Graph and temporal included in every paid tier.

Trust & control

Built for the data you can't be careless with

The same primitives a regulated team needs, on every tier, not gated behind an enterprise call.

EU-sovereign

Hosted in the EU (Helsinki) on every tier. No US CLOUD Act exposure. DPA on request.

GDPR data-control

Inspect, correct, or erase a user's entire memory with one call. Invalidations keep an audit trail.

Never trained on

Your users' memories are theirs. We don't train models on your data, and you can export it anytime.

Fast, deterministic reads

No LLM sits on the read path, so a correction propagates instantly and fact reads return in p95 under 50ms.

In production today The same engine powers Korely's own notes app, tracking thousands of typed facts and resolving contradictions daily.

Pricing

Flat, predictable pricing, with the graph included

Free for hobby projects. $19/mo for serious builders. EU-hosted by default.

Hobby

Single dev, side projects.

Free forever
  • 1K memories/mo
  • 25K queries/mo
  • 2 agents
  • Unlimited end users
  • Graph + temporal, EU-hosted
Most popular

Developer

Graph + temporal included.

$19 /month
  • 5K memories/mo
  • 250K queries/mo
  • 10 agents
  • Unlimited end users
  • Graph + temporal, EU-hosted

Team

For growing teams.

$79 /month
  • 25K memories/mo
  • 1M queries/mo
  • 100 agents
  • Unlimited end users
  • Graph + temporal, EU-hosted

Scale

High-volume production.

$249 /month
  • 75K memories/mo
  • 10M queries/mo
  • 500 agents
  • Unlimited end users
  • Graph + temporal, EU-hosted

Join early access to get the first year at half price. · Full pricing →

Early access

Stop renting your agent's brain

Leave your email and you're in the first cohort, with the first paid year at half price.

One email, nothing else. No newsletter, no tracking. Unsubscribe anytime.

Read the docs, ship today.

The full REST + SDK reference, the bi-temporal model, and copy-paste examples in Python, Node, and cURL.

Read the docs

Building for humans, not agents? Korely also makes a desktop notes app →