Use case · Coding agent

Stop teaching your AI the same conventions every Monday

Code conventions, refactor history, architectural decisions. Saved once by the agent. Read back on the next session. Across Cursor, Claude Code, Codex, OpenCode, and any framework that can call a REST API.

The shape of the problem

Want to build a coding agent that stops re-learning your project every Monday? Here is how

Think about a new contractor who joins your team every single morning. Brilliant coder, types fast, but he has zero memory of yesterday. Every day you sit him down and explain again that you use const not let, that the auth lives in this folder, that you already ripped out Prettier for Biome last month. He nods, does great work for a few hours, then goes home and forgets all of it.

That is your coding agent today. What you actually want is a senior teammate who remembers the project, who knows the decisions you made and why, and who never re-opens a settled argument. The only thing standing between those two people is memory.

Korely is that memory.

How you build it

You already have the smart part. You are missing the memory part

  1. 1

    Pick your editor

    Claude Code, Cursor, Codex, OpenCode, whatever you already use. You do not need a new tool to build the agent. You already have the smartest part.

  2. 2

    Decide what is worth remembering

    Naming conventions, folder layout, the reason behind a refactor, the libraries you banned, the patterns you settled on in code review. These are the things the agent keeps re-discovering and getting wrong.

  3. 3

    Let the agent write a memory when it learns one

    When a reviewer says we always use const, the agent calls korely.add() with that fact, scoped to an agent_id for that repo or team.

  4. 4

    Read memory back at the start of every session

    Before it writes the next line the agent calls korely.search() and gets the relevant conventions and decisions, then prepends them to its own prompt.

  5. 5

    Scope memory per repo or per team

    Use the agent_id so two projects never bleed into each other, and so the same memory is shared across Cursor, Claude Code, and any other tool you plug in.

  6. 6

    The part nobody actually wants to build

    The memory layer itself. A bi-temporal store that knows what is true now versus what was true before, contradiction handling so a changed decision overwrites the old one cleanly, an entity graph so related decisions connect, and hybrid retrieval that returns the right fact in under 50ms with no model call. That is months of infrastructure work, and it is exactly the part Korely already built. You point your agent at the REST API or SDK and skip all of it, starting at 19 euro a month.

The shape of the fix

The agent writes down what it learns, reads it back next time

Session 1, Monday

A decision happens in the editor

  • Reviewer: "we use const here, not let"
  • The agent records it once

Korely memory

A bi-temporal typed fact is stored

  • Knows what is true now versus before
  • Contradiction check + entity graph
  • EU-hosted, no LLM on the read path

Session 2, days later

A fresh session reads it back

  • Hybrid retrieval returns only what is true now
  • Agent suggests const, not let, in under 50ms

The memory lives outside the chat. A fresh session with no history still opens already knowing the convention, and when a decision changes the old fact is superseded rather than deleted.

How Korely fits

The memory layer you would otherwise build before the agent is useful

Korely is a bi-temporal, graph-backed, hybrid-retrieval memory store: typed facts that know what is true now versus what was true before, two-stage contradiction handling so a reversed decision cleanly supersedes the old one instead of both lingering, an entity graph that connects related decisions, and hybrid retrieval (FTS plus pgvector plus RRF plus reranker, Postgres only) that returns the right context fast.

The numbers matter here specifically. At an equal token budget a reader answers 76 percent of recall questions correctly from Korely selected memory versus 42 percent from a same-size recent-history window, a 34 point jump, reproducible and significance-tested. Reads come back in under 50ms with no LLM on the read path, so adding memory does not add latency to the agent loop.

For a developer this means you spend your time on the agent behavior, not on building and operating a memory database, and you do not pay a model tax on every recall. Everything is EU-hosted and local-first. The whole thing starts at 19 euro a month with a free tier to try it.

Show me the code

A minimal two-session flow

coding_agent.py python 
# ── Monday: a reviewer settles a convention ─────────────────────
from korely_memory import Korely

korely = Korely(api_key="kor_live_...")

# The agent records the rule the moment it is stated on the PR
korely.add(
    "Team convention: use `const` for all variable declarations "
    "in TypeScript. `let` is only allowed inside short-lived "
    "loop counters.",
    agent_id="team-acme-typescript",
)

# ── Friday: a fresh session, the agent recalls the rule ────────
context = korely.search(
    "variable declaration convention",
    agent_id="team-acme-typescript",
)
# context → "Use const. let only inside short-lived loop counters."

