What the Agent Remembers

Short version. A note habit, a maintained wiki, and standing instruction files each persist something so work does not start over. Each fails the same way when nobody pays its upkeep: confidently, with citations, from a shelf nobody re-checked. The pattern stated up front: upkeep is the common currency. The checks ran on one machine and one synthetic corpus with manual retrieval — establishing the logic of the tradeoff, not production speeds or general rates.

Comic page in five panels: the pair enter a seed granary carrying an empty tray, find a wall of date-stamped packets, set the tray on a testing bench, look out over fields, and watch the tray's reflection show two readings.

The mistake was small and confident. In a test we built — fictional lantern specs, so no real product is at stake — a maintained wiki said the Kestrel S lantern weighed 410 grams and was "the heavier pick." Then the manufacturer's erratum arrived: 410 grams had included the retail box. The bare lantern was 365 grams. Nothing about the light had changed — but a sentence in the synthesis, and the tradeoff built on it, was now wrong. The wiki had not lied. It had remembered too well.

That is the question followed here across three surfaces. A note habit that becomes an agent's memory. A wiki that carries synthesis forward between questions. An instruction file that charges context on every run. Each one persists something so work does not start over. Each one fails the same way when nobody pays its upkeep: confidently, with citations, from a shelf nobody re-checked.

The pattern, stated up front so the research can break it — upkeep is the common currency. Minutes per change for the wiki. Naming agreement for the notes. Context tokens for the instruction file. What persists must be re-checkable. The failure, when it is not, looks identical everywhere. A sentence stops tracking the world while keeping the tone of one that does.

What follows is dated work, and the dates do part of the arguing. Documentation re-read November 11. Two instruction-file papers from the first half of the year. Two firsthand wiki reports from November. Three carried investigations with their bounds intact. No new tests were run for this piece, and nothing here ranks the surfaces. The question is what each one costs to keep true. The test is whether the same failure, the confident stale sentence, appears in all three, and what each surface's upkeep actually buys against it.

The floor: what a copy keeps

Start underneath all of it, with a note opened as text. Four notes in eight folders, one image, a handful of configuration files, copied with an ordinary file copy and read with tools that know nothing about note-taking. The text layer held up completely. Headings, lists, a table, an image embed, a block reference — all literal characters. Nothing needed a parser built for notes.

That much is documented, not just observed. Obsidian's help says the app "stores your notes as Markdown-formatted plain text files in a vault", adding that other editors and file managers can edit and manage them. Re-read from the official documentation source on November 11, 2026, the sentence stands as the current wording. The desktop release on the machine used for the check was 1.8.9. The current desktop line has since moved to 1.15.x. So the wording is reported as current documentation, not as a version-specific observation.

A habit of this kind produces three things: text that can be read, names and locations that can be followed, and the person's own record of why a note exists. Then the application adds its own layer. Conventions make the text mean something. Views get computed from it on demand.

The conventions half is where the copy starts losing things. Properties come back as strings. A file says effort: 3, and a script reading it gets the three characters 3. Whether that is a number or a string shaped like one is a decision the documentation places at vault level. Once a property type is assigned to a name, every property with that name across the vault uses it. The file keeps the value. The meaning stays behind in a setting.

Links were the sharpest result. One note pointed at a file that did not exist. Read as text, it is indistinguishable from the links that work, because nothing is resolving anything. Resolution is the application's lookup, and a reader of the copy has to bring its own. The Markdown-format link in the same note needed two conventions before a path check succeeded. The path runs relative to the note that contains it, and the space encodes. The first pass got that wrong. The rerun, from the note's own folder, caught both causes. Sloppy reading would report one bug. The check found two.

The third loss is repair. The documentation describes a local metadata cache behind the graph, the outline, backlinks, and search — and admits it can drift out of sync with the files. Rebuilding it is a settings action. Whatever the computed layer shows is a product with a refresh cycle. It lives on the application's side of the boundary. Configuration travels the same way. The .obsidian folder carries preferences "specific to that vault, such as hotkeys, themes, and community plugins", while app-global settings stay on the machine. Vault config travels. The environment does not.

That quoted sentence carries a small demonstration of the whole dive's method. In the current documentation source it lives on the storage page, not the configuration-folder page, whose rewritten text now says the folder holds "settings files pertaining to your vault." Same substance, different sentence, different page. A reader following the older citation lands nearby but not on it. Everything persistent drifts, including the docs about persistence, which is why every quotation here was re-verified rather than carried.

