Use case · Finance / wealth advisory

An advisor co-pilot that answers from who the client is now

Risk tolerance, liquidity needs, portfolio drift. Written down per client, read back before any advice, and weighted toward the recent change rather than the intake form from two years ago.

The shape of the problem

Want to build an advisor co-pilot that actually remembers each client? Here is how I would do it

Think about the good private banker your parents had for twenty years. You walk in and you do not have to re-explain that you hate surprises, that you sold the rental property last spring, that your daughter starts university in two years so that money has to stay liquid. He just knows. He picks up where you left off.

Now think about every robo-advisor and chatbot you have ever used. Each conversation starts from zero. You tell it your risk tolerance, it gives you advice, you close the tab, and next month it greets you like a stranger and quotes the risk profile you filled in two years ago when you were single and renting.

The whole job of a wealth advisor is continuity, and a stateless chatbot is the one thing that cannot do continuity.

Korely is the part that makes your agent behave like the banker who remembers, not the chatbot who forgot.

How you build it

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

  1. 1

    Pick your stack and build the agent itself

    Claude Code, Cursor, an LLM with function calling, whatever you already use. Wire it to your market data feed and your portfolio system so it can read positions, prices, and allocations. This part you already know how to do.

  2. 2

    Define the client as the unit of memory

    Every client gets their own scope (one agent_id or end_user_id per client), so Maria risk tolerance never bleeds into Paolo. When the agent talks to a client it reads and writes only that client slice.

  3. 3

    Capture facts as they come up in conversation and in the data

    Risk tolerance, target allocation, liquidity needs, time horizon, the fact that they will not touch tobacco or defence stocks, the fact they panic-sold in March. Each of these is a small fact the agent should write down the moment it learns it, not a transcript it has to re-read every time.

  4. 4

    Make the agent answer from what is true now

    Before it gives any advice it pulls the client current facts and their actual current positions, notices the portfolio has drifted from the target, and frames the answer around today, not around the intake form from two years ago.

  5. 5

    Handle the changes, because in finance everything changes

    The client raises their risk tolerance, a new regulation lands, they tell you they are retiring early. The old fact has to step aside cleanly and the new one has to win, while you keep the history for the audit trail. This contradiction handling is where most home-built memory quietly breaks.

  6. 6

    Wire in the audit and compliance view

    Because the memory is time-aware you can answer not just what the client wants now but what they wanted on any past date and why the advice changed. Auditors love this. Stateless chatbots cannot produce it.

  7. 7

    The part where you stop building

    Steps 3 to 6 are a bi-temporal graph-RAG memory layer: typed facts, a contradiction resolver that keeps the timeline straight, recency weighting, an entity graph that connects a client to their goals and holdings, and fast hybrid retrieval. That is months of infrastructure and a database you would have to babysit forever. With Korely you call korely.add() and korely.search() and that whole layer is already built, hosted in the EU, and answering reads in under 50ms, starting at 19 euro a month. You build the advisor. We are the memory.

The shape of the fix

The agent writes each client fact down, then answers from what is true now

March update

The client tells you they are de-risking

  • "Cut equity, hold more cash, a big expense is coming"
  • The agent records the new risk tolerance once

Korely memory

A bi-temporal typed fact is stored

  • New fact supersedes the two-year-old intake form
  • Recency weighting tilts toward the recent change
  • EU-hosted, no LLM on the read path

Today

A later session reads the current picture

  • Hybrid retrieval returns conservative, needs liquidity
  • The agent advises from now in under 50ms

The agent never re-reads the whole history. It asks the memory and gets back what is true now, and when the client changes course the old fact is superseded with its date rather than deleted, so the audit trail stays intact.

How Korely fits

The memory layer that sits between your advisor agent and a real client relationship

Building it yourself means typed facts (not just dumped chat logs), a two-stage contradiction resolver that knows the new risk tolerance supersedes the old one without losing the history, recency weighting so today portfolio outweighs the macro view from two years ago, an entity graph that ties each client to their goals and holdings, and hybrid retrieval (full text plus pgvector plus RRF plus reranker, Postgres only) that actually surfaces the right fact at the right moment. That is the hard, unglamorous part, and it is months of work plus a database you have to run forever.

In wealth advisory it matters more than almost anywhere else, because the whole product is continuity and the cost of answering from a stale fact is real money and a compliance problem. On a reproducible benchmark, an agent reading from Korely selected memory answered 76 percent of long-horizon questions correctly versus 42 percent from a same-size recency window. That gap, 34 points, is roughly the difference between an advisor who remembers and one who guesses.

Reads come back in under 50ms with no LLM on the read path, the store is hosted in the EU which a finance team genuinely cares about, and it starts at 19 euro a month with a free tier. Everyone already has Claude Code or Cursor to build the agent. Nobody wants to hand-build the memory.

Show me the code

A minimal write-then-read flow

finance_agent.py python 
# ── March: the client tells the advisor they are de-risking ─────
from korely_memory import Korely

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

# The agent records the new fact the moment it is stated
korely.add(
    "Risk tolerance lowered to conservative. Big expense "
    "coming, wants more cash and less equity for now.",
    agent_id="client-maria-rossi",
)

