Track important changes in Agent Memory and Context Engineering, including capabilities, product updates, adoption signals, risks, and evidence worth continued monitoring.
google/adk-go PR #633 fixes a runtime correctness gap where `RunAgentRequest.StateDelta` on `/api/run` and `/api/runSSE` was parsed but never applied to session state, so subsequent agent runs could ignore caller-provided context updates. The fix centralizes a new `applyStateDeltaIfPresent` helper that writes a non-empty delta into the session before starting the run.
What Changedgoogle/adk-go PR #633 fixes a runtime correctness gap where `RunAgentRequest.StateDelta` on `/api/run` and `/api/runSSE` was parsed but never applied to session state, so subsequent agent runs could ignore caller-provided context updates. The fix centralizes a new `applyStateDeltaIfPresent` helper that writes a non-empty delta into the session before starting the run.
Why It MattersDevelopers using ADK REST run endpoints for resume/continuation flows now get runs that honor caller-supplied session updates, so resumed agents execute from the latest state instead of silently continuing with stale context and failing to reflect `stateDelta` input. This is implemented by persisting the delta as a state event before execution (with map copying to avoid shared-mutation bugs), so operators should monitor session-event append failures, event ordering under concurrent runs, and any client assumptions that depended on the previous no-op handling of `stateDelta`.
Final score 81Confidence 971 evidence item/api/run/api/runSSEstateDeltaRunAgentRequestsessionService.AppendEventEventActions.state_deltaapplyStateDeltaIfPresentRunSSEHandlerRunHandler
The PR introduces a new backfill pipeline so AgentMemory users can rebuild viewer graphs from previously stored memories/observations instead of being stuck on a 0 nodes / 0 edges screen, by adding a working `POST /agentmemory/graph/build` path and a resumable CLI apply flow that replaces the prior missing `/agentmemory/graph/build` behavior.
What ChangedThe PR introduces a new backfill pipeline so AgentMemory users can rebuild viewer graphs from previously stored memories/observations instead of being stuck on a 0 nodes / 0 edges screen, by adding a working `POST /agentmemory/graph/build` path and a resumable CLI apply flow that replaces the prior missing `/agentmemory/graph/build` behavior.
Why It MattersUsers and operators with existing AgentMemory histories can now recover a usable graph view from old data, so dashboards and downstream workflows no longer remain blocked by a permanently empty graph after invoking Rebuild Graph. The change provides a new `POST /agentmemory/graph/build` endpoint plus a dry-run/apply CLI, using resumable chunk processing and source-ID skip logic to avoid long-running requests while filling nodes/edges for historical data. Monitor chunk resume correctness, skipped-ID state, and duplicate-node edge remapping on large backfills, because failures there would either hide relationships or produce inconsistent graph structure despite the new workflow.
The PR adds an explicit `agentmemory connect codex` install path that writes lifecycle hooks into Codex’s config-layer (`~/.codex/hooks.json`) and prefers the installed Codex plugin cache for hook script paths, with a bundled-package fallback. It also deduplicates prior AgentMemory hook entries while preserving unrelated user hooks, fixing the case where users saw a connected plugin but no observations because hooks were installed without dispatch.
What ChangedThe PR adds an explicit `agentmemory connect codex` install path that writes lifecycle hooks into Codex’s config-layer (`~/.codex/hooks.json`) and prefers the installed Codex plugin cache for hook script paths, with a bundled-package fallback. It also deduplicates prior AgentMemory hook entries while preserving unrelated user hooks, fixing the case where users saw a connected plugin but no observations because hooks were installed without dispatch.
Why It MattersDevelopers using AgentMemory with Codex will see lifecycle observations actually captured from their regular Codex tool calls instead of an apparently installed plugin that produces no traces, so automatic context capture works again in current builds including on Windows. The change persists a config-layer hook entry in `~/.codex/hooks.json` with cache-first pathing and preserved user hooks, while using a fallback until upstream Codex hook discovery is available; teams should watch for regressions when Codex updates plugin-discovery behavior, because duplicate or dropped dispatches could reintroduce hidden data gaps.
The open PR changes the Viewer Memories tab to route search requests to the backend `/agentmemory/search` path for CJK input (and for longer Latin queries), replacing pure client-side `String.includes()` filtering for those cases.
What ChangedThe open PR changes the Viewer Memories tab to route search requests to the backend `/agentmemory/search` path for CJK input (and for longer Latin queries), replacing pure client-side `String.includes()` filtering for those cases.
Why It MattersPeople searching memories with Chinese/Japanese/Korean text in the Viewer can now get usable search results from true backend matching instead of brittle local substring filtering, and IME users are less likely to hit interrupted or incomplete searches while typing; this should improve practical search reliability in everyday usage. The new behavior depends on the backend search path, so operators should continue watching latency/availability of `/agentmemory/search`, correctness of CJK detection boundaries, and fallback transitions between backend and local mode to avoid silent false negatives.
The PR adds a new opt-in `CLAUDE_MEM_EXTERNAL_MEMORY_MODE=primary` path so key memory operations (save, search, timeline, stats, and project reads) are persisted and served from a shared Postgres + Valkey store as the primary source, while keeping default local SQLite behavior unchanged.
What ChangedThe PR adds a new opt-in `CLAUDE_MEM_EXTERNAL_MEMORY_MODE=primary` path so key memory operations (save, search, timeline, stats, and project reads) are persisted and served from a shared Postgres + Valkey store as the primary source, while keeping default local SQLite behavior unchanged.
Why It MattersTeams running claude-mem across multiple workers can now share recall state through one external memory path, so context lookup works consistently across instances instead of splitting across local SQLite files. Technical effect: the new primary mode makes selected memory surfaces authoritative in Postgres with Valkey-assisted caching (`source_sqlite_id = null`) and uses that path for worker/MCP search/timeline reads, which is directly intended for multi-process deployments. Track whether failure modes under Postgres/Valkey disruption, and whether the remaining SQLite-only session metadata introduces mixed-source behavior during mixed-mode operation.
Final score 80Confidence 941 evidence itemclaude-memPostgreSQLValkeyCLAUDE_MEM_EXTERNAL_MEMORY_MODECLAUDE_MEM_PG_URLSQLiteworker searchtimeline
The PR adds a shared environment reader with process-env precedence and `~/.agentmemory/.env` fallback, then wires it into hook Bearer authentication and CLI API calls so these clients use the same config path as the daemon.
What ChangedThe PR adds a shared environment reader with process-env precedence and `~/.agentmemory/.env` fallback, then wires it into hook Bearer authentication and CLI API calls so these clients use the same config path as the daemon.
Why It MattersDevelopers and operators running agentmemory hooks or CLI commands no longer get surprise authentication failures when their shell environment is not propagated, so session capture and consolidation flows are less likely to break silently. The change creates a single merged config path (`process env -> ~/.agentmemory/.env`) used by hooks and CLI requests (including status/demo/JSONL/import flows), reducing drift between daemon and client behavior; continue monitoring whether long-running hook processes pick up secret rotation safely and whether missing or malformed local `.env` files can introduce auth inconsistencies.
Release v0.9.20 reverts the v0.9.19 change that chained `session-end.mjs` from Codex `Stop`, because `Stop` can fire before a conversation is truly finished and later observations were being written under an `endedAt`-marked closed record. The hotfix restores `Stop` to summarize-only behavior and keeps the broader SessionEnd-based completion design open in issue #493.
What ChangedRelease v0.9.20 reverts the v0.9.19 change that chained `session-end.mjs` from Codex `Stop`, because `Stop` can fire before a conversation is truly finished and later observations were being written under an `endedAt`-marked closed record. The hotfix restores `Stop` to summarize-only behavior and keeps the broader SessionEnd-based completion design open in issue #493.
Why It MattersOperators and developers using agentmemory will no longer see conversations marked complete too early, so later assistant observations stay in the active session instead of being stored against a closed one, reducing lost-context incidents and postmortem confusion in production runs. The fix is a targeted rollback: `Stop` again performs summarize-only actions rather than invoking `session-end.mjs`, while the SessionEnd-oriented completion path remains unresolved and should be tracked via issue #493 to ensure real session boundaries are eventually handled without reintroducing early-close regressions.
Final score 79Confidence 981 evidence itemCodex Stopsession-end.mjsendedAtsession tracking
This change connects existing sidecar update helpers into the key tool-mode read/write paths so tool-mode curate and query operations now refresh runtime-signal metadata (update/access counts and recency) instead of leaving entries with empty or stale activity history.
What ChangedThis change connects existing sidecar update helpers into the key tool-mode read/write paths so tool-mode curate and query operations now refresh runtime-signal metadata (update/access counts and recency) instead of leaving entries with empty or stale activity history.
Why It MattersTool-mode users and operators in byterover-cli will get signal-driven ranking and decay behavior that matches real usage, so active topics are less likely to be treated as newly created or untouched and skipped by relevance logic. By updating sidecar metadata on curate writes and query reads through existing helpers, the PR closes a correctness gap where tool-mode projects lost real activity signals for candidates and ranking heuristics. Continue watching whether every deployment path passes a valid `runtimeSignalStore` and whether silent no-op behavior on missing/errored store operations masks monitoring blind spots, because that would reintroduce stale signal effects.
Final score 79Confidence 951 evidence itemruntime-signal sidecarbumpSidecarOnCurateWritebumpSidecarOnQueryReadSearchExecutorQueryExecutordaemon tool-mode curate pathruntimeSignalStore
Implemented per-thread workspace binding so a thread can be explicitly bound to a workspace while unbound threads inherit the parent chat workspace, preserving normal startup behavior and reducing cross-thread context leakage in grouped conversations.
What ChangedImplemented per-thread workspace binding so a thread can be explicitly bound to a workspace while unbound threads inherit the parent chat workspace, preserving normal startup behavior and reducing cross-thread context leakage in grouped conversations.
Why It MattersOperators and team members in Feishu/Lark threaded chats will see more predictable workspace context, because each thread can keep its own workspace assignment while threads without explicit binds automatically use the parent chat workspace instead of drifting unpredictably. Concretely, the new lookup order stores thread-level precedence and parent-level fallback, and convention-based auto-binds are recorded so sibling threads inherit consistently. Watch for rollout behavior on first-time `thread_isolation` enablement, especially whether `/workspace bind` is being used in heavily nested threads and whether Telegram forum topics inherit as intended in mixed-platform usage.
Final score 79Confidence 931 evidence itemthread_isolationworkspace bindingresolveWorkspacelookupEffectiveWorkspaceBindingFeishuLarkTelegram forum topics
Added a SessionStart hook that injects `_CLAUDE.md` into Claude context automatically when a session starts inside `OBSIDIAN_VAULT_PATH`, removing the previous per-command reload behavior and enabling setup-time wiring through `scripts/setup.sh`.
What ChangedAdded a SessionStart hook that injects `_CLAUDE.md` into Claude context automatically when a session starts inside `OBSIDIAN_VAULT_PATH`, removing the previous per-command reload behavior and enabling setup-time wiring through `scripts/setup.sh`.
Why It MattersVault users will see lower token usage and faster interactions because vault context is loaded once at session start instead of being re-read on every Claude command, while non-vault sessions remain unaffected. This change introduces a path-guarded startup hook entry in Claude settings; operators should monitor path-resolution behavior across Windows/POSIX environments and whether long-running sessions reflect later edits to `_CLAUDE.md` as expected.
Final score 78Confidence 951 evidence itemSessionStart hook_CLAUDE.mdhooks/load_vault_context.pyscripts/setup.shOBSIDIAN_VAULT_PATHClaude settings
Introduces a new `POST /agentmemory/graph/build` endpoint that enables rebuilding the knowledge graph from existing session observations and saved memories, with batched extraction and returned metrics for processed items, truncation, and errors.
What ChangedIntroduces a new `POST /agentmemory/graph/build` endpoint that enables rebuilding the knowledge graph from existing session observations and saved memories, with batched extraction and returned metrics for processed items, truncation, and errors.
Why It MattersOperators and developers can now regenerate a project’s knowledge graph via a single API call, which reduces manual recovery time when graph data is stale or broken after data changes. The endpoint runs through existing `mem::graph-extract` in batches and reports processing/truncation/error outcomes, so teams can identify how much was rebuilt and where extraction failed; continue watching batch size limits, repeated truncation rates, and whether large-session backfills stay stable under load.
This PR adds a `context.client` path from gateway requests into `runtime.context`, with a safe clipping helper and a hidden prompt reminder so agents can adapt responses to frontend capabilities and preferences (such as artifact, CSV download, charts, or plain-text-only output).
What ChangedThis PR adds a `context.client` path from gateway requests into `runtime.context`, with a safe clipping helper and a hidden prompt reminder so agents can adapt responses to frontend capabilities and preferences (such as artifact, CSV download, charts, or plain-text-only output).
Why It MattersCustom frontends and their operators can now get response formats that match their UI capabilities automatically (for example, showing artifacts/charts only where supported and falling back to plain text where needed), which reduces mismatched outputs and ad-hoc downstream formatting fixes. Technically, this is enabled by a new secure `context.client` clipping helper, typed client context definitions, gateway-to-runtime propagation, and dynamic context reminder injection; continue watching for schema drift between frontend payloads and runtime context, potential bypasses in sanitization, and whether all agents consistently consume the new context hints.
Final score 78Confidence 961 evidence itemcontext.clientruntime.contextgateway run requestagent dynamic contextclient capabilitiesclient preferencesartifact/csv_download/charts
The PR updates OpenClaw integration to derive a project/workspace context and pass it through both memory recall and capture paths, so shared deployments stop grouping observations in a global bucket when projects are mixed; if project metadata is missing, it safely falls back to session-level scoping.
What ChangedThe PR updates OpenClaw integration to derive a project/workspace context and pass it through both memory recall and capture paths, so shared deployments stop grouping observations in a global bucket when projects are mixed; if project metadata is missing, it safely falls back to session-level scoping.
Why It MattersShared agentmemory operators can prevent OpenClaw from leaking or mixing conversation memory across projects, which reduces incorrect context retrieval in multi-project deployments and lowers the chance of one project seeing another project’s past turns. Concretely, recall now carries a derived project/workspace signal into smart-search and observe records now persist project/cwd fields for consistent session grouping, with tests added to guard this behavior; continue watching whether event metadata remains consistent in all clients, and whether fallback-to-session-id paths are triggering frequently (which would indicate remaining scoping blind spots).
Final score 77Confidence 911 evidence itemOpenClawagentmemorybefore_agent_startagent_endsmart-searchobserveprojectcwdsession id
PR #4879 introduces a new Comet integration that creates a runnable browser automation orchestrator backed by Gemini 2.5 Pro within browser-use. The change bundles screenshot-based capabilities (vision, element finding, CAPTCHA detection, OCR), two-level memory (RAM + chromadb), and Windows Chrome profile persistence into one workflow path.
What ChangedPR #4879 introduces a new Comet integration that creates a runnable browser automation orchestrator backed by Gemini 2.5 Pro within browser-use. The change bundles screenshot-based capabilities (vision, element finding, CAPTCHA detection, OCR), two-level memory (RAM + chromadb), and Windows Chrome profile persistence into one workflow path.
Why It MattersWeb automation operators can run a unified agent that understands screenshots and can reuse logged-in Chrome profiles, reducing setup friction and repeated authentication interruptions in day-to-day scripted browsing tasks while preserving context across turns. This is achieved through a new orchestrator that combines browser-use with `langchain-google-genai`/`google-generativeai` and memory backends, so teams should monitor whether vision-driven actions produce false positives, whether Windows-only session persistence works reliably in their deployment paths, and whether Gemini/captcha credential misconfiguration causes session stalls.
Final score 77Confidence 911 evidence itembrowser-useCometGemini 2.5 Prolangchain-google-genaigoogle-generativeaichromadbPlaywrightWindows Chrome profile
Introduces a new `pre-compact` lifecycle hook in claude-mem that captures a structured session summary before context compaction and restores it on the next `SessionStart`, so long-running Claude Code sessions retain prior decisions after window resets.
What ChangedIntroduces a new `pre-compact` lifecycle hook in claude-mem that captures a structured session summary before context compaction and restores it on the next `SessionStart`, so long-running Claude Code sessions retain prior decisions after window resets.
Why It MattersDevelopers using Claude Code sessions will keep key context (decisions, findings, and state) across compaction resets, reducing session continuity breaks and manual context recovery after context window overflow. This is implemented by executing summary generation in the pre-compact path and replaying it via context injection on the next session start, so follow-up prompts can continue from the right state. Watch whether summary generation ever misses edge cases (large sessions, provider-specific routing, or skipped hook execution) because those cases would reintroduce context loss.
Final score 77Confidence 961 evidence itemPreCompact hooksession_summariesSessionManager.queuePreCompact/api/sessions/pre-compactSessionStartCLAUDE_MEM_PRECOMPACT_ENABLED
The PR extends Cognee’s `remember` endpoint with an optional `content_type` field so callers can explicitly specify the type of content being memorized, reducing reliance on implicit behavior during memory operations.
What ChangedThe PR extends Cognee’s `remember` endpoint with an optional `content_type` field so callers can explicitly specify the type of content being memorized, reducing reliance on implicit behavior during memory operations.
Why It MattersDevelopers and service operators using the `remember` API can now pass explicit content-type context with memory writes, so integrations handling mixed data formats can reduce ambiguous payload handling and integration errors. Watch for compatibility of existing clients that omit `content_type`, how invalid values are validated, and whether error responses remain actionable enough for callers.
Final score 76Confidence 901 evidence itemremember endpointcontent_typeAPI form parametersmemory operations
In v0.9.19, graph retrieval in AgentMemory was changed from BFS to weighted Dijkstra search so query paths are ranked by edge strength rather than hop count alone. The update preserves existing depth limiting while changing path selection logic to prefer more semantically meaningful, higher-confidence memory routes.
What ChangedIn v0.9.19, graph retrieval in AgentMemory was changed from BFS to weighted Dijkstra search so query paths are ranked by edge strength rather than hop count alone. The update preserves existing depth limiting while changing path selection logic to prefer more semantically meaningful, higher-confidence memory routes.
Why It MattersDevelopers and operators using AgentMemory search will get context retrieval that follows stronger memory links instead of the first few hops, which should reduce weak or irrelevant context being surfaced during agent workflows and improve downstream answer quality. Under the hood, the min-heap Dijkstra flow also replaces the prior BFS `Array.shift()`/O(V·E) behavior, but teams should monitor for ranking drift on shallow-depth queries and watch latency/memory characteristics on dense graphs to catch any path-quality or performance regressions.
Final score 76Confidence 951 evidence itemAgentMemorygraph retrievalDijkstraweighted edge graphsearchByEntitiesmaxDepth
This change updates standalone MCP `memory_recall` proxying to call `/agentmemory/search` instead of `/agentmemory/smart-search`, and forwards `format` and `token_budget` so `full`, `compact`, and `narrative` recall modes behave as specified; local fallback recall responses are aligned to search-style behavior while `memory_smart_search` compact mode is kept as-is.
What ChangedThis change updates standalone MCP `memory_recall` proxying to call `/agentmemory/search` instead of `/agentmemory/smart-search`, and forwards `format` and `token_budget` so `full`, `compact`, and `narrative` recall modes behave as specified; local fallback recall responses are aligned to search-style behavior while `memory_smart_search` compact mode is kept as-is.
Why It MattersDevelopers using standalone `memory_recall` integrations should now get predictable recall output styles and token-limited responses instead of unexpected smart-search-formatted behavior, which should reduce client-side formatting work and recall-mode breakage; watch whether older clients depending on the former route still assume `/agentmemory/smart-search` and whether narrative-mode formatting remains stable after the routing change. Technically, this reroutes proxy calls to `/agentmemory/search`, adds passthrough of mode and budget parameters, and aligns local fallback responses to search-style results while preserving `memory_smart_search` compact behavior.
Final score 75Confidence 951 evidence itemMCPmemory_recallmemory_smart_searchagentmemory/searchagentmemory/smart-searchformattoken_budgetfull/compact/narrative modes
The PR adds a new opt-in `CLAUDE_MEM_EXTERNAL_MEMORY_MODE=primary` path so key memory operations (save, search, timeline, stats, and project reads) are persisted and served from a shared Postgres + Valkey store as the primary source, while keeping default local SQLite behavior unchanged.
ContributionImplemented a production-oriented external-memory switch to Postgres-as-primary: when enabled, claude-mem writes observations, summaries, and manual memory saves directly to Postgres, caches via Valkey, and hydrates worker HTTP/MCP search and timeline from that path instead of relying on local SQLite as the recall source.
ImpactTeams running claude-mem across multiple workers can now share recall state through one external memory path, so context lookup works consistently across instances instead of splitting across local SQLite files. Technical effect: the new primary mode makes selected memory surfaces authoritative in Postgres with Valkey-assisted caching (`source_sqlite_id = null`) and uses that path for worker/MCP search/timeline reads, which is directly intended for multi-process deployments. Track whether failure modes under Postgres/Valkey disruption, and whether the remaining SQLite-only session metadata introduces mixed-source behavior during mixed-mode operation.
The PR updates OpenClaw integration to derive a project/workspace context and pass it through both memory recall and capture paths, so shared deployments stop grouping observations in a global bucket when projects are mixed; if project metadata is missing, it safely falls back to session-level scoping.
ContributionImplemented context-aware scoping for OpenClaw memory flow by deriving a project value in the start hook, attaching it to recall requests, and adding `project`/`cwd` to observe payloads; also added fallback-to-session-id behavior when project metadata is absent and regression tests for recall/capture scoping.
ImpactShared agentmemory operators can prevent OpenClaw from leaking or mixing conversation memory across projects, which reduces incorrect context retrieval in multi-project deployments and lowers the chance of one project seeing another project’s past turns. Concretely, recall now carries a derived project/workspace signal into smart-search and observe records now persist project/cwd fields for consistent session grouping, with tests added to guard this behavior; continue watching whether event metadata remains consistent in all clients, and whether fallback-to-session-id paths are triggering frequently (which would indicate remaining scoping blind spots).
PR #4879 introduces a new Comet integration that creates a runnable browser automation orchestrator backed by Gemini 2.5 Pro within browser-use. The change bundles screenshot-based capabilities (vision, element finding, CAPTCHA detection, OCR), two-level memory (RAM + chromadb), and Windows Chrome profile persistence into one workflow path.
ContributionImplemented the core Comet orchestration path in `comet/main.py` so users can run a Gemini-backed web agent directly, with integrated multimodal page understanding and session memory instead of separate manual glue for vision, navigation, and context handling.
ImpactWeb automation operators can run a unified agent that understands screenshots and can reuse logged-in Chrome profiles, reducing setup friction and repeated authentication interruptions in day-to-day scripted browsing tasks while preserving context across turns. This is achieved through a new orchestrator that combines browser-use with `langchain-google-genai`/`google-generativeai` and memory backends, so teams should monitor whether vision-driven actions produce false positives, whether Windows-only session persistence works reliably in their deployment paths, and whether Gemini/captcha credential misconfiguration causes session stalls.
This PR adds a `context.client` path from gateway requests into `runtime.context`, with a safe clipping helper and a hidden prompt reminder so agents can adapt responses to frontend capabilities and preferences (such as artifact, CSV download, charts, or plain-text-only output).
ContributionImplemented end-to-end client-aware context flow: sanitize and clip incoming `context.client`, forward it through the gateway into `runtime.context`, and inject it into agent prompt context so downstream agents can make client-specific output decisions.
ImpactCustom frontends and their operators can now get response formats that match their UI capabilities automatically (for example, showing artifacts/charts only where supported and falling back to plain text where needed), which reduces mismatched outputs and ad-hoc downstream formatting fixes. Technically, this is enabled by a new secure `context.client` clipping helper, typed client context definitions, gateway-to-runtime propagation, and dynamic context reminder injection; continue watching for schema drift between frontend payloads and runtime context, potential bypasses in sanitization, and whether all agents consistently consume the new context hints.
The PR introduces a new backfill pipeline so AgentMemory users can rebuild viewer graphs from previously stored memories/observations instead of being stuck on a 0 nodes / 0 edges screen, by adding a working `POST /agentmemory/graph/build` path and a resumable CLI apply flow that replaces the prior missing `/agentmemory/graph/build` behavior.
ContributionAdded a concrete graph backfill capability for historical data: stored observations and memories can now be planned and applied into graph records through a real API endpoint and CLI, with dry-run preview, resumable chunked writes, and updated duplicate-aware merge behavior for extracted edges.
ImpactUsers and operators with existing AgentMemory histories can now recover a usable graph view from old data, so dashboards and downstream workflows no longer remain blocked by a permanently empty graph after invoking Rebuild Graph. The change provides a new `POST /agentmemory/graph/build` endpoint plus a dry-run/apply CLI, using resumable chunk processing and source-ID skip logic to avoid long-running requests while filling nodes/edges for historical data. Monitor chunk resume correctness, skipped-ID state, and duplicate-node edge remapping on large backfills, because failures there would either hide relationships or produce inconsistent graph structure despite the new workflow.
Added a SessionStart hook that injects `_CLAUDE.md` into Claude context automatically when a session starts inside `OBSIDIAN_VAULT_PATH`, removing the previous per-command reload behavior and enabling setup-time wiring through `scripts/setup.sh`.
ContributionImplemented startup-time vault-context injection: when the current working directory is inside `OBSIDIAN_VAULT_PATH`, `_CLAUDE.md` is loaded into Claude at session launch, and setup now registers the hook automatically (coexisting with PostCompact), so operators no longer need per-command context reload handling.
ImpactVault users will see lower token usage and faster interactions because vault context is loaded once at session start instead of being re-read on every Claude command, while non-vault sessions remain unaffected. This change introduces a path-guarded startup hook entry in Claude settings; operators should monitor path-resolution behavior across Windows/POSIX environments and whether long-running sessions reflect later edits to `_CLAUDE.md` as expected.
LangChain introduced interpreter support in Deep Agents, adding small embedded runtimes that let agents execute code between tool calls to coordinate actions, retain working state, and control which context is forwarded to the model.
ContributionImplemented a concrete new capability: interpreter-backed execution inside Deep Agents. This enables code-driven orchestration logic, persistent intermediate state handling, and explicit context selection across steps rather than relying only on static prompting.
ImpactDevelopers of multi-step AI workflows can keep agent behavior more reliable and easier to manage because agents can now handle tool sequencing, state transitions, and context trimming through an embedded interpreter instead of manual glue logic, reducing brittle orchestration bugs. You should watch for interpreter sandbox security, state consistency across long runs, and per-step runtime overhead, since those factors determine whether this flexibility improves production reliability or introduces new failure/latency risks as workloads scale.
Introduces a new `pre-compact` lifecycle hook in claude-mem that captures a structured session summary before context compaction and restores it on the next `SessionStart`, so long-running Claude Code sessions retain prior decisions after window resets.
ContributionAdded an explicit pre-compaction workflow: register a `pre-compact` hook and route, queue and generate a summary through the existing summarize pipeline before compaction, persist it, then inject the latest summary on the next session start; includes opt-in control via `CLAUDE_MEM_PRECOMPACT_ENABLED`.
ImpactDevelopers using Claude Code sessions will keep key context (decisions, findings, and state) across compaction resets, reducing session continuity breaks and manual context recovery after context window overflow. This is implemented by executing summary generation in the pre-compact path and replaying it via context injection on the next session start, so follow-up prompts can continue from the right state. Watch whether summary generation ever misses edge cases (large sessions, provider-specific routing, or skipped hook execution) because those cases would reintroduce context loss.
This change connects existing sidecar update helpers into the key tool-mode read/write paths so tool-mode curate and query operations now refresh runtime-signal metadata (update/access counts and recency) instead of leaving entries with empty or stale activity history.
ContributionAdded and connected call sites for existing sidecar helpers in all primary tool-mode curate/query touchpoints, ensuring write paths bump `updateCount`/`recency` and read paths bump `accessCount` when a runtime signal store is present.
ImpactTool-mode users and operators in byterover-cli will get signal-driven ranking and decay behavior that matches real usage, so active topics are less likely to be treated as newly created or untouched and skipped by relevance logic. By updating sidecar metadata on curate writes and query reads through existing helpers, the PR closes a correctness gap where tool-mode projects lost real activity signals for candidates and ranking heuristics. Continue watching whether every deployment path passes a valid `runtimeSignalStore` and whether silent no-op behavior on missing/errored store operations masks monitoring blind spots, because that would reintroduce stale signal effects.
The PR adds an explicit `agentmemory connect codex` install path that writes lifecycle hooks into Codex’s config-layer (`~/.codex/hooks.json`) and prefers the installed Codex plugin cache for hook script paths, with a bundled-package fallback. It also deduplicates prior AgentMemory hook entries while preserving unrelated user hooks, fixing the case where users saw a connected plugin but no observations because hooks were installed without dispatch.
ContributionImplemented a concrete fix to `agentmemory connect codex` so it installs dispatchable Codex config-layer lifecycle hooks, resolves hook script paths from the installed plugin cache first (with a fallback), deduplicates previous AgentMemory hook entries, and supports Windows, preventing silent non-execution after install.
ImpactDevelopers using AgentMemory with Codex will see lifecycle observations actually captured from their regular Codex tool calls instead of an apparently installed plugin that produces no traces, so automatic context capture works again in current builds including on Windows. The change persists a config-layer hook entry in `~/.codex/hooks.json` with cache-first pathing and preserved user hooks, while using a fallback until upstream Codex hook discovery is available; teams should watch for regressions when Codex updates plugin-discovery behavior, because duplicate or dropped dispatches could reintroduce hidden data gaps.
The open PR changes the Viewer Memories tab to route search requests to the backend `/agentmemory/search` path for CJK input (and for longer Latin queries), replacing pure client-side `String.includes()` filtering for those cases.
ContributionIntroduced backend-powered search routing for memory lookup: queries containing CJK characters are automatically sent to `/agentmemory/search` (BM25 + vector), Latin queries of length 3+ are also routed to backend, IME `compositionstart`/`compositionend` handling is added to prevent interrupted input, and local filtering is used as a fallback on backend failure.
ImpactPeople searching memories with Chinese/Japanese/Korean text in the Viewer can now get usable search results from true backend matching instead of brittle local substring filtering, and IME users are less likely to hit interrupted or incomplete searches while typing; this should improve practical search reliability in everyday usage. The new behavior depends on the backend search path, so operators should continue watching latency/availability of `/agentmemory/search`, correctness of CJK detection boundaries, and fallback transitions between backend and local mode to avoid silent false negatives.
A watcher reliability bug was fixed by changing firstLine() to sanitize truncated strings to valid UTF-8 before publishing watcher_events.subject. When a multi-byte character is clipped at the byte boundary, the function now removes trailing bytes until utf8.ValidString succeeds, preventing malformed subjects from reaching downstream consumers.
ContributionIntroduced UTF-8 boundary correction in the watcher message parser: after byte-length truncation, firstLine() now trims trailing bytes (up to 3 bytes) until the remaining string is valid UTF-8. This directly replaces a silent corruption path with a safe fallback and is backed by tests for Cyrillic, em dash, emoji boundary cuts, ASCII baseline behavior, and newline handling.
ImpactOperators and integrations that consume watcher rows (including the Slack-to-conductor bridge) will avoid pipeline stalls caused by a single malformed Unicode row, so message processing can continue instead of repeatedly failing on the same event. The change resolves a correctness regression where truncated multibyte characters produced invalid payloads and triggered SQLite/JSON failures, so the immediate follow-up to watch is whether other entry points still emit invalid event subjects or malformed Unicode before downstream consumers.
The PR adds a shared environment reader with process-env precedence and `~/.agentmemory/.env` fallback, then wires it into hook Bearer authentication and CLI API calls so these clients use the same config path as the daemon.
ContributionIntroduced a centralized env-resolution layer that prioritizes process environment variables and falls back to the agentmemory env file, then reused this merged source for hook auth headers, context-injection behavior, and CLI request paths, replacing duplicated env handling.
ImpactDevelopers and operators running agentmemory hooks or CLI commands no longer get surprise authentication failures when their shell environment is not propagated, so session capture and consolidation flows are less likely to break silently. The change creates a single merged config path (`process env -> ~/.agentmemory/.env`) used by hooks and CLI requests (including status/demo/JSONL/import flows), reducing drift between daemon and client behavior; continue monitoring whether long-running hook processes pick up secret rotation safely and whether missing or malformed local `.env` files can introduce auth inconsistencies.
Introduces a new `POST /agentmemory/graph/build` endpoint that enables rebuilding the knowledge graph from existing session observations and saved memories, with batched extraction and returned metrics for processed items, truncation, and errors.
ContributionAdded a concrete API operation for graph backfill and rebuild that lets users trigger graph extraction over historical session/memory data without writing custom tooling, while exposing per-run counts, truncation totals, and extraction error details.
ImpactOperators and developers can now regenerate a project’s knowledge graph via a single API call, which reduces manual recovery time when graph data is stale or broken after data changes. The endpoint runs through existing `mem::graph-extract` in batches and reports processing/truncation/error outcomes, so teams can identify how much was rebuilt and where extraction failed; continue watching batch size limits, repeated truncation rates, and whether large-session backfills stay stable under load.
google/adk-go PR #633 fixes a runtime correctness gap where `RunAgentRequest.StateDelta` on `/api/run` and `/api/runSSE` was parsed but never applied to session state, so subsequent agent runs could ignore caller-provided context updates. The fix centralizes a new `applyStateDeltaIfPresent` helper that writes a non-empty delta into the session before starting the run.
ContributionIntroduced a shared `applyStateDeltaIfPresent` path used by both `RunHandler` and `RunSSEHandler` that checks for a non-nil/non-empty `stateDelta`, shallow-copies it, appends it via `sessionService.AppendEvent`, and ensures execution proceeds against the updated session state.
ImpactDevelopers using ADK REST run endpoints for resume/continuation flows now get runs that honor caller-supplied session updates, so resumed agents execute from the latest state instead of silently continuing with stale context and failing to reflect `stateDelta` input. This is implemented by persisting the delta as a state event before execution (with map copying to avoid shared-mutation bugs), so operators should monitor session-event append failures, event ordering under concurrent runs, and any client assumptions that depended on the previous no-op handling of `stateDelta`.
This change updates standalone MCP `memory_recall` proxying to call `/agentmemory/search` instead of `/agentmemory/smart-search`, and forwards `format` and `token_budget` so `full`, `compact`, and `narrative` recall modes behave as specified; local fallback recall responses are aligned to search-style behavior while `memory_smart_search` compact mode is kept as-is.
ContributionFixed the `memory_recall` call path by switching standalone MCP proxy routing to the search endpoint and explicitly passing `format` and `token_budget`, which corrects output-mode behavior and budget handling for recalled results.
ImpactDevelopers using standalone `memory_recall` integrations should now get predictable recall output styles and token-limited responses instead of unexpected smart-search-formatted behavior, which should reduce client-side formatting work and recall-mode breakage; watch whether older clients depending on the former route still assume `/agentmemory/smart-search` and whether narrative-mode formatting remains stable after the routing change. Technically, this reroutes proxy calls to `/agentmemory/search`, adds passthrough of mode and budget parameters, and aligns local fallback responses to search-style results while preserving `memory_smart_search` compact behavior.
Implemented per-thread workspace binding so a thread can be explicitly bound to a workspace while unbound threads inherit the parent chat workspace, preserving normal startup behavior and reducing cross-thread context leakage in grouped conversations.
ContributionAdded thread-aware workspace resolution in core routing so explicit thread bindings shadow parent chat bindings, with fallback traversal to parent scope when a thread has no bind, and updated Feishu dispatch/message handling to pass the correct thread-bound channel key so existing `feishu:chatID` behavior remains compatible.
ImpactOperators and team members in Feishu/Lark threaded chats will see more predictable workspace context, because each thread can keep its own workspace assignment while threads without explicit binds automatically use the parent chat workspace instead of drifting unpredictably. Concretely, the new lookup order stores thread-level precedence and parent-level fallback, and convention-based auto-binds are recorded so sibling threads inherit consistently. Watch for rollout behavior on first-time `thread_isolation` enablement, especially whether `/workspace bind` is being used in heavily nested threads and whether Telegram forum topics inherit as intended in mixed-platform usage.
In v0.9.20, agentmemory removed the v0.9.19 regression that chained `session-end.mjs` after `stop.mjs` for Codex. The release notes indicate Codex emits Stop callbacks repeatedly within one conversation, so that chain was marking sessions completed too early and dropping later observations.
ContributionRolled back the Codex hook sequence so `stop` no longer triggers `session-end`, restoring the stop path to summarize-only behavior and preventing session state from being set to completed on intermediate stop events.
ImpactCodex users and operators should see fewer truncated session logs in active conversations, because repeated stop signals will no longer close sessions prematurely and suppress later observations. This directly affects memory completeness for multi-turn runs where outputs keep arriving after each assistant turn; next, watch whether the planned one-shot terminate event (#493) is adopted and that no other handler path reintroduces early completion semantics.
The PR extends Cognee’s `remember` endpoint with an optional `content_type` field so callers can explicitly specify the type of content being memorized, reducing reliance on implicit behavior during memory operations.
ContributionImplements optional `content_type` support on the `remember` API and clarifies optional parameter annotation behavior in the API documentation, enabling typed memory requests without adding required input changes.
ImpactDevelopers and service operators using the `remember` API can now pass explicit content-type context with memory writes, so integrations handling mixed data formats can reduce ambiguous payload handling and integration errors. Watch for compatibility of existing clients that omit `content_type`, how invalid values are validated, and whether error responses remain actionable enough for callers.
Release v0.9.20 reverts the v0.9.19 change that chained `session-end.mjs` from Codex `Stop`, because `Stop` can fire before a conversation is truly finished and later observations were being written under an `endedAt`-marked closed record. The hotfix restores `Stop` to summarize-only behavior and keeps the broader SessionEnd-based completion design open in issue #493.
ContributionRolled back the v0.9.19 behavior where Codex `Stop` triggered the session-end chain, eliminating premature session completion and ensuring late observations are no longer attached to already-ended session records.
ImpactOperators and developers using agentmemory will no longer see conversations marked complete too early, so later assistant observations stay in the active session instead of being stored against a closed one, reducing lost-context incidents and postmortem confusion in production runs. The fix is a targeted rollback: `Stop` again performs summarize-only actions rather than invoking `session-end.mjs`, while the SessionEnd-oriented completion path remains unresolved and should be tracked via issue #493 to ensure real session boundaries are eventually handled without reintroducing early-close regressions.
Release pi-v0.1.7 updates the Pi plugin to keep `mem_session_summary` working when automatic project discovery fails by accepting an explicit `project` fallback and using the nearest local `.engram/config.json` when older Engram servers do not support `/project/current`.
ContributionIntroduces explicit project fallback logic for Pi’s `mem_session_summary` path and a local-config fallback when project auto-detection or `/project/current` is unavailable, plus clearer version-mismatch messaging for 404 responses.
ImpactTeams running Pi workflows on mixed or older Engram server versions can continue using context summaries with fewer failures, because missing auto-detected project metadata no longer blocks command flow and operators get clearer errors when version or endpoint mismatch occurs. The change should reduce manual intervention in setups where `/project/current` is not available, while operators should watch for fallback correctness in multi-project trees and verify that the nearest local `.engram/config.json` does not silently point to the wrong project.
In v0.9.19, graph retrieval in AgentMemory was changed from BFS to weighted Dijkstra search so query paths are ranked by edge strength rather than hop count alone. The update preserves existing depth limiting while changing path selection logic to prefer more semantically meaningful, higher-confidence memory routes.
ContributionReplaced BFS path selection in memory graph search with a weighted shortest-path implementation using Dijkstra and min-heap ordering. Edges now carry weights (0.1–1.0), the traversal cost is `1/max(weight, 0.01)`, and the `startNode` is excluded from returned paths so the existing `score=1.0` fallback behavior in `searchByEntities` remains intact.
ImpactDevelopers and operators using AgentMemory search will get context retrieval that follows stronger memory links instead of the first few hops, which should reduce weak or irrelevant context being surfaced during agent workflows and improve downstream answer quality. Under the hood, the min-heap Dijkstra flow also replaces the prior BFS `Array.shift()`/O(V·E) behavior, but teams should monitor for ranking drift on shallow-depth queries and watch latency/memory characteristics on dense graphs to catch any path-quality or performance regressions.
v0.9.18 adds a pre-transport redaction step in the filesystem watcher preview path that replaces PEM private-key blocks and standalone JWT-like tokens with redacted placeholders, preventing raw credential material from being sent through preview output.
ContributionThe update introduced concrete secret-scrubbing behavior in the watcher flow: a state-machine pass now rewrites PEM key blocks (including multiple key formats) and masks standalone JWT-shaped strings to a safe placeholder before any transport write, directly closing a credential-exposure path in preview previews.
ImpactOperators and developers consuming filesystem watcher previews are less likely to leak private credentials through shared logs or transport channels, which lowers accidental secret exposure risk when monitored files contain keys or tokens; continue tracking whether sanitized previews reduce incident response visibility and whether any non-secret token-like strings are being over-redacted. The redaction now runs inside the preview pipeline itself, so the first line of defense is shifted closer to the source before downstream emitters receive data, and teams should still audit other output paths for similar leaks.
Release [email protected] introduces a user prompt when enabling workspace sandbox trust, so trust decisions become explicit instead of implicit.
ContributionAdds an interactive confirmation step to the workspace trust flow, requiring users to explicitly accept trust before proceeding, which changes trust handling from implicit behavior to explicit operator consent.
ImpactDevelopers running grok-cli now see a trust confirmation before a workspace is marked as trusted, which helps them avoid unintentionally granting sandbox permissions to untrusted or risky projects and reduces the chance of accidental local-context exposure during workflow execution; watch for how this affects non-interactive scripts. The underlying change is a new CLI prompt in the sandbox trust path, so teams should monitor whether automation/CI pipelines can still proceed cleanly, whether default trust state is preserved safely, and whether any CLI paths bypass the prompt unexpectedly.
Release v1.15.13 introduces native memory tooling in the pi module (feat commit 6976950516524d41a007bccc0e3f23baaaddefa4), shifting memory handling into core Engram instead of relying on external memory integrations.
ContributionAdded built-in memory tools to Engram’s pi path, enabling core memory operations to be handled natively in-engine and reducing the need for external memory-layer plugins.
ImpactDevelopers building on Engram can now implement and use memory features directly through the release’s new native pi tools, which should simplify integration and reduce engineering overhead when adding persistent memory behavior to applications. Watch for how the new APIs behave with existing workflows, especially around API compatibility, persistence semantics, and error handling under high memory-operation throughput, since incorrect assumptions here could still cause regressions after migration.