Technische Samenvatting: BudgetMem

Probleemstelling

Grote Taalmodel (LLM)-agenten vertrouwen steeds meer op geheugen om verder te opereren dan enkel contextvensters voor interacties met een lange horizon en kennisintensief redeneren. Bestaande systemen maken echter voornamelijk gebruik van offline, query-agnostische geheugenvorming. In deze paradigma's wordt de vorige context vooraf verwerkt, gecomprimeerd of op een vaste manier geïndexeerd, zonder te conditioneren op de specifieke downstream-query. Deze "eenmalig bouwen, altijd gebruiken"-benadering is vaak inefficiënt, omdat er rekenkracht wordt verbruikt ongeacht de specifieke behoeften van een query, en er risico bestaat dat informatie die cruciaal is voor bepaalde queries, wordt weggegooid.

Hoewel runtime-geheugengebruik (opvraag op aanvraag) een flexibel alternatief biedt, introduceert dit aanzienlijke overhead en latentie. Huidige industriële LLM-systemen bieden steeds vaker expliciete, getrapte rekencontroles (bijvoorbeeld "denk"-modi of redeneerniveaus) om kwaliteit tegen kosten af te wegen, maar agentgeheugensystemen missen een systematisch kader voor expliciete, controleerbare prestatie-kostenafwegingen tijdens runtime-onttrekking. De kernuitdagingen zijn:

1. Budgettoewijzing: Het definiëren van de geschikte eenheid voor budgettering in een runtime-omgeving, aangezien het behandelen van geheugen als een monolithische pijplijn met vaste rekenkracht afwegingen grof en moeilijk controleerbaar maakt.
2. Budgetrealisatie: Het bepalen hoe budgetcontrole systematisch kan worden geoperationaliseerd, in plaats van te vertrouwen op ad hoc kostenreductie of simpele escalatie van rekenkracht.

Methodologie: BudgetMem

De auteurs stellen BudgetMem voor, een runtime-agentgeheugenkader dat is ontworpen om expliciete, query-bewuste prestatie-kostencontrole mogelijk te maken. Het kader structureert geheugenverwerking als een modulaire pijplijn met meerdere stadia, waarbij rekenkracht op module-niveau controleerbaar is.

1. Modulaire Pijplijnarchitectuur

BudgetMem implementeert geheugenonttrekking ($f_{mem}$) als een reeks modules. In hun evaluatie gericht op dialoog volgt de pijplijn:
$$M_{fil} \rightarrow \{M_{ent}, M_{tmp}, M_{top}\} \rightarrow M_{sum}$$

• Filtermodule ($M_{fil}$): Verfijnt opgehaalde ruwe stukken.
• Parallelle Extractiemodules: Haalt complementaire contexten op:
  • $M_{ent}$: Entiteitsgerichte feiten.
  • $M_{tmp}$: Tijdsgerelateerde aanwijzingen.
  • $M_{top}$: Topische samenvattingen.
• Samenvattingsmodule ($M_{sum}$): Aggregeert tussentijdse contexten tot het uiteindelijke onttrokken geheugen ($m$).

Cruciaal is dat het kader geen specifieke module-set veronderstelt, maar vereist dat elke module een gemeenschappelijke budget-tier-interface blootlegt.

2. Budgettiers en Realisatiestrategieën

Elke module blootlegt drie budgettiers: LOW, MID en HIGH. Deze tiers corresponderen met toenemende rekenbudgetten en doorgaans verbeterde extractiekwaliteit. Het artikel onderzoekt drie complementaire strategieën om deze tiers te realiseren:

• Implementatietiering: Varieert de module-implementatie.
  • LOW: Lichtgewicht heuristieken (regels, regex, spaCy).
  • MID: Compacte geleerde modellen (bijvoorbeeld op BERT gebaseerd).
  • HIGH: LLM-gebaseerde verwerking.
• Redeneertiering: Varieert inferentiegedrag terwijl de modelruggengraat vast blijft.
  • LOW: Directe generatie.
  • MID: Chain-of-Thought (CoT)-stijl.
  • HIGH: Meerstaps- of reflectie-stijl inferentie.
• *Capaciteitstiering: Varieert de modelcapaciteit (grootte) die binnen de module wordt gebruikt.
  • LOW: Kleine modellen (bijvoorbeeld 3B parameters).
  • MID: Middelgrote modellen (bijvoorbeeld 8B–32B parameters).
  • HIGH: Grote modellen (bijvoorbeeld 70B+ parameters).

3. Query-bewuste Routing via Versterkend Leren

Om deze getrapte keuzes dynamisch te navigeren, maakt BudgetMem gebruik van een gedeelde, lichtgewicht router die is getraind met Versterkend Leren (RL).