# ── Today: the client asks what to do with new cash ───────────
context = korely.search(
    "current risk tolerance and liquidity needs",
    agent_id="client-maria-rossi",
)
# context → "Conservative as of March. Needs liquidity. Hold cash."

# The agent frames advice around the March reality, not the
# aggressive-growth intake form filled in two years ago.

The same memory is reachable from any agent, Claude Code, Continue, n8n, LangGraph, or a plain HTTP client. Scope memories with one agent_id per client so one subscription covers your whole book without bleeding one client into another.

When the client changes course

The agent answers from the March reality, not the two-year-old form

A client tells your agent in March that they are getting more conservative, they want to cut equity exposure and hold more cash because a big expense is coming. Two years ago, at intake, they filled in a form that said aggressive growth, long horizon, high risk tolerance. A stateless agent reads the intake form, sees aggressive growth, and cheerfully suggests piling into a volatile small-cap fund. That is not just unhelpful, in a regulated context it is the wrong advice on file.

With Korely time-aware memory the new fact (risk tolerance lowered, March) supersedes the old one, recency weighting puts today ahead of the two-year-old intake, and when the client asks what should I do with the new cash, the agent answers from what is true now: hold it liquid, do not chase the small-cap, your situation changed. The old fact is not deleted, it is kept as superseded with its date, so when an auditor later asks why the recommendation changed in March the agent can show the exact timeline.

That single moment, answering from the March reality instead of the two-year-old form, is the whole reason a finance team needs real memory and not a longer prompt.

timeline.py python 
korely.add(
    "Risk tolerance: aggressive growth, long horizon.",
    agent_id="client-maria-rossi",
    metadata={"effective_from": "2024-02-01"},
)

# Two years later, the client de-risks before a big expense
korely.add(
    "Risk tolerance now conservative, needs liquidity.",
    agent_id="client-maria-rossi",
    metadata={"effective_from": "2026-03-15"},
)

korely.search("risk tolerance", agent_id="client-maria-rossi")
# → "Conservative" (current). Aggressive fact marked superseded.

# Retrieve full history for the compliance trail:
# GET /v1/memories/{id}/history  -> full timeline with effective_from

Frequently asked

Advisor co-pilot memory, common questions

How is this different from just storing each client profile in my own database? +

A profile table holds one current value per field, so when a client risk tolerance changes you either overwrite the old value and lose the history, or you bolt on a versioning scheme and a way to ask what was true on a given date. Korely is that versioning, done right and time-aware out of the box. Every fact carries when it became true and when it stopped being true, the new value supersedes the old one automatically, and you can still pull the full timeline for an audit. You also get hybrid search and an entity graph on top, so the agent finds the relevant fact instead of you writing the query.

Why does answering from what is true now matter so much in wealth advisory? +

Because advice is only correct relative to a moment in time. The right answer for a client who said aggressive growth two years ago is the wrong answer for the same client who said this March that they are de-risking before a big expense. A stateless agent reads whatever fact it happens to surface, often the oldest one because it was repeated most. Korely weights recent facts over stale ones and marks superseded facts as superseded, so the agent frames advice around the client situation today, not the intake form from two years ago. On a reproducible long-horizon benchmark that is the difference between 76 percent and 42 percent correct.

Is this safe for regulated finance and EU clients? +

The memory store is managed and hosted in the EU on Postgres, so client data stays in the EU and you are not standing up your own vector database to maintain. Nothing is deleted silently: when a fact changes, the old version is kept as superseded with its dates, which gives you the audit trail a compliance review asks for. You can export or erase a client full memory with one call, which is exactly what you need for a data subject request. Korely is a memory layer, not a financial advice engine, your agent and your compliance process stay in charge of the actual recommendations.

Does it work with the agent I am already building in Claude Code or Cursor? +

Yes. Korely is plain memory behind a REST API and a Python and Node SDK, so any agent in Claude Code, Cursor, Continue, LangGraph, n8n, or a raw HTTP client can use it. You install the SDK once, get an API key, and the agent calls korely.add() to write a client fact and korely.search() to read the client current picture before it answers. You build the advisor logic the way you already know how, Korely is only the remembering part.

How fast are reads, and is there an LLM in the loop on every call? +

Reads come back in under 50ms because there is no LLM on the read path. Retrieval is hybrid full-text plus vector with reranking and graph traversal, all deterministic, so a client-facing agent does not stall waiting on a model just to recall a fact. The model work happens in your agent when it reasons over what the memory returns, not inside the lookup.

What does it cost to start? +

There is a free Hobby tier to build and test against, and paid plans start at 19 euro a month when you need more memories and more agents. You scope memory per client, so one subscription covers your whole book of clients rather than charging per profile. The point is that you skip months of building and running a bi-temporal graph-RAG memory yourself, which costs far more than the subscription in engineering time alone.

Give your advisor agent a memory that answers from now

The free tier is enough to wire your advisor agent to a real client memory this afternoon, and paid plans start at 19 euro a month when you outgrow it. Sign up, grab an API key, and pick the tier that fits your book.

See pricing and start free

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