Skip to content
memseek
context engine

RAG finds information.
Memory remembers information.
A context engine decides what the agent should know now.

Not the most similar passage. Not the whole history. The few things that are still true, with the evidence attached.

Run it locally → View on GitHub
the category

A context engine continuously turns changing evidence into the compact, trustworthy context an agent needs for its current task.

memseek, specifically

Memseek turns changing evidence into current, cited knowledge and assembles it for agents on demand — from rules you declare in versioned YAML, over data that stays in your Postgres.

data + events
  • CRM & business apps
  • documents
  • conversations & calls
  • tool results
  • agent traces & outcomes
memseek
context engine
  • retrieve
  • derive
  • supersede
  • reconcile
  • cite
  • assemble
current context
  • what is true now
  • + what it superseded
  • + provenance
  • + a token budget
→ any agent
how it works

Observe → Maintain → Assemble → Serve.

Four stages, described once in a folder of YAML.

  1. 01 · observe Capture evidence

    Append what happened: events, documents, conversations, tool results, agent outcomes.

  2. 02 · maintain Turn evidence into state

    Keep current facts, what they superseded, and the provenance behind both.

  3. 03 · assemble Build context for one task

    Rank what is relevant, then cut it to a declared token budget.

  4. 04 · serve Hand it to the agent

    Over the SDK, the HTTP API, or a short list of MCP tools you declared.

The stage that separates a context engine from a memory store is maintain. A store keeps what you wrote; an engine keeps deciding what it means as new evidence lands — which is why a fact can stop being true here without anyone deleting anything. Why current beats similar →

the output

What the agent actually receives.

A context artifact — a compact package assembled for one task, with a receipt attached.

  • current statethe beliefs that hold right now
  • evidencethe records that earned their place, cited
  • token countmeasured against the budget you declared
  • manifestexactly what went in, and a hash of the bytes
artifacts/profile_brief.yaml the whole assembly step 
  - name: crm_profile_brief
    blocks:
      profile:                    # what holds now
        document: {entity: "{{entity}}"}
        max_tokens: 2000
      evidence:                   # what supports it
        view: crm_history@1
        max_tokens: 3000

The budget is a field. The sources are named. The rendered output carries input_record_ids and rendered_sha256 back with it, so the context an agent received six weeks ago is something you can reconstruct.

Memory is one capability inside this.

Long-term agent memory, hybrid retrieval, derived state and prompt-time assembly in one declarative layer. Episodic and semantic memory, reflection and consolidation are all mechanisms it runs — and docker compose up gets you a working one to query.

Run it locally → Open agent-memory showcase Other showcases The whole product