Inspiration
Every time you start a new conversation with an LLM, it forgets you. It forgets what you care about, what you've already explained, what words mean in your context. We wanted to know: what if memory wasn't bolted on after the fact as a chat log, but built as real hardware — a virtual substrate the model genuinely lives on? Kioku is the answer to that question.
What it does
Kioku gives Qwen a living memory. It doesn't store messages — it understands every exchange, decomposing it into meaning, intent, keywords, preferences, and self-researched definitions, then committing the result into a Cadran virtual-hardware substrate where retrieval is a direct address jump. The demo arena shows two chat panes side by side: Qwen + Kioku (memory on) and Qwen raw (memory off). Same model, same key — only the memory differs, so the comparison is the pitch. A memory inspector shows a memory forming live through its pipeline stages (captured → decomposed → embedded → curious → committed), lets you browse engrams, charts retention and forgetting curves, and reads the Cadran substrate gauge. A researcher tab runs full multi-step web research sessions grounded in Kioku memory.
How we built it
The memory pipeline runs fully on Qwen Cloud — qwen-max for decomposition, curiosity definitions, consolidation, and answers; text-embedding-v3 for the vector embeddings that drive semantic recall. The substrate is a pure-Python sparse-file implementation of Cadran virtual hardware (a simulated 1 TiB address space with physical block allocation). The backend is FastAPI with SSE for live pipeline streaming. The frontend is a dependency-free SPA. Deployed on Alibaba Cloud ECS Singapore, systemd + nginx.
Challenges we ran into
The biggest challenge was getting Qwen3 models to behave predictably — they default to slow chain-of-thought reasoning that can return an empty content field. We had to detect Qwen3 models and disable thinking mode explicitly, with a reasoning_content fallback. DashScope's hard max_tokens cap of 8192 also caught us (default was 16384), breaking structured JSON calls silently. Getting per-request key pass-through right across all routes — so the user enters their key once and it flows everywhere — required careful plumbing through SSE streams.
Accomplishments that we're proud of
The Cadran virtual-hardware memory model — treating memory as addressable space rather than a key-value store — is genuinely novel. The live pipeline inspector showing a memory forming in real time (you watch it become an engram) makes the invisible visible. The side-by-side comparison of Qwen+Kioku vs Qwen raw is the cleanest possible proof of memory working.
What we learned
Memory is not a log. The moment you start treating recall as a semantic address jump rather than a search, everything changes — latency drops, relevance improves, and the model can actually surprise you with what it remembers. We also learned that Qwen's embedding model (text-embedding-v3) is strong enough that the whole memory system works without any fine-tuning.
What's next for Kioku
Shipping the Rust kiokud daemon (the real Cadran hardware implementation — the Python substrate is a compatibility shim for the demo). Persistent cross-session memory tied to a user identity. A forgetting curve tuned to individual users. Making the substrate available as a library any Qwen app can import.
Log in or sign up for Devpost to join the conversation.