# The agent prepends this to its system prompt before generating
# the next line. No more drift between sessions.

The same memory is reachable from any agent, Claude Code, Continue, n8n, LangGraph, or a plain HTTP client. Scope memories with different agent_id values to keep each tool knowledge separate and auditable.

When conventions change

The agent answers from what is true now, but keeps the timeline

Three months ago your team ripped out Prettier and switched the whole repo to Biome. You told the agent once, in one session, on the PR where you made the change. Today a new feature branch opens and the agent reaches for the formatter. Without time-aware memory it would happily do one of two wrong things: pull the old Prettier fact because it is still sitting in the history, or get confused because both facts exist and pick at random.

With Korely the agent asks what is true now. The Prettier fact is marked superseded as of the switch date, the Biome fact is current, so it formats with Biome without you saying a word. And if six months later someone asks why the formatter changed, the old fact is still on the timeline, marked superseded with its effective date, so you have the audit trail instead of a deleted memory.

The agent answers from what is true today, but it never loses the history of how you got here.

timeline.py python 
korely.add(
    "We format with Prettier defaults.",
    agent_id="team-acme-typescript",
    metadata={"effective_from": "2025-09-01"},
)

# Three months later, the team switches
korely.add(
    "We format with Biome now, Prettier is removed.",
    agent_id="team-acme-typescript",
    metadata={"effective_from": "2026-03-15"},
)

korely.search("formatter", agent_id="team-acme-typescript")
# → "Biome" (current). Prettier memory marked superseded in the graph.

# Retrieve full history via the REST API:
# GET /v1/memories/{id}/history  -> full timeline with effective_from

Frequently asked

Coding agent memory, common questions

Why does my coding agent keep re-discovering the same conventions every session? +

Because the chat session is the only memory it has, and the session ends. Every const-not-let rule, every folder convention, every reason behind a refactor resets to zero when the window closes. Monday is always session one. You do not have a convention problem, you have a memory problem, and the fix is a store the agent writes to and reads back from across sessions.

How is this different from .cursorrules, AGENTS.md, or a CLAUDE.md file? +

Those files are static and global, and they sit at the top of the context window where they get buried under fifty file imports and forty messages of you negotiating with the model. By the time the agent writes the next line, the rule is technically still in the tokens but functionally gone. Korely is dynamic instead of static: the agent decides what is worth remembering and writes it, then searches for the relevant fact right before it acts. And it is time-aware, so when a decision changes the new one supersedes the old cleanly rather than both rules contradicting each other.

Does this work with Claude Code, Cursor, Codex, and OpenCode at the same time? +

Yes. Any agent that can call a REST endpoint or import an SDK can read and write the same memory. You install korely-memory once, give the agent an API key, and call korely.add() and korely.search(). Scope each repo or team with an agent_id so projects stay separate. The convention you taught Cursor on Monday is there when Claude Code opens the repo on Friday, because the memory lives outside any single tool.

Does adding memory slow my agent down? +

No, and that is deliberate. Reads come back in under 50ms with no language model on the read path, so a search is a fast database call, not another inference round-trip. The retrieval is hybrid, full-text plus vector plus a reranker over Postgres, which is why it returns the right fact instead of a pile of loosely related ones. At an equal token budget a reader answers 76 percent of recall questions correctly from Korely selected memory versus 42 percent from a same-size window of recent history.

Where does my code knowledge actually live, and can I get it out? +

In a managed store in the EU, Postgres with a vector and graph index, nothing for you to host or operate. Your agent reads and writes over the REST API or the Python and Node SDKs. You can export everything or erase everything with one call, and because facts are time-aware you can also pull the full history of how a decision evolved instead of only the latest state.

What does it cost to start, and is there a free way to try it? +

There is a free Hobby tier so you can wire it into your editor and run real memory writes before paying anything. Developer plans start at 19 euro a month and Team at 79 euro, raising the limits. The whole point is that you skip building a bi-temporal graph-RAG memory layer yourself, which is months of infrastructure work, and rent the finished one instead.

Plug Korely into your editor, stop teaching the same lesson

The free tier lets you wire memory into your editor today, and paid plans start at 19 euro a month. Sign up, grab an API key, and run the first memory write in minutes.

See pricing and start free

Looking for a different shape? See the other nine use cases →