Concept

• Active Retrieval During Generation - Let the model decide when and what to retrieve mid-generation — paging external memory as a tool call rather than a single upfront top-K dump.
• Agent Memory Tiers - Internal model knowledge, short-term context, and long-term external stores form a hierarchy for what an agent retains and where.
• Chunking Strategy - Split sources into indexable units with size, overlap, and split rules that trade retrieval diversity against boundary integrity and index cost.
• Codebase Retrieval for Agents - When issue text is tiny and repos are huge, BM25 file retrieval underperforms interactive localization — and stuffing more retrieved tokens often hurts.
• Contextual Chunk Augmentation - Prepend metadata or model-generated situating text to each chunk before indexing so retrieval works when the chunk alone lacks standalone meaning.
• Embedding-Plus-LLM Memory Linking - Filter candidate memory connections cheaply with embedding similarity, then let an LLM judge which of those candidates are genuinely related — neither step alone finds good links at scale.
• Episodic Reflection Memory - Store a small buffer of self-reflection texts across trials so later trajectories see distilled lessons, not only the latest raw trace.
• Externalised Progress Artefacts - Long-running agents keep continuity across context windows through artefacts outside the transcript (a pass/fail feature list, a progress file, an init script, git commits and checked-in plans), not through transcript memory.
• FIFO Context Eviction - Drop the oldest short-term messages first when the window fills — simple, but often deletes the purpose-setting turns that matter most.
• Generation Over Extractive Retrieval - Prefer generative readers when answers need synthesis across clue-bearing passages or parametric fallback — extractive spans score zero if the string never appears.
• Generative Agent Architecture - Condition long-horizon agent behavior on a memory stream, recursive reflection, and hierarchical plans rather than single-shot LM prompts.
• Harness Memory Strategy Spectrum - Harness memory ranges from linear unbounded history through recursive summarisation, pluggable condensers and threshold compaction to persistent agent-authored memory files, and knowing which design is in play is the first step in debugging a memory problem.
• Hierarchical Summarization - Summarize a corpus too large for the context window by dividing it into window-sized units, summarizing each, then recursively summarizing the summaries along natural structure.
• Human-Agent Knowledge Roles - Humans should steer evidence and meaning while agents handle repeatable filing, integration, linking, and consistency maintenance.
• Hybrid Retrieval - Combine term-based and embedding-based retrieval — sequentially via reranking or in parallel via rank fusion — to catch both keywords and semantics.
• Ingest-Query-Maintain Loop - Durable agent knowledge compounds when ingestion, useful query results, and explicit maintenance all feed revisions back into the store.
• Iterative Multi-Hop Retrieval - Generate a search query from accumulated context at each of a fixed number of hops, retrieving more passages each time, before answering — a scripted alternative to letting an agent decide when to stop searching.
• Knowledge Activity Journal - An append-only chronological journal lets agents and humans reconstruct recent ingests, queries, maintenance passes, and their outcomes.
• Knowledge Content Inventory - A compact machine-readable catalog can route an agent to relevant knowledge pages with progressive disclosure so they do not load the whole bundle before full-text or embedding retrieval becomes necessary.
• Knowledge Maintenance Cost Curve - Automating repetitive cross-reference and consistency work can keep a knowledge store useful after manual bookkeeping would cease to pay off.
• Knowledge Maintenance Operating Schema - A versioned instruction artifact makes knowledge-ingestion and maintenance conventions repeatable across otherwise stateless agent sessions.
• Lexical Similarity Scoring - Score retrieval candidates by literal word overlap with the query, after stripping stop words and stemming, as a fast proxy for relevance.
• Memory Evolution on Retrieval - When a new memory links to existing neighbors, let those neighbors' own context, tags, and connections update in response, so the memory graph gets richer rather than merely bigger.
• Memory Management - Decide what enters short-term context versus long-term store, and when to add, merge, summarize, or evict so the window stays within budget.
• Memory Pressure Eviction - Warn the model before the window fills, then flush oldest in-context messages into durable recall while rebuilding a recursive summary.
• Memory Stream - Store natural-language experience records scored by recency, importance, and relevance so retrieval packs the most useful memories into context.
• Memory Summarization - Compress redundant short-term history into running summaries, merges, or reflection-driven updates to free context without discarding task state.
• Minimum Sufficient Knowledge Architecture - Adopt only the storage, retrieval, and output components justified by the domain, collection size, users, and model capabilities.
• OS-Inspired Agent Memory - Treat the context window like RAM and external stores like disk so a finite window can page facts in and out under agent or harness control.
• Persistent Synthesis Memory - Persisting cross-source synthesis lets agent knowledge compound instead of reconstructing the same relationships at every retrieval.
• Query Rewriting - Reformulate the user's latest utterance into a standalone retrieval query so ambiguous follow-ups resolve against the knowledge store correctly.
• RAG-Sequence vs RAG-Token - Marginalize retrieved documents once per answer sequence, or per generated token, trading single-doc coherence against multi-doc mixing.
• Reflection Tree - Periodically synthesize recent memories into higher-level insights that cite evidence, forming trees from raw observations up to abstract self-models.
• Retrieval Query Construction Spectrum - Build a retrieval query directly from the user's text, via an LLM-generated rewrite, or by letting the model decide when and what to search at all.
• Retrieval-Augmented Generation - Retrieve the most relevant external knowledge per query and feed it to the generator — context construction that treats the retriever as an agent tool.
• Retriever Generator Architecture - Split a dense (or hybrid) retriever from a seq2seq generator, with optional query-encoder finetuning while keeping the document index fixed.
• Section-Scoped Evidence Retrieval - Retrieve evidence separately for each outline section so long-form synthesis stays grounded without fitting the entire reference set into one context.
• Self-Directed Memory Management - Let the agent call memory tools itself — guided by hierarchy docs and pressure signals — rather than only a fixed external eviction policy.
• Session Log Outside the Context Window - An append-only, queryable session or event log held outside the context window keeps compaction decisions recoverable and lets a crashed harness resume from its last event.
• Source-Memory-Schema Separation - Separate immutable evidence, agent-authored knowledge, and operating instructions so each layer has a clear owner and mutation policy.
• Structured Agent Memory - Store tables, queues, and other structured state outside raw prompt text so the agent can rely on shape the context window alone cannot preserve.
• Tabular Retrieval Tools - Answer structured-data questions via text-to-SQL, execution, and generation — treating schema selection and SQL runners as agent tools.
• Task-Specific Summarization - Summarize source text for a fixed downstream question so retained details match the later prompt — trading reusability for relevance.
• Zettelkasten Agent Memory Notes - Turn each interaction into an LLM-authored structured note — keywords, tags, a contextual description, and an embedding — instead of storing it under a developer-predefined schema.