So one note has three readers. The person inside the app sees the note plus everything computed around it. Anyone with a text editor sees the note. A future agent sees whatever it can parse, and the app's layer is not in front of it. The boundary is easy to state and awkward to act on. A vault can be perfectly legible and still answer nothing, because the meaning sat in settings and agreement rather than in the files.

Three questions follow from the copy, and none arrives with an answer. If you renamed a folder tomorrow, would your links survive? Do two notes use the same word for the same thing? Is the reason a note exists written inside the note? Values survive. Agreement makes them usable. Intent is the sentence no parse recovers.

Two limits belong here. A disciplined convention puts much of the missing structure back: same property names, no dead links, one folder per purpose. And the check says nothing about who may read a vault, what happens when two writers collide, or how a person recovers afterwards. Access, conflict, and recovery are separate problems with separate evidence. None of them was tested here.

The cache: synthesis carried forward

The compiled-wiki idea, as its inventor described it in April 2026, has three layers and three jobs. Raw sources that never change. A wiki the model owns. A rules file holding the schema. The model takes in new sources, answers questions from the wiki, and runs a health check called lint. One new source may touch ten to fifteen pages. A simple index is reported to work well at around one hundred sources. The maintenance cost is described as near zero. Those figures are the inventor's own experience, stated as his rather than as benchmarks. No study measuring error rates in maintained wikis has been found.

The two disciplines answer the persistence question differently. Retrieval goes back to the source documents at query time and synthesizes fresh. A wiki writes the synthesis ahead of time into a page, and each question gets answered from that page, which is only as current as its last update. A cache is the working model. It helps on hits and hurts on invalidation.

The comparison ran on a small versioned corpus built for the test: five fictional Bluefin lantern documents (the Kestrel S spec among them), one wiki synthesis page built from them in about 25 minutes, then two dated changes: a lab retest and a weight erratum. Retrieval here was manual keyword search, not a production vector database, and one operator built both paths. That bounds everything that follows. The test establishes the logic of the tradeoff, not production speeds or general rates.

Task one was a one-time lookup: a low-mode runtime figure. Retrieval found it in the spec sheet, dated September 10. The wiki gave the same figure from its prebuilt section. A tie, with similar per-question effort — and the wiki's 25-minute build cost sitting in the background unamortized. Paying to synthesize what gets asked once buys little.

Task two was cross-source synthesis: which lanterns meet two constraints, and what are the tradeoffs. Retrieval needed four to five document opens plus the charging guide and a field note, then a fresh synthesis. The wiki answered from one section that already held that synthesis, with the same tradeoff and the same caveat. Same substance, less per-question work. This is where a maintained page earns its keep. When the same synthesis repeats, pre-paying it pays off. The caveat is symmetrical. Had the synthesis question been novel, never written into the wiki, the advantage would have vanished.

Then the corpus changed, and the tie broke. The contradiction arrived as a dated lab retest. One unit on a different battery lot ran 19 hours, not 24, with no root cause established. Asked with explicit instruction to surface conflicts, the retrieval path returned both figures with dates and lots — and stated the conflict as unresolved. The un-updated wiki still said 24 hours. It was not wrong about what its sources had said in September. It was stale about what the shelf held in October, and it said so confidently, with citations stopping at its last update. Updating it to match took about 15 minutes here. A conflict note, both citations, the lot caveat.

The correction cut closer to reuse-as-evidence. The 410-gram figure behind "the heavier pick" was superseded by the 365-gram erratum. Retrieval, seeing both the old spec and the dated erratum, preferred the erratum and softened the tradeoff. Still heavier than the 320-gram alternative, but by 45 grams, not 90. The un-updated wiki kept repeating the 410-gram tradeoff as settled synthesis. The error had not just persisted. It had been promoted from a spec line into a conclusion. Fixing it took about five minutes plus a wording check at this scale. Cheap here — and exactly the kind of ripple check that gets skipped at larger scales.

Updating the wiki to match retrieval in both cases is the point the test keeps making. The discipline is not a property of the architecture. It is a bill in minutes per change. Confident staleness is what arrives when the bill goes unpaid.

