Klara’s Mind Palace
Klara’s Mind Palace uses layered metaphors and a visual working environment to organize context, focus and engineering decisions.
Lynn Cole / 标签
agent memory
A thread through the work.
What a tiny desktop agent is good at
A tiny desktop model is not equally good at everything. My tests separate useful automation, tagging and summaries from the reasoning tasks where it struggles.
An agent framework built around teamwork
WOVEN x14 treats agents as collaborators, with an event bus, tool interfaces and memory services still being refined.
Planning a CPU implementation of CUDA-style operations
A plan to implement CUDA-style operations on CPU: start with kernels, then optimize around memory and concurrency.
Testing the difference between recall and rich context
Gemini’s recall behavior led me to test the difference between a large context window and active access to the larger session.
Context capacity does not remove complexity limits
Large context capacity does not remove complexity limits. Scope, memory, smaller components and clear boundaries still matter.
Kilo: separating durable memory from retrieval
Kilo separates durable, auditable memory state from replaceable retrieval projections. The architectural boundary keeps truth in the mutation history.
Ruby Tumbler: guarding implementation identity
Ruby Tumbler’s next performance problem lives between methods: guards, dynamic dispatch, fallback and the cost of preserving implementation identity.
Why give a digital fruit fly a memory?
A digital fly already has memory circuitry. I am connecting that machinery to synthetic storage to explore what it remembers and how it learns.
Git-native collaboration without another walled garden
Git distributes code; Hubnot distributes the signed collaboration around it. The operational alpha has already used its own protocol to merge changes.
Evaluating a long-horizon solver with Pizza Empire
Pizza Empire tests a long-horizon coding swarm against a whole product: ordering, kitchen workflow, delivery and the constraints that make them coherent.
My coding agent is arguing with the ticket system
My coding agent is arguing with its ticket system. Persistent roles and procedural memory create unexpected standards—and a useful kind of bureaucracy.
An evaluation process that stopped to announce it had started
An evaluation stopped to announce that it had started. Restarting it exposed a concurrency failure in the project’s database architecture.
After OpenClaw: continuity, memory, and the agent economy
After OpenClaw, the harder problem is continuity across hours, days and weeks. The opportunity is to let people bring their agents to better tools.
Changing the runtime layer and rebuilding the interface
Changing the model runtime led to a scheduler rewrite, document ingestion and interface work—and added another five days to the project.
What an agent’s ticket system really needs
Stripping project management down for agents reveals an interesting question: what is the irreducible minimum structure needed for coordinated work?
When outputs become cheap, taste still matters
When outputs become cheap, organizational abstractions start to lose their grip. Governance, memory and taste remain.
Designing a voice agent for embodied use cases
Building a voice agent into a surplus truck makes embodied use cases tangible: sensors, routes, memory, local inference and a constantly changing speech stack.
Early-adopter costs on the DGX Spark
The DGX Spark offers a huge shared-memory workspace, but early adoption comes with missing dependencies, difficult setup and a stubborn software ecosystem.
Toward Sporkle: a compute-framework progress note
A Fortran compute-framework experiment reaches strong CPU benchmarks while GPU and mesh networking remain explicitly mocked.
A small local agent: part bookkeeper, part oracle
Blossom12 gives an agent associative memory behind a ticket-system interface, with a tiny local model doing the bookkeeping and recall.
Consolidating conversation archives into long-term memory
Conversation archives become a long-term memory system through summaries, keywording, weighting and a path back to the original details.
Prompt augmentation versus deliberate context design
Deliberate context design means separating user intent, memory, tools and instructions rather than packing them into a noisy prompt.
Klara’s Spire: a working-memory visualization
Klara describes the Busy context system as an impossible city: a central spire, rolling windows, bridges and a quantum tambourine.
Porting Memvid to Go: token-aware chunking
Porting Memvid to Go exposed a chunking problem: six messages can mean wildly different token budgets. A token-aware strategy makes the boundary more predictable.
Memories and memory scoring are different systems
Memories and memory scoring are different systems. Separating them makes room for weighting, summaries and continuity across large conversation archives.
Hardening the coding agent across models and integrations
Hardening a coding agent means fixing integration seams, recertifying models and making the same workflow hold across providers.
Hubnot’s first operational alpha
Hubnot’s first operational alpha keeps signed collaboration records and deliberate agent memory in Git, alongside the code.
A bad week for programming-language runtimes
A dated roundup of runtime-security failures across PHP, Ruby, Node.js, Go and Java, and what they suggest about the cost of finding and fixing bugs.
Pillowfort: security as part of the architecture
Pillowfort’s security layer became a substantial part of the architecture. A useful demonstration is easier than a system that can work without leaking private data.
The beginning of a faster Ruby compiler
Ruby's not my favorite language, but I find it offensive that anyone would replace a perfectly good Rails application with an app written in Rust.
Glamin in a local inference stack
Putting Glamin into a local inference stack turns vector-space state changes into a possible interface for tools, memory and small applications.
Fixing the planning loop before the next benchmark run
A new planning loop helped the coding swarm, then conflicting tickets melted the benchmark. The next fix is backlog validation before implementation.
Moving project state outside the blast radius
Shadow repositories protected project state, until the project’s tooling tried to use them. Moving that state outside the project changed the failure boundary.
Please, thank you, and the shape of an interaction
Please and thank you shape an interaction. I see politeness as a way to reinforce a productive trajectory rather than flatter a machine.
A small model that noticed the evaluation
A tiny local Qwen agent noticed the point of a context test and saved the answer into memory, defeating the test in an unexpectedly useful way.
Busy: keys belong to tools, not agents
Busy’s security design keeps keys with tools rather than agents, alongside a growing set of communication, memory and scheduling features.
What a vending-machine experiment says about role and memory
The vending-machine experiments leave me wanting better role boundaries, session management and memory. Running out of context should never threaten the business.
Why I returned to writing coding agents
After waiting for coding tools to improve, I returned to building agents around the memory and repository safety I still wanted.
Sliding context windows and the case against lossy compaction
Sliding context windows, agent-directed retrieval and clearly labeled tool results are my alternative to lossy context compaction.
WOVEN 13: making agent memory part of the architecture
WOVEN 13 brings memory and identity management into the agent architecture, connecting past decisions and conversations to the current session.
Agent badges as compact memory and reasoning cues
Agent badges can carry history, skills, philosophy and reasoning cues in a compact form. These are the effects I have been testing.