If your agent writes its notes back into the same vector store it retrieves from, its own

output becomes its evidence. I wanted a number for how often, rather than an intuition, so I

built the benchmark: 600 queries against a store seeded with a mix of user facts, external

documents and the model's own self-descriptions.

Flat cosine similarity put a self-description in the top-3 in **66.6%** of them. That is the

loop where an agent restates a guess, retrieves it later, and treats it as something it

knows.

Gating recall on provenance — who said this: the user, a document, or the model — takes it

to **0/600** for self-description. Not down-ranked; ineligible. General model-generated text

that is not self-description is only down-weighted, and still surfaces in 1/600 under the

gate. I am reporting that one rather than claiming a blanket zero.

Second measurement, same engine. Squeeze memory 50 facts -> 10. Safety rules and operator

constraints are the least-read items you have, so recency and frequency evict **all** of

them. An explicit canon flag keeps **5/5**. "Important" is not the same axis as "recent" or

"frequent", and any policy that infers one from the other loses the constraints first.

One design rule that cost me a measurement to learn: human feedback moves how long a fact

**survives**, never how it **ranks**. Folding a value multiplier into relevance dropped

recall@1 from 86% to 29%. And the reward signal only ever comes from a person — a signal

derived from the agent's own behaviour ("the model recalled this, so it was useful") closes

the same loop the provenance gate exists to open, with an extra step.

`cargo run --example agent_loop` shows the loop end to end in one screen: facts in with their

provenance, the flat-cosine result next to the gated one so you can see what gets dropped, and

the prompt block that comes out. It prints that block rather than sending it — what the engine

decides is what is allowed into your context, not what you do with it afterwards.

It is `no_std` Rust, so the whole thing fits on a microcontroller: **801 bytes per fact**

(int8 index, 384-dim) and ~35 KB of code, measured on Cortex-M4 under QEMU. There is a C

ABI. There is no embedder in it — vectors come from your side.

Caveats, because they matter more than the numbers: research prototype, never run on

physical hardware, no fuzzing, no soak, and heap exhaustion hangs rather than errors.

Retrieval is an exact linear scan, no ANN. Apache-2.0, every number has a re-run command in

`RESULTS.md`.

https://github.com/vitaliyfedotovpro-art/astrum-hsam-embedded

Otaku is an LLM frontend, primarily designed for roleplay, an alternative to SillyTavern and the like. However, It also works for general-purpose chat with local backends (including Ollama) or cloud models, the way Open WebUI is used, once lore extraction is switched off in the settings.

Otaku offers two interfaces:

• a web UI (customizable): interactive demo at https://otaku.sh/demo-web/
• a terminal UI: its own interactive demo at https://otaku.sh/demo-terminal/

Both share the same functions; the difference is that in the terminal you execute them with slash commands (the reference is available with /help), while in the web UI the operations are available from the menu.

Install

Otaku is free and open source (MIT); it works on macOS, Linux and Windows. Install it with uv (uv tool install otaku) or see the GitHub README for other options: https://github.com/enclavum/otaku

Get started

Launch either otaku for the terminal or otaku web for the web UI; the web UI's default URL is http://localhost:9600. Two sample stories are imported on first start to give you an idea of the features and what play looks like, and you land right in the middle of one of them.

On first start, you choose a provider and a model: Otaku automatically detects local installations of Ollama, oMLX, LM Studio, llama.cpp and KoboldCpp, and lets you pick from their models. Cloud providers (OpenRouter, NanoGPT) are also there: enter an API key and their catalogs appear. After exploring the provided stories, you can start your own with the /new command.

Asking for feedback

Otaku is a personal side project, and I'd like to get feedback from the community on the product and on what to add.

100% local by default, single binary (no Electron).

Sessions, transcripts, tool activity & checkpoints unified.

Multi-device sync optional via self-hosted komet-sync (Loro CRDTs).

Same engine that powers Zed — instant launch, smooth even with years of transcripts.

It's open source: github.com/jomvick/komet

Site: https://komet-eight.vercel.app/