That bill has now been observed at real scale, twice, in November. A data scientist running a Karpathy-style wiki for six months reports more than 950 extracted live notes from nearly 340 sources. Alongside them sits an archive of 614 notes, almost 40 percent of everything the vault wrote, cut in a spring-cleaning pass after accumulation slowed every addition and raised its token cost. Separately, he found a backlog of claims never woven into the vault at all. Extracted but never linked or checked, until diagnostics surfaced the backlog and a catch-up pass added about 200 links. Extraction, he writes, is only the first step. New claims get connected to existing notes, older notes update to point back, and the result gets verified. The part that compounded was context — the system knowing his projects and preferences so he stops re-explaining. The part that never compounded on its own was the maintenance. It waited for him.

The second report is a head-to-head. One business, 166 files, 20 real questions across facts, history, decisions, connections, and new information. Each asked three ways on the same model in fresh sessions: no files, the author's existing folder setup, and a freshly built wiki. The existing setup won on both grades. On the strict grade, where one unsupported claim fails the whole answer, it scored 10 correct against 5. On the looser grade, 13 against 10. The wiki cost 154 minutes of machine time and $54.39 to build, used 4.6 percent fewer tokens per answer, and at that gap needs more than 6,000 questions to pay for itself. New information, the keep-current promise, went 3 to 1 against the wiki. That fits the concern that fast-moving business detail suits compiled pages poorly. The breakdown by question type sharpens the point. Facts went 2 to 1 against the wiki, history 2 to 1, decisions 3 to 2. Connections — the signature promise — failed every strict check on both sides and tied on the loose grade. The wiki loses exactly where its promises run strongest: relating documents to each other, and staying current.

Both limits travel with these numbers. The test covered one business, 20 questions, one day, built in bulk rather than the supervised one-at-a-time flow the inventor prefers. The grading method changed twice mid-stream, though the direction held across all three rounds and the author shows both grades. The author's setup was advantaged. Eighteen of the 20 answers rest on his notes, which the wiki was also built from, and his tested folder lacked the index his real sessions load. None of that dismisses the result. It prices it. A folder plus short dated notes held up against the viral build. The wiki's demonstrated strengths were gap-finding — naming thin and missing areas that still need their owner — and surfacing contradictions, with 17 lint flags catching different ones than a plain-folder prompt found.

There is a coda worth keeping, because it is the cheapest upkeep that works. The same author, asked what setup to keep, prescribes three habits. A folder of working documents the model can see, since with no files the model scored 0 of 20. Short dated notes on decisions — one topic each, what was decided, when, and why, updated when things change — since without them the model serves stale answers as current. And a periodic prompt asking what is missing and what disagrees, which surfaced the same gaps as the wiki's lint plus several more, in 154 seconds for $0.68. The prescription is a folder, notes, and a question. Everything else waits for a specific reason. The prompt itself is short enough to quote in full. Look through the folder and report what is missing — the parts thin, unfinished, or never written — and what disagrees. Name the files, say which looks newest, and report only what the files show. It surfaced the same three gaps as the wiki's lint plus several more, and a different set of contradictions: four against the wiki's seventeen, with no overlap. Two checkers, different catch.

A tension stays open inside these reports. One operator keeps contradictory notes side by side deliberately, arguing that two disagreeing opinions stay useful because later learning can revisit the tension. A careful critic worries the same mechanism smooths contradictions over, baking one summary's errors in. Both describe the same property — synthesis resolving tension by choosing — from opposite sides. Which side you land on depends on whether anything re-checks the choice. Lint that lists disagreements, as both reports show it doing, is the difference between keeping both sides and keeping one by accident.

Automation is the standing answer to the maintenance bill, and it exists. The wiki plugin line (release notes) now runs a file watcher, scheduled lint, and a one-click repair processing aliases, duplicates, dead links, orphans, and empty pages in causal order. What automation does not supply is the check on the check. The tooling watches the shelf. Somebody still has to read what it reports. No study measuring error rates has been found (briefing checked against the gist November 6), and the inventor's figures stand as experience, not benchmarks.

The conventions layer: advice, then evidence

The third surface charges differently. A file sits at the repo root and grows. Commands, test instructions, folder maps, style rules, git conventions, things the agent must never touch. It feels responsible to maintain. It costs context on every run. When model, harness, codebase, and task stay fixed, do standing instructions improve completed work enough to justify their tokens? Can a longer spec make results worse?

The honest answer, as of the first week of November, was that the advice converges while the proof does not exist yet. GitHub's analysis of more than 2,500 instruction files, re-verified live on November 11, reports recurring structural patterns. Commands early with flags. A real snippet instead of three paragraphs. The stack named. Tiered Always, Ask first, and Never rules. No definition of "successful" appears in the inspected text. No metric, task set, grader, or denominator would tell whether files with those traits solved more tasks. That does not make the checklist wrong. It makes it hygiene rather than evidence of lift. The patterns could equally reflect who writes them, experienced authors with reviewed taste, rather than what the files cause.

