pensieve-stateful-context

name	pensieve-stateful-context
title	The Pensieve Paradigm: Stateful Language Models Mastering Context
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2602.12108
keywords	["Stateful Language Models","Context Management","Memory Tools","Long-Horizon Tasks","Active State Engineering"]
description	Enable language models to actively manage their context using memory tools (read, index, note-take, delete). Models receive agency to self-engineer context rather than passively consume pre-staged information, maintaining compact high-quality reasoning states through strategic deletion of irrelevant information while preserving distilled notes.

The Pensieve Paradigm: Stateful Language Models Mastering Context

Problem Context

Current language models passively receive context that humans curate, creating a bottleneck: they cannot adapt information selection to specific reasoning needs. The Pensieve Paradigm shifts agency to the model itself: models receive memory tools and actively manage context throughout long-horizon tasks. The key insight is transforming from monotonic context accumulation (until context window exhaustion) to sawtooth profiles (strategically deleting irrelevant information while preserving high-value summaries).

Core Concept

Models coordinate four memory operations: (1) read: retrieve chunks from document corpus, (2) index: catalog retrieved information, (3) note: take distilled notes on key facts, (4) delete: remove irrelevant context. This maintains a compact, high-quality reasoning state throughout extended tasks. The model gains the "wand" to use memory tools directly (unlike external retrieval systems that manipulate context without model input).

Architecture Overview

• Memory toolkit: Read, index, note-take, delete operations
• Tool orchestration: Model decides which tool at each step
• State management: Track current context, identified facts, deleted items
• Distillation: Summarize information into notes before deletion
• Long-horizon coordination: Manage reasoning state across 100+ steps

Implementation

Step 1: Memory tool interfaces

from dataclasses import dataclass
from typing import List, Dict, Optional
import json

@dataclass
class MemoryState:
    """Current state of model's working memory."""
    current_context: str       # Current active reasoning state
    indexed_facts: Dict[str, str]  # {fact_id: fact_text}
    notes: List[]          
    retrieved_docs: [, ]  
    deleted_context: []    

 :
    

     ():
        
        .corpus = document_corpus
        .state = MemoryState(
            current_context=,
            indexed_facts={},
            notes=[],
            retrieved_docs={},
            deleted_context=[]
        )

     () -> []:
        
        
        query_keywords = query.lower().split()
        scores = {}

         doc_id, content  .corpus.items():
            score = (
                content.lower().count(kw)  kw  query_keywords
            )
             score > :
                scores[doc_id] = score

        
        top_docs = (scores.items(), key= x: x[], reverse=)[:num_chunks]
        retrieved = [.corpus[doc_id]  doc_id, _  top_docs]

        
         doc_id, _  top_docs:
            .state.retrieved_docs[doc_id] = .corpus[doc_id]

         retrieved

     ():
        
         fact_idx, fact  (facts):
            fact_id = 
            .state.indexed_facts[fact_id] = fact

     ():
        
        note_entry = {
            : summary,
            : reference_ids  [],
            : (.state.notes)
        }
        .state.notes.append(json.dumps(note_entry))

     () -> []:
        
        deleted = []
         fact_id  fact_ids:
             fact_id  .state.indexed_facts:
                deleted.append(.state.indexed_facts.pop(fact_id))
                .state.deleted_context.append(fact_id)

         deleted

     () -> :
        
        summary = 
         summary