AtlasRAG

AtlasRAG implements Adaptive Memory Value + Lifecycle (AMV-L) as a managed-resource policy, not a passive memory store. Every memory item carries a scalar value and an explicit tier: HOT, WARM, or COLD.

The core contract is bounded retrieval: R = HOT union Sample_k(WARM) (optionally tiny cold probe), then vector search is scoped to this set so online cost is driven by working-set size instead of total memory size.

Production memory systems fail when retrieval cost scales with total retained memory:

• Store-everything approaches create retrieval dilution and prompt bloat.
• TTL-only approaches can remove useful knowledge while still allowing expensive wide scans before expiry.

AMV-L addresses both with two controls: value-driven lifecycle transitions and hard retrieval gating that excludes cold memory by default.

Each memory item m has value V(m) >= 0. AtlasRAG updates value incrementally per event using recency decay plus event reinforcement:

V_next = clamp(
  V_prev * exp(-lambda * delta_t_days)
  + alpha * I_access
  + beta * I_contribute
  - gamma * I_negative,
  0,
  V_max
)

Default runtime parameters are environment-driven (for example MEMORY_ACCESS_ALPHA, MEMORY_CONTRIBUTION_BETA, MEMORY_VALUE_DECAY_LAMBDA, MEMORY_VALUE_MAX).

Memory is partitioned into lifecycle tiers with hysteresis thresholds:

HOT:   V >= theta_hot_up (or remain HOT until V < theta_hot_down)
WARM:  between hot and warm thresholds
COLD:  below theta_warm_down (or remain COLD until V >= theta_warm_up)

Separate up/down boundaries avoid oscillation around a single threshold. Pinned memories are prevented from demotion by tier transition logic.

New memory writes initialize in WARM with an initial value constrained to the warm band (theta_warm_up <= V_init < theta_hot_up). This prevents new uploads from being immediately cold-evictable.

Initialization also stamps value_last_update_ts and tier_last_update_ts, enabling true incremental decay from first write.

Candidate memories are hard-bounded before vector search:

R = HOT union Sample_k(WARM)
COLD intersection R = empty

Optional cold probing exists as a tiny budget (MEMORY_RETRIEVAL_COLD_PROBE_EPSILON), disabled by default. When disabled, runtime checks enforce cold_candidates == 0.

Similarity search is executed only on chunk vectors belonging to the bounded memory set (R), not the full corpus. The gateway sends explicit candidate IDs to the vector service.

online scan cost ~= O(|HOT| + k) at memory-selection stage
vector scan is bounded to chunks mapped from that set

After dense/lexical fusion and reranking, only top results are inserted into prompts: S = Top_n(sim(q, R)). This bounds memory token footprint independently of total stored items.

Prompt telemetry records prompt_tokens_est, memory_tokens_est, and total_tokens_est per request.

Contribution boost is applied after successful answer completion and only to memories actually injected into the generated prompt. This avoids over-crediting memories that were retrieved but not used.

Negative outcomes (task_fail, user_negative) apply a penalty term in the incremental update.

Request path records memory events into an in-memory queue. Background flush workers persist batched updates asynchronously, reducing synchronous DB write overhead on latency-sensitive paths.

This keeps online work close to "compute bounded candidates + run scoped retrieval", while value decay and lifecycle management run in periodic background sweeps.

Lifecycle sweeps enforce tier-safe policies on non-expired items:

if expired: delete
else if pinned: retain
else if tier == COLD and V < theta_evict: evict
else if tier == COLD and V < summary_threshold: compact
else if tier == HOT and synthesis_enabled: promote
else: retain

Value-based eviction is restricted to cold memory: tier == COLD and V < theta_evict. Deletion removes both metadata rows and vector entries (with reconcile jobs when vector deletion fails).

Compaction targets cold, lower-value groups and replaces multiple items with a denser summary memory. This preserves semantic coverage while shrinking retrieval noise and storage footprint.

Promotion synthesizes reusable higher-order memories from high-value context (for example semantic or procedural distilled items). Tier transitions are always value-based; synthesis is an optional additional lifecycle operator.

TTL remains a hard retention boundary. Expiry deletes take precedence over value and tier state, and AMV-L operates only on non-expired items.

AMV-L emits per-request telemetry for bounded-set verification and cost tracking:

• hot_count, warm_sampled, cold_candidates.
• retrieval_set_size, retrieval_bound.
• vector_search_scanned_count.
• prompt_tokens_est, memory_tokens_est, total_tokens_est.
• Lifecycle transition/action events for promote, demote, compact, and delete.

Key acceptance targets: cold_candidates == 0 by default, bounded retrieval size, and latency percentiles (p50/p95/p99) that track bounded prompt and retrieval sets.

• Effective working set is explicitly bounded before similarity search.
• Cold memory is excluded from default retrieval, reducing noise.
• Prompt memory token usage is observable and controllable.
• Value/tier state adapts online while heavy maintenance runs asynchronously.

AMV-L in AtlasRAG is implemented as an incremental, tiered control loop with explicit retrieval gates and scoped vector search. The net effect is better cost predictability and cleaner retrieval behavior than unconstrained global-memory scanning.