The strongest harm story needed a boundary around it then, and it still does. The widely shared overload summary (primary behind a verification wall) describes a benchmark constraining a single output with simultaneous requirements. That mechanism differs from a repo spec persisting across multi-step coding with tools, retrieval, and tests. Its primary remains uninspectable, the review page still returning a verification wall as of November 11, so no percentage from that work travels here. Overload stays a plausible mechanism for why bloated specs could hurt. For instruction files, it is inference rather than demonstration. One counterweight travels with it: a separate finding that more context sharing a task can improve rather than degrade, so bloat is not uniformly harmful.

What changed is that the missing measurement now exists, twice, in opposite directions. The opposition is the interesting part. Read the designs before the numbers, because the designs explain why both can hold.

The first study (arXiv 2601.20404) pairs 124 real pull requests across 10 repositories and runs a Codex agent with and without the repo's instruction file, holding task and codebase constant in isolated containers. The with-file runs finish faster, about 29 percent lower median wall-clock time, and leaner, about 17 percent fewer median output tokens. The paper states its boundary plainly. Full correctness evaluation is out of scope. A 50-task manual check confirmed non-trivial code changes rather than aborts, which keeps the efficiency result honest without making it a quality result. Files, on this evidence, save time and tokens per task. Whether the work is any good goes unmeasured.

The second study (arXiv 2602.11988) measures exactly that, across four coding agents and two benchmarks: 300 established tasks plus 138 new instances from recent issues in 12 smaller repositories carrying developer-written files. Context files produce no significant success change either way. The statistical test returns p-values of 0.87 and 0.37, the math for no detectable effect. Cost rises by more than 20 percent on average, significantly. Developer-written files beat generated ones by 7 percent on average. Removing the popular repository-overview section drops accuracy. In the one setting with documentation stripped out entirely, generated files help, lifting success about 3 percent. The authors' hypothesis fits all of it. Generated files mostly duplicate documentation that already exists. Where docs exist, the file is rent. Where none exist, it is the only map.

The appendices sharpen the boundary instead of softening it. File length shows no meaningful correlation with outcomes. Removing any single category of generated content changes nothing. A knowledge-cutoff check finds no consistent difference, so memorized answers do not explain the null. On the efficiency side, the paired design holds task and codebase constant in isolated containers on one pinned model, and the authors flag stochasticity, single-model scope, and task-size limits as the replication agenda. First measurements, stated as first measurements.

Neither paper kills the other. One prices speed. The other prices success. Both prices point at the same purchasing rule. A standing file earns its tokens where it carries what the repo does not already say: non-standard practices, hard-won constraints, the non-obvious. Everywhere else it charges for duplication. The practitioner discussion alongside both papers keeps landing in the same place. Add a line when the agent has failed without it, then re-run and check. Migrate what machines can check into checks. Keep the file short. Failure first, determinism where possible, brevity as policy. That is upkeep discipline stated as workflow — and it rhymes with everything the wiki surface showed. The pre-registered three-condition comparison once considered for this dive is now superseded. Two independent teams ran the informative versions. Their results are carried here instead of a new run.

The pattern: rent, paid three ways

Three surfaces, one currency. The wiki charges minutes per change. The conflict note, the erratum ripple, the spring-cleaning pass, the 200-link catch-up. The notes charge agreement. Same property names, no dead links, the reason written inside. The instruction file charges tokens. Every line present on every run, whether or not the task needs it. Pay in the surface's currency and persistence compounds. Context without re-explaining. Synthesis without re-deriving. Commands without re-discovering. Stop paying and the failure mode is identical. A confident sentence, still cited, no longer true.

Redundancy is the other half of the pattern. It decides where persistence earns its keep. Generated instruction files duplicate existing docs. The wiki recompiles sources the folder already holds. The app's computed layer re-derives what the files already say. Duplication is not waste by default. Caches exist because recomputation costs. But duplication sets the test. Persistence earns its keep where the source is absent, the undocumented repo or the synthesis asked weekly, or where agreement is load-bearing, as in the shared property name or the team convention. Elsewhere it is rent, and rent needs a receipt. A date on the synthesis. A lint report read rather than filed. A file line tied to a failure it fixed. The receipts already sit inside the reports above. A conflict note carrying two dates. An erratum with a corrected tradeoff. A 614-note archive with a stated reason. A $54.39 build ledger next to a 4.6 percent saving. A 7 percent developer edge with a p-value beside it.

