
Yurumi: the suite that died far from the guilty test
Seven tests failed and pytest aborted the whole run with a WindowsPath error. The cause was a monkeypatch on os.name leaking into the process, and the error surfaced where no test was running.
25 posts

Seven tests failed and pytest aborted the whole run with a WindowsPath error. The cause was a monkeypatch on os.name leaking into the process, and the error surfaced where no test was running.

The backup health check counted snapshots and reported green. The mirror had more snapshots than the primary and its newest one was two days old: counting proved existence, not freshness. Six fixes in six days to separate the two.

With the decision server down, triage finished in 300 ms. With it up and the host saturated, it took eight seconds to return a neutral answer. A degraded dependency was more expensive than a missing one, and the code treated both as the same case.

Four fixes in four days around the same SQLite file: descriptors nobody closed, a schema that demanded a write lock on every boot, and two mute exception handlers. The database was never corrupted — it was held hostage by connections the code forgot to close.

The question endpoint took 56 seconds and still answered NOT FOUND, while the deterministic path answered in 3 seconds with the right source. Four independent causes, each measured before being cut.

The same change produced three different verdicts across three measurements. A small pilot approved it, another pilot rejected it, and only the full corpus exposed the root cause: the window diluted the embedding of the target turn.

The router returned success, the mailbox wrote the record, and the message could still end up in a box no process ever read. Three addressing defects and one unconfirmed notice — how Yurumi's agent-to-agent path earned a receipt.

The key loader documented that the process environment beats .env files. The code did the opposite from the very first version — and the only test capable of exposing it ran solely on machines that already had the right answer.

A cron synchroniser kept reporting success every fifteen minutes while indexing only half the jobs, writing in simulation mode, and hiding the real cause of its own failure. Three silent defects, and one number that exposed all of them.

Yurumi's skill search hit concrete queries and missed vague ones, because the index read a Windows-only directory, had no dedup and returned the file path where the description should be. The index went from 197 to 733 skills.

The indexer was writing 4,541 notes to C:/mnt/d while the real vault sat frozen — the old guard only checked whether the functions were still in the file, never the result on disk. Two symptoms, one cure: measure the destination.

The Yurumi cron that runs every 5 minutes was improved: now it detects duplicates, clusters them, and has a pill ratchet to prevent regressions. See how the loop evolved from a simple consumer to a true memory agent.

Four memory layers with different lifetimes, a TTL that never actually expired, and the decision that fixed it: sleeping is not deleting. How the memory lifecycle stopped being a loose field in the payload.

Capivara's chat started answering without sources: HTTP 200, a polished sentence, zero memory. Restarting the embedding service looked like the obvious fix — and was precisely what kept it from coming back. Underneath, two defects from the same family: a process that only opens its port after waking up, and a fallback that doesn't know how to undo itself.

The embedder was not broken, it was loading. A one-way latch turned a cold load of minutes into a system that stayed broken until the next restart.

Before swapping Arachne's search engine for Yurumi, I had to prove the new one was at least as good as the old. Shadow dual-write, real traffic, overlap@10 — and the number nobody expects: 0.511.

After the bilingual jump to 0.1614 recall@1, there was a number left on the bench: how much was the cross-encoder contributing on every search? The week I measured that latency and recall are a bill you pay on every query — and the answer ended up written as a permanent flag in the config.

Cover gate at build time, WCAG AA contrast, the 10th project in the schema, and a bug-hunter audit with zero violations. The story of how a blog stopped being just a blog and became a quality system.

Yurumi started as a local replacement for mem0 — storing conversation memories. In two weeks it gained intent, actions, learning, its own identity and a knowledge graph. The journey from a simple store to a complete agentic system.

Three embedding models, two search systems, one homegrown benchmark: the study that started with a question about semantic similarity and ended up revealing the tradeoffs between colibri, bge and openai — and how each one found its place in the ecosystem.

Capivara kept its memories in a local ChromaDB, with its own embedder and L1-L4 layers. Yurumi kept the ecosystem's memory in a Qdrant. Two separate memories meant a brain that never talked to the rest of the body. The unification on 08/28 migrated 182/182 memories without losing a single one: hash dedup, backup before deleting, and an --apply gate that separates the plan from the execution.

Every project's AGENTS.md was the official instruction set of the ecosystem, but it lived outside the Yurumi's memory — the ingest only ran when someone remembered to run it. The fix was a signature watcher (mtime+size) that re-ingests only what changed. Along the way: a first_run that ran a full ingest every day, an os.stat that hung when WSL wedged, and the lesson of never trusting a junction.

Yurumi stored its memory with a single embedding model trained in Portuguese. It worked — until the first question in English. The fix was not swapping the model; it was running two of them side by side and fusing the rankings with RRF. After a full LoCoMo run, recall went from 0.139 to 0.1614.

The simple question 'what does my agent actually remember?' turned into a full audit of Yurumi: 32 knowledge bases, 551 documents, a Qdrant collection with over 8 thousand vectors, and a LoCoMo baseline that handed back reality in percentage form.

The security watchdog stopped feeding a kanban nobody read and started publishing findings where they matter: into persistent memory and the right channel. Less ceremony, more active hunting, zero cards.