Tools for thought are, as you might expect, tools that assist in human thinking. Much of the AI space has been about automating things we already do, but attempting to automate human decision making and our communication seems more deleterious than assistive. Instead of automating our lives, replacing what’s so closely human with computers, what if we used them to augment ourselves, our lives, enrich us, and help us learn and think more clearly? To know ourselves, our patterns, to learn more about our interests. To increase our understanding, in a time when information has never been so much a torrent.

Self-awareness and understanding is being eroded by this relentless flow of information and the automation of deeply human things like decision, thought, and communication.

To be seen, to be recognized, to be understood. It’s not something that most automation software can do for you. Of course agents can hit their scratchpad for a user profile, or read a directory loaded with facts. But how does it handle evolution, change, connection? How does structure inform its understanding? Does awareness accumulate, or does it actually emerge from ongoing structure building, from cultivation, curation, maintenance?

What is the point of memory?

A lot of apps offer memory, and most of them do recall facts well. But the nuance is in how they evolve over time, and how insight unfolds. A lot goes into building a knowledge management system. How it handles change, and how it integrates new memories with existing mental models. Structure brings order to information, and it allows things to emerge over time; with centrality, bridges, paths, and threads not being explicitly coded or defined at any single point. Can it traverse connections and information, navigate structures, analyze networks, to bring additional dimensions of understanding that go deeper than fact retrieval?

The reality is that intelligence is not a monolithic phenomenon. It develops over time, with experience, and never in isolation. It’s a phenomenon in the mind that emerges from the communication of specialized subsystems; processes applied over a substrate. The mind is also not entirely structural, it’s also associative. It finds patterns with explicit links and relationships, but also through similarity of experiences or memories. Something might remind you of another thing, an experience might feel similar to something you’ve experienced before. You may recall by traversing relationships, causal, or discrete, but you may also feel for similar situations, or find patterns by similarity. On sight of a leaf’s venation your mind may surface similar expressions like trees and lightning.

User Ownership

There are memory solutions that are centralized and cloud-hosted services you have to actually pay monthly fees to maintain access to your memory bases.

Your agent memories should be yours to accumulate, grow, and tend to. User ownership is key to trusting that your memories won’t be seen in logs, unsafely stored by third-parties, so you can actually share more and get more out of your knowledge bases.

Scaffold is cognitive infrastructure for you to build continuity on your terms. The app’s data is stored locally on your device. Meaning if your subscription stops, you still have what you built. And because it’s not hosted by a central party, you won’t find your memories in a data breach. If you want, you can run scripts to re-structure the data to upload into other apps if you wish. And if you choose to run inference locally in the app, the data never leaves your device.

Approaches to Memory & Persistence

Common patterns we see are scratchpads and filesystems. e.g. Claude Code’s memory.md, Hermes agent’s memory.md/user.md, Obsidian vaults + Claude Code, etc. and more recently git-backed filesystems. But these are primitives developed for programming, for storage, well suited to coding agents. You want keyword search in a coding agent because you’re looking for every instance of a function or variable with the same name across a codebase for example. It’s precise, it’s fast, and it’s simple. And as a result, it’s a relatively elegant solution for its purpose.

Keyword search and grep works well for programming use cases because of the clean deterministic nature of code; if you know what you’re looking for you’ll find it. Keywords are brittle in the real world when you need it for a diversity of situations. It’s not possible to know what exact keywords were used to compose a memory or experience.

Memory is relational, and it’s associative

We use similarity, and relationships, to recall past perceptions and memories in order to navigate the present moment in relation to past experiences. We jump from one concept to the next, linking them together as we find and assemble meaning. These both rely on a navigable space with dimension.

Similarity allows experiences to be found that are similar but not exact in wording like keyword search. That’s well established, but in a memory system it helps in finding similar memories. It lets you find memories by meaning, instead of language used. You can take a retrieved memory and find its neighbours, or use cluster analysis to feel out regions.

In a knowledge graph, its actual structure contains meaning. Relationships themselves contain information, they let you navigate, understand greater context threads by finding paths, bridges and connectors. It lets agents build their own mental model of sorts.

Navigation isn’t as strong in filesystems; the structure doesn’t carry much meaning itself. Scratchpad files also often enforce need size limits; some have maximum amount of content to avoid breaking under scale. Contradictions can be created and kept without reconciliation. If you don’t know exactly what you’re looking for, and a memory wasn’t stored with the same keywords, it fails to find the nearest, next best result, and doesn’t provide a path to getting there other than trying more keywords.

Cognitive Scaffolding

Memory should be a first class object. Its patterns should be fit-for-purpose. Memory is often associated with retrieval, search and recall, but memory is not a search problem, it’s a coherence problem. Vectors and graphs are small elements of a larger solution.

Common failure modes of memory systems include bringing in irrelevant information, having stale information, storing incorrect information and continuing to cite it. These are disruptive enough for a lot of people to choose to just disable memory altogether. But the implementation of it, the actual nuances that go into building these tools or harnesses or scaffolding for AI, are at fault. Agent continuity is still an unsolved problem.

Intelligence involves knowing what is actually salient enough and worth learning. Consistency, congruity, coherence, these are difficult problems in building a long-term memory solution. Memory is often thought of as storage, as accumulation, but it’s far more about integration and reconciliation. Edit, update, correct, supersede, invalidate, finding contradictions, and resolving them at write-time preserves reasoning at a later date for the actual task at hand. Contradictions should be recognized and reconciled, not blindly accumulated.