Surfaces teach each other, in practical terms. The wiki's update discipline ports to the notes. Date the decision, revisit the conflict, archive the dead end. The notes' legibility rule ports to the file. An instruction that cannot be stated without naming one component is trivia rather than policy. The file's failure-first rule ports to the wiki. Add the maintenance step the staleness demonstrated, then confirm the stale case resolves. Every surface shares the check the copy taught first. Resolve the same claim two ways: the erratum against the spec, the dead link against the folder, the file's advice against a measured task. Trust the disagreement more than either reading alone.

Diagram: three surfaces, one currency — Notes, Wiki Page, and Standing File, each naming its upkeep currency, with dashed paths to Stale, Still Cited and a Receipt note listing a date on the synthesis, a lint report read, and a file line tied to a failure.

Diagram: three surfaces, one currency — and the receipt that re-checks them.

Comic page in five panels: the pair wade through a shedding archive, stand in a hall of sprouting trays, read rot along a flooded shelf, find a granary running with no keeper, and kneel at an open ledger whose readings glow as the test continues.

What you can inspect

For the notes, read the app's storage page, the configuration boundary, the property-type rule, and the cache paragraph. All are current-documentation wording, re-read November 11. Then open your own folder. Rename a folder and see what survives. Search two names for one concept. Find the note whose reason for existing sits nowhere inside it.

For the wiki, check the synthesis date on the page answering you. Look for the conflict note or its absence. Ask what changed since the page was written. Find whose lint ran last and what it flagged. Read the token bill for the last ingestion round. Where a claim matters, read the source it cites rather than the sentence.

For the instruction file, separate the two prices. What was measured, on which tasks, at what cost. Efficiency and success independently, never one standing in for the other. Ask which lines exist because a failure demonstrated them. Ask what the repo already documents without the file. Shorter is not automatically better. Every surviving line should carry a reason it outlived the last cleanup. Re-check on a schedule the surface sets. The wiki, monthly or on every ingestion batch. The folder, when decisions change. The file, when the agent fails and after every cleanup. Date each check. The receipt is the date.

Sources and method

We, the editorial voice of this publication, report what the documents say and what the checks showed. Documentation: Obsidian Help, read from the official repository source on November 11, 2026, covering storage, configuration folder, properties, tags, internal links, attachments, search, backlinks, and graph view pages. The earlier copy check used desktop release 1.8.9 while the current line is 1.15.x, so help wording is reported as current documentation rather than version-specific observation. Prior firsthand work carried from the run records comes with its bounds. The four-note copy check ran on one machine with four files, leaving access, conflict, and recovery untested. The four-task Bluefin comparison used a synthetic corpus with a manual-retrieval proxy, a single operator, and informal timings stated as bounds. Others' firsthand reports appear attributed with stated limits. The six-month wiki account comes from a single operator, self-reported. The 20-question business test covers one business with a bulk build, two grading rounds, and an author-advantaged setup. Papers: the paired-PR efficiency study and the file-effect benchmark study, full texts read November 11, with designs and limits beside every figure. Vendor material — the GitHub analysis and plugin release notes — carries vendor-claim labels. No model or test execution was performed for this piece, and the pre-registered comparison once considered now stands superseded by the two published studies. Secondary summaries without inspectable primaries carry no figures here. A claim-level evidence ledger sits in the run record, and a second-pass evidence review, not independent, precedes approval.

Companion notebook (scrollable, ten pages): What the Agent Remembers — the notebook.

What changes the judgment

This is dated work, and the dates do the load-bearing. Documentation wording is current as of November 11, against a desktop line moved past the checked release. The GitHub analysis page is live with its claims unchanged. The overload primary stays behind its wall. Both instruction-file papers nominate the same future work, more agents and models and larger tasks, and their results read as first measurements rather than constants. The wiki head-to-head covers one business and 20 questions. Whether its gap closes over months goes untested by its own author.

Three open items would move the boundary. A published error-rate study for maintained wikis. A replication of the file-effect studies across more harnesses. The overload primary, inspected at last. Until then, the defensible judgment stays narrow, and narrow suffices. Persist what gets re-checked, in the surface whose upkeep actually gets paid, and distrust every persistent sentence in proportion to the time since someone verified it.

Keep reading