For AI Agents

Memory that always knows what's still true.

Bi-temporal memory for AI agents. Resolve contradictions, 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 temporal-reasoning ss·user ss·preference ss·assistant multi-session
recall@k retrieval · ~100% QA end-to-end answer

Per-axis profile on LongMemEval.

  1. Knowledge update

    Serve the value that's true now, not last month's.

  2. Temporal reasoning

    What's latest, and what was true before a date.

  3. Single-session · user

    Recall what the user just told you.

  4. Single-session · preference

    Carry preferences into the next turn.

  5. Single-session · assistant

    Remember what your agent committed to.

  6. Multi-session

    Connect facts across many past chats.

Open harness: same questions, same reader model, same neutral judge, only the memory layer changes. Every transcript is public to audit.

How it works

Your agent just chats. Korely keeps it on what's true now.

korely · memory
Memory

Typed facts from plain conversation, contradictions resolved, recalled by any agent, the same store, across every session.

Why Korely

Memory your agent can trust.

Typed facts that resolve over time, so your agent answers from what is true now. The full history and the graph are one query away.

0×more correct answers
<0msto fetch a memory
0%of full-history accuracy
0%time-aware facts
0to start

LongMemEval · 178 questions · equal token budget · statistically significant (p < 10⁻¹²) · public to rerun.

Typed facts, resolved over time, with a graph and an audit trail. One store, three surfaces, from $0.

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.

The memory

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.

Retrieval

Semantic vector search over stored memories, plus deterministic lookup of typed facts and entity relations. No model on the read path.

Where memories live

A managed cloud store (Postgres + pgvector), with EU data residency.

The integration

Agent integration

REST API, Python + Node SDK, and a CLI (it ships inside the Python package).

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

Efficient by default. Transparent by design. Yours to control.

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

Time travel

Ask what was true on any past date.

Every memory becomes a typed fact with its own validity window. When a value changes, the old one is kept, not overwritten, so you can replay your agent's knowledge as of any moment.

  • Typed facts with valid_from and valid_to
  • Changes supersede the old value, never overwrite it
  • as_of returns the truth at any past date
korely · graph
customer · dimensions over timeCustomercityBerlinMunichsince2024segmentSMBindustrySaaS
as_of2026-03-09→ city =Berlin
as_of2026-07-09today→ city =Munich

Use cases

Ten shapes of agent memory

One memory, scoped per agent. Each vertical ships with a code snippet you can copy.

All use cases →

Pricing

Flat, predictable pricing, with the graph included

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

Get started → · Full pricing →

Get started

Give your agent memory that stays true.

Create your account and mint your first key, free to start. EU-hosted, no card required.