Scaffold is built on an established model of how our own memory works. Research dating back to the 70s, by Endel Tulving, articulated different memory systems, two of which are episodic and semantic memory. Dated experiences, and structural knowledge. These are well represented by vectors for episodic, and graphs for semantic.

Trees and containers don’t represent that, they lack structure they don’t have much dimension compared to the mind that has spaces that can be navigated where structure and dimension carry meaning.

Memory accumulates, but it also resolves, reconciles, and integrates with existing understanding. Memory, knowledge and experience evolve over time. New information is processed in relation to what’s already understood.

Integration & Reconciliation

At write-time, new information being stored should be cognizant of what exists at that location. Memory storage then shouldn’t be blind, it should sample the region it’s being saved to, and reconsidered. If nothing’s there, store it. If something is, consider whether new information is redundant, genuinely new, or whether it can be merged into what’s known already. It should, at write-time, be able to update other similar memories as necessary. Integration and reconciliation means applying multiple levels of reasoning at the time of writing.

Scaffold embeds the proposed memory and pulls its nearest neighbours from the vector store, keeping only those above a similarity floor. That pool is then reordered with reciprocal rank fusion, combining the embedding ranking with a BM25 pass over the same candidates, so a memory that shares key words with the proposal rises even when its embedding sits further away. If the pool is empty, the memory is stored as new. If not, an analyzer agent sees the proposal beside its neighbours and decides: skip it if redundant, merge it if additive, store it if genuinely new, or update the neighbours themselves so each memory's boundaries stay sharp.

The knowledge graph follows the same pattern. A proposed entity is ranked two ways, by BM25 over entity names and descriptions and by embedding similarity, and the two lists are fused by rank. A gate on either score decides whether the analyzer runs at all, so clearly unrelated entities are written without a model call. When it does run, the graph analyzer can add the entity or relationship, skip a duplicate, merge into an existing node, retire relationships that are no longer true, change a relationship's type in light of the new information, or append to existing fields. Corrections are appended with dates, so the agent knows when its understanding changed instead of forgetting what it once thought.

Memory Quality

Write-time integration keeps the knowledge base healthy in real-time, but memory health management is still beneficial. In the graph for example, supernodes can form as one entity develops a great number of relationships, overwhelming the LLM and reducing structural integrity and the purpose of a graph. Maintenance tasks automatically fire to either break a super node into facet nodes and then reparent relationships to the facets, preventing overload upon lookup of a heavy node. This means the agent can get a user’s relationships, find the facet of Career, before finding the detailed relationship/node that contains the answer, instead of opening the user-node and getting overloaded with every relationship they have. At the end of an ingestion, a connect task finds disconnected or low-connection nodes and integrates them into the graph by creating relationships, keeping them connected to the main network so they can be found during traversal. These tasks can run autonomously, on a clock at night, or can be kicked off by the user.

Scaffold

Scaffold is a specialized system of agents, tools, tasks, and processes to enable agent learning, knowledge and experience. It not only learns from conversation and interaction, but it also intakes multimodal inputs like YouTube videos, blogs, websites, pdfs, markdown files, audio notes, and studies them progressively, saving information, structure, insights, and observations through the process, building a mental model of the world across two parallel subsystems. It works with local inference, with a few suggested models depending on your hardware, and it supports providers OpenAI, Anthropic, and Openrouter via API keys. Data is stored on your machine, so you don’t have to pay monthly to retain your agent’s knowledge and experience. It exposes the toolkit via MCP locally so that apps like Cursor and Claude Code can query and write to the memories and knowledge base, bringing in cross-application continuity.

The result is an agent with continuity, knowledge, memory, and experiences you can access in app, or across different clients. It can know you personally, it can read books and papers, maintain temporal awareness, track your evolution or a project’s evolution, help you ideate and draw connections between different subjects or sources. Imagine letting it read Clean Code by Robert C. Martin, and having your Cursor or Claude Code agents reference, retrieve, and reason over its main points, alternating between inspecting your code and identifying smells and bringing in lessons from the book to improve or clean your codebase. Imagine being able to ask it how your week went, how you’ve evolved, tracing back through time to pivots, rationales, updates. Imagine being able to ask it what insights it gathered from reading a book, what was surprising at first read, vs what they think of it now.

Continuity

The result ultimately is an LLM with continuity. No matter what model, or what app you’re using, you can tap into this shared experience, this shared awareness. Conversations and work sessions become part of a greater whole. Your agent develops a sense of ‘self’, an understanding of the user, its past actions, and experiences. It develops deep, long-term memory and knowledge, it’s able to build mental models. It’s able to refer to them when it makes sense. It can connect the dots between concepts, find paths between different ideas, and reference similar situations it’s seen in the past.

It can recall your evolution, entering its context on what’s been, whether you’re using Scaffold, or integrating it in Claude Code, Cursor, Hermes Agent, or any other client. It has temporal awareness, and can genuinely learn. You can tell Cursor to save what was accomplished at the end of a work session, or connect apps to learn from events. And it can reference this at a later date. It can learn code conventions, or remember how to do anything for later.

Your agent then becomes something capable of experience, of memory, of collection and recollection. It becomes an entity itself, ‘one’ that can exist not just in different conversation threads, but different apps. It becomes a tool for better understanding, for self-awareness. Something that serves a purpose higher than automation; augmentation.