Build1 distinct publisher3 min readUpdated
Mads Thines has shipped an open-source memory layer for coding agents that starts on local disk. The design bet is that a record of past mistakes should be inspectable and portable.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Mads Thines, a Copenhagen-based designer and product engineer, has released LoreKit, an open-source memory layer that gives AI coding agents a record of earlier mistakes, fixes and project-specific lessons [1]. The initial workflow runs entirely on the developer's machine, storing memories as readable Markdown rather than requiring an account or a hosted database [2], which makes this a question about where agent state lives rather than whether agents should have any.
Thines says the project came out of roughly two years spent building an autonomous workflow for coding agents, during which he found that agents kept rediscovering the same environmental facts and debugging fixes once a session ended [3]. His first answer was a pile of local files; LoreKit appeared when he wanted those lessons to travel between machines, teammates and CI jobs without binding the memory system to one agent host [4]. His public profile lists him as a coder and designer at the observability startup Dash0, with earlier training in graphic design before frontend and product work [5].
Installation is `npx @lorekit/cli install`, which adds three agent skills, an MCP server entry and lifecycle hooks for supported environments [6]. The homepage names Claude Code, Cursor and Codex, while the repository says any MCP-compatible client can call the same memory tools [7]. In local mode a `.lorekit.json` file selects local storage and points the MCP entry at the CLI's local server, with memories landing under `~/.lorekit/` or a repository's `.lorekit/` directory [8]. Each file is Markdown with YAML frontmatter carrying fields such as scope, key, timestamps and the number of times a lesson has been encountered [9].
The published example is a failing integration test whose Postgres container is not running; a hook suggests preserving the fix, but LoreKit does not record the session by itself, and the model has to call `memory.write` [10]. The resulting memory tells a later session to start the database before treating `ECONNREFUSED 5432` as a code defect [11]. That is a founder-produced demonstration, not an independent test [12], and it exposes the real dependency: capture is only as reliable as the agent's willingness to make the call.
What operators get in exchange is a visible audit trail. A memory can be opened, searched with `grep`, committed, edited or deleted [13]. Thines frames the entries as advisory observations, with deliberate rules still belonging in files such as `CLAUDE.md` where a human reviews and versions them, leaving LoreKit to hold lower-confidence operational knowledge that may harden into a rule, expire, or stay a warning [14].
Local mode is also the distribution wedge. It runs without authentication, network access or a new managed store [15], which lowers the cost of a trial and gives Thines a route into teams that will not send repository context to an external service [16].
The hosted tier is where the seams show. Users create an account, generate an API key and point the CLI at a remote Postgres-backed store; local files stay on disk and `list` shows both, but sharing an older local lesson with teammates or CI takes a separate migration command [17]. Organizations can bind repository scopes to a shared store with viewer, member, administrator and owner roles [18], and the free tier supports up to 5,000 memories and 120 requests per minute [19], about two per second [20]. Read-only tokens can expose team lessons to CI [21].
Watch whether the retrieval layer actually behaves identically across backends. Thines says scope precedence, ranking, de-duplication and context budgets sit above the storage choice, but that claim comes from the launch material and has not been independently tested [22].
Follow any of these and your For You feed starts watching them — no settings page required.
Ranked by verification strength, evidence, and original report placement.
Mads Thines, a Copenhagen-based designer and product engineer, has launched LoreKit, an open-source memory layer that gives AI coding agents a record of earlier mistakes, fixes and project-specific lessons.
LoreKit's initial workflow runs entirely on a developer's machine, storing memories as readable Markdown files rather than requiring an account or hosted database. Thines detailed the local setup in an August 15 blog post.
The project grew out of roughly two years Thines spent building an autonomous workflow for coding agents; he found agents repeatedly rediscovered the same environmental facts and debugging fixes after sessions ended.
Thines' first answer was a collection of local files; LoreKit emerged when he wanted those lessons to move between machines, teammates and continuous-integration jobs without tying the memory system to one agent host.
Thines' public profile describes him as a coder and designer working at observability startup Dash0, and his LinkedIn lists earlier training and work in graphic design before he moved into frontend and product engineering.
Developers install LoreKit's CLI and MCP server with 'npx @lorekit/cli install'; the installer adds three agent skills, an MCP server entry and lifecycle hooks for supported environments.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
Design detail is concrete, verification is absent
One publisher, and its substantive material traces back to the founder's launch post, repository and homepage. Install path, storage layout, frontmatter fields and permission model are specific enough to check, which lifts the floor; but the worked example is explicitly a founder demonstration, the storage-agnostic retrieval architecture is stated as not independently tested, tier limits are labelled company-supplied, and the only performance number is self-reported. No third-party test, benchmark or user account appears.
Release exists, uptake unmeasured
The supplied material establishes only that the software and a hosted tier were published, plus a self-reported load test. There are no downloads, installs, stars, named users, team deployments or CI integrations reported, and hosted-tier ceilings are product specifications rather than usage. Inferring uptake from a launch would be guesswork.
Modest overstatement, largely self-flagged
Claims here are narrow by design - accumulated project notes with lexical retrieval, advisory rather than authoritative, manual writes - and the article itself marks the demo as founder-produced, the architecture as untested and the load test as self-reported. What remains unsupported is functional consistency across local and hosted storage plus the implied practical value of the memory layer, neither of which has independent testing or adoption behind it, so claims run slightly ahead of evidence rather than far ahead.
Founder-sourced launch with an open-core upsell
Nearly all factual content originates with the person selling the product: launch post, repository, homepage and Reddit thread. The article's own framing identifies the commercial mechanism - a free local mode as distribution wedge into teams that will not export repository context, with a hosted Postgres store, org roles and CI tokens as the paid destination and a capped free tier. Mitigating factors are the article's repeated attribution labels and its comparison to rival memory systems.
Facts about the product are solid; consequences are not
High confidence that LoreKit exists, is open source, installs as described and offers the stated local and hosted modes, because those specifics are checkable and consistently attributed. Low confidence in anything downstream: whether the memory layer improves agent behaviour, how lexical retrieval holds up against embedding-based rivals, and whether anyone beyond the founder is using it. Single-publisher coverage and vendor-sourced specifications cap the ceiling.
build
Waku 0.1.0 bets the product is the control plane, not another coding agent1 distinct publisher
build
255 tool schemas, 91K tokens: pricing the two MCP costs nobody budgets1 distinct publisher
product
Binance gives agents a trading seat, and gives users the permission slip1 distinct publisher
build
NVIDIA put a number on agent skills: 300+ verified, two harnesses, baselines under 50/1001 distinct publisher
Distinct publishers with included, body-backed reporting in this cluster.
1 article · August 16, 2026