• Beleid ($\pi_\theta$): Bij elke module-aanroepstap $k$ observeert de router een toestand $s_k$ (bestaande uit de query, huidige module-invoer en een module-descriptor) en selecteert een actie $a_k \in \{LOW, MID, HIGH\}$.
• Doel: De router wordt geoptimaliseerd om een afweging te maken tussen taakprestaties en kosten voor geheugenonttrekking. De beloningsfunctie is gedefinieerd als:
  $$r = r_{task} + \lambda \cdot \alpha \cdot r_{cost}$$
  Waar $r_{task}$ de beloning voor taakprestaties is (F1 of LLM-Judge), $r_{cost}$ de genormaliseerde kostenbeloning is, $\lambda$ de voorkeur voor de afweging controleert, en $\alpha$ een op variantie gebaseerde afstemmingsfactor is om training te stabiliseren.
• Training: De router wordt getraind met Proximal Policy Optimization (PPO). De kosten worden gemodelleerd op basis van tokengebruik en API-prijzen, genormaliseerd via een schuivend venster om vergelijkbaarheid met taakbeloningen te waarborgen.

Belangrijkste Bijdragen

1. Kaderintroductie: De auteurs introduceren BudgetMem, een modulair runtime-agentgeheugenkader dat expliciete prestatie-kostencontrole mogelijk maakt voor on-demand geheugenonttrekking via budget-getrapte modules.
2. Routingsmechanisme: Zij stellen budget-tier-routing voor, waarbij een gedeelde, lichtgewicht router, getraind via RL, dynamisch budgettiers selecteert tijdens extractie. Dit wordt geïnstancierd met drie complementaire strategieën (implementatie, redenering en capaciteit) binnen een uniek kader.
3. Empirische Analyse: Door experimenten op LoCoMo, LongMemEval en HotpotQA te uitvoeren, toont het artikel aan dat BudgetMem sterke prestaties levert in settings die prioriteit geven aan prestaties, en duidelijke, controleerbare prestatie-kostenafwegingscurven vaststelt onder strakkere budgetten. De analyse ontrafelt de sterke punten van verschillende tieringstrategieën en biedt inzichten in welke mechanismen de beste rendementen opleveren onder variërende budgetregimes.

Experimentele Resultaten

De auteurs evalueerden BudgetMem tegen sterke baselines (bijvoorbeeld ReadAgent, MemoryBank, LightMem) met LLaMA-3.3-70B en Qwen3-Next-80B backbones.

• Prestaties eerst (Hoog budget): In settings die prioriteit geven aan prestaties ($\lambda=0$), presteerden BudgetMem-varianten consistent beter dan baselines. Bijvoorbeeld, op LongMemEval met LLaMA behaalde BudgetMem-CAP een Judge-score van 60,50, wat aanzienlijk hoger is dan de beste baseline, LightMem (48,51).
• Prestatie-kostenafwegingen: Door de kostenweegfactor $\lambda$ te variëren, traceert BudgetMem soepele frontieren die baselines omhullen.
  • Implementatie- en Capaciteitstiering: Bestrijken een bredere kostenrange. Implementatietiering biedt snelle winsten onder gematigde budgetten, terwijl capaciteitstiering de frontier naar buiten duwt in regimes met hoge budgetten.
  • Redeneertiering: Vertoont een uitgesproken kostenconcentratie. Het fungeert als een fijnkorrelige kwaliteitsknop binnen een beperkte kostenbandbreedte, en biedt verbeteringen bij vergelijkbare kosten, maar minder flexibiliteit voor extreme lage/hoge budgetextremen in vergelijking met de andere strategieën.
• Kostenefficiëntie: Zelfs in regimes die prioriteit geven aan prestaties, blijft BudgetMem kostenefficiënt door alleen query-relevante ruwe stukken op aanvraag te verwerken, waardoor de overhead van offline verwerking van volledige geschiedenissen wordt vermeden.

Betekenis en Claims

Het artikel stelt dat BudgetMem een kritieke kloof in agentgeheugensystemen aanpakt door verder te gaan dan "eenmalige heuristieken" of "rekenkracht-escalatie" naar een systematisch beeld van prestatie-kostencontrole.

• Controleerbaarheid: Het biedt een praktisch mechanisme voor expliciete, controleerbare afwegingen, in lijn met de industriële trend van getrapte rekenopties (bijvoorbeeld "denk"-modi).
• Gecombineerde Vergelijking: Door een uniek testbed te gebruiken, verduidelijkt het werk wanneer verschillende tieringstrategieën (implementatie, redenering, capaciteit) de meest gunstige afwegingen leveren, en biedt het richtlijnen voor implementatie onder variërende budgetbeperkingen.
• Runtime-focus: In tegenstelling tot eerder werk dat zich richtte op offline constructie, richt BudgetMem zich op runtime-onttrekking, waardoor wordt gewaarborgd dat rekenkracht alleen wordt besteed wanneer nodig en in verhouding tot de eisen van de query.

De auteurs concluderen dat BudgetMem de bruikbaarheid en controleerbaarheid van agentgeheugen verbetert onder real-world budgetbeperkingen, waardoor geheugenberekening expliciet beheersbaar wordt zonder in te leveren op de kwaliteit van redeneren met een lange horizon.