Aiden Adds Context Pruning and Recoverable Agent Sessions

Major Update: We merged PR #609, PR #618, PR #608, PR #607, PR #622, PR #621, and PR #592. This coordinated runtime update strengthens AI agent context management by making active context, session persistence, and provider-driven continuation more explicit for long-running work. The code is merged into the open-source Aiden firmware repository; its verification scope is described below.

The problem we fixed

Long-running sessions can accumulate large tool results and state that is no longer useful for the next request. If all of that material remains active until general compaction begins, it consumes the Provider’s input budget and makes the current work compete with stale history.

Aiden can now evaluate historical tool results and expired state against the available input budget before compaction. Eligible historical content can be pruned while the current turn is retained, so the request you are actively working on stays in context. This is context pruning for AI agents, not a rule that removes the current turn or preserves every earlier detail indefinitely.

Pruning also has a clear boundary. The Provider remains responsible for general compression, while Aiden manages the session-level decision to remove eligible historical results and expired state. The context_prune_threshold setting is now a migratable input-budget ratio instead of a fixed token count. This makes the threshold relative to the Provider’s available budget and keeps the configuration portable as that budget changes.

Recoverable session lineage

The same merged work clarifies what Aiden persists and how a session continues after a Provider truncates context. Session events are now the persistence source. The unused historical mirror has been removed, reducing ambiguity about which record represents the durable session history.

When the Provider reports context truncation, Aiden can rotate the work into a child session. The new session records its parent-child lineage rather than appearing as unrelated work. If you inspect a continuation later, that relationship gives you a traceable explanation of how the active session followed the earlier one.

This structure supports persistent AI agent sessions without overstating the result. Recorded lineage does not guarantee that every detail from a previous context window can be reconstructed or that every interrupted task will resume identically. It establishes a durable session relationship and a defined continuation path when provider limits are reached.

Safer active-session updates

The active-session pointer now follows the same consistency model. Aiden updates .current_session through synchronized atomic replacement, avoiding exposure of a partially written pointer while the current-session reference changes.

Together, the responsibilities are easier to follow: session events provide persisted history, .current_session identifies the session to resume, and lineage records when a child session follows provider context truncation. You get a more explicit model for tracing long-running work across session boundaries and restarts.

The context-pruning implementation in this merged series was cross-built and deployed for verification on Luckfox hardware. That is a specific verification step, not a claim that the update has been deployed across every Aiden environment or behaves identically under every configuration.

One limitation remains documented: first-turn token-estimation accuracy after a restart is still a follow-up concern. The update improves session persistence and continuation, but it does not present restart token estimation as complete. You can review the linked pull requests for the implementation record and follow Aiden’s continued open-source development.