{"id":105185,"date":"2026-07-18T19:29:57","date_gmt":"2026-07-18T19:29:57","guid":{"rendered":"https:\/\/youzum.net\/google-clouds-always-on-memory-agent-replaces-rag-and-embeddings-with-continuous-llm-consolidation-on-gemini-3-1-flash-lite\/"},"modified":"2026-07-18T19:29:57","modified_gmt":"2026-07-18T19:29:57","slug":"google-clouds-always-on-memory-agent-replaces-rag-and-embeddings-with-continuous-llm-consolidation-on-gemini-3-1-flash-lite","status":"publish","type":"post","link":"https:\/\/youzum.net\/de\/google-clouds-always-on-memory-agent-replaces-rag-and-embeddings-with-continuous-llm-consolidation-on-gemini-3-1-flash-lite\/","title":{"rendered":"Google Cloud\u2019s Always-On Memory Agent Replaces RAG and Embeddings With Continuous LLM Consolidation on Gemini 3.1 Flash-Lite"},"content":{"rendered":"

Most AI agents forget. They process a request, answer it, then drop the context. Google Cloud\u2019s generative-ai<\/code> repository now ships a sample that tackles this directly. It is the Always-On Memory Agent<\/strong><\/a>, a reference implementation that treats memory as a running process.<\/p>\n

Always-On Memory Agent<\/strong><\/h2>\n

Fundamentally, the project is a lightweight background agent that never stops. It runs 24\/7 as a continuous process, not a one-shot call. It is built with Google ADK<\/strong> (Agent Development Kit) and Gemini 3.1 Flash-Lite<\/strong>. Notably, it uses no vector database and no embeddings. Instead, an LLM reads, thinks, and writes structured memory into SQLite<\/strong>. The model choice targets low latency and low cost for continuous background work.<\/p>\n

How It Works: Ingest, Consolidate, Query<\/strong><\/h2>\n

Architecturally, an orchestrator routes every request to one of three specialist sub-agents. Each sub-agent owns its own tools for reading or writing the memory store.<\/p>\n

First, the IngestAgent<\/strong> handles incoming content. It uses Gemini\u2019s multimodal capabilities to extract a summary, entities, topics, and an importance score. That structured record then lands in the memories<\/code> table.<\/p>\n

Next, the ConsolidateAgent<\/strong> runs on a timer, every 30 minutes by default. Like sleep cycles, it reviews unconsolidated memories and finds connections between them. Then it writes a synthesized summary, one key insight, and those connections to the database. Consequently, the agent builds new understanding while idle, with no prompt.<\/p>\n

Finally, the QueryAgent<\/strong> answers questions. It reads all memories and consolidation insights, then synthesizes a response. Importantly, it cites the memory IDs it used as sources.<\/p>\n

<\/p>\n

\n“, src:”report.pdf”, sm:”Anthropic reports 62% of Claude usage is code-related.”,
\n ent:[“Anthropic”,”Claude”,”AI agents”], tp:[“AI”,”code generation”], imp:0.8},
\n {icon:”\"\ud83d\uddbc\"“, src:”roadmap.png”, sm:”Q1 priority: reduce inference costs by 40%.”,
\n ent:[“Q1″,”inference”], tp:[“cost”,”planning”], imp:0.7},
\n {icon:”\"\ud83c\udf99\"“, src:”standup.mp3″, sm:”AI agents grow fast, but reliability is still a challenge.”,
\n ent:[“AI agents”,”reliability”], tp:[“agents”,”reliability”], imp:0.75},
\n {icon:”\"\ud83d\udcdd\"“, src:”idea.txt”, sm:”Smart inbox idea: persistent AI memory for email.”,
\n ent:[“smart inbox”,”email”], tp:[“product”,”memory”], imp:0.6}
\n ];
\n var CONS = {
\n links:[[1,3],[2,1],[3,4]],
\n insight:”The bottleneck for next-gen AI tools is the transition from static RAG to dynamic memory systems.”
\n };
\n var Q = “What should I focus on?”;
\n var A = ‘Based on your memories, prioritize: ship the cost-reduction plan <span class="”ref”">[Memory 2]<\/span>, ‘ +
\n ‘then close the agent reliability gap <span class="”ref”">[Memory 3]<\/span>. ‘ +
\n ‘The smart inbox concept <span class="”ref”">[Memory 4]<\/span> validates demand for persistent AI memory.’;\n

var i=0, consolidated=false;
\n var $=function(id){return document.getElementById(id)};
\n var store=$(“store”), pkt=$(“pkt”), logEl=$(“log”);<\/p>\n

function post(){ try{ parent.postMessage({type:”aoma-resize”,height:document.body.offsetHeight+40},”*”); }catch(e){} }
\n function log(html){ logEl.innerHTML=html; post(); }
\n function activate(el,cls){ [ “sIngest”,”sCons”,”sQuery” ].forEach(function(id){ $(id).classList.remove(“active”,”cons”,”query”); });
\n if(el){ el.classList.add(“active”); if(cls) el.classList.add(cls); } }<\/p>\n

function packet(color){ pkt.style.background=color; pkt.style.opacity=”1″; pkt.style.left=”0″;
\n setTimeout(function(){ pkt.style.left=”calc(100% – 10px)”; },30);
\n setTimeout(function(){ pkt.style.opacity=”0″; },950); }<\/p>\n

function ingest(){
\n if(i>=SAMPLES.length){ log(“<b>Inbox empty.<\/b> All 4 sample files ingested — now consolidate or query.”); return; }
\n var s=SAMPLES[i]; var id=i+1;
\n activate($(“sIngest”)); packet(“#4285F4”);
\n log(‘<b>IngestAgent<\/b> reads <b>’+s.icon+’ ‘+s.src+'<\/b> → extracting summary, entities, topics, importance…’);
\n var c=document.createElement(“div”); c.className=”card”; c.id=”card”+id;
\n c.innerHTML='<span class="”cid”">#’+id+'<\/span><div class="”sm”">’+s.sm+'<\/div>’+
\n ‘<div class="”chips”">’+s.ent.map(function(e){return ‘<span class="”chip”">’+e+'<\/span>’}).join(“”)+'<\/div>’+
\n ‘<div class="”chips”">’+s.tp.map(function(t){return ‘<span class="”chip" tp”>’+t+'<\/span>’}).join(“”)+'<\/div>’+
\n ‘<div class="”imp”">importance <b>’+s.imp+'<\/b><\/div>’;
\n store.appendChild(c); post();
\n setTimeout(function(){ c.classList.add(“show”); post();
\n log(‘<b>Stored memory #’+id+'<\/b> in SQLite. ‘+(SAMPLES.length-id)+’ file(s) left in inbox.’); },500);
\n i++;
\n if(i>=2){ $(“bCons”).disabled=false; $(“bQuery”).disabled=false; }
\n }<\/p>\n

function consolidate(){
\n if(i<2){ log(“Ingest at least 2 memories first.”); return; }
\n activate($(“sCons”),”cons”); packet(“#FBBC04”);
\n $(“tmr”).classList.add(“run”);
\n log(“<b>ConsolidateAgent<\/b> woke on its 30-min timer — reviewing unconsolidated memories…”);
\n var svg=$(“wires”); svg.innerHTML=””;
\n for(var k=1;k<=Math.min(i,4);k++){ var el=$(“card”+k); if(el) el.classList.add(“hl”); }
\n setTimeout(function(){
\n CONS.links.forEach(function(pair){ drawWire(pair[0],pair[1]); });
\n log(“<b>Found connections<\/b> across memories — writing one cross-cutting insight…”);
\n },500);
\n setTimeout(function(){
\n var ins=$(“insight”); ins.innerHTML='<b>Insight:<\/b> ‘+CONS.insight; ins.classList.add(“show”);
\n $(“tmr”).classList.remove(“run”); consolidated=true;
\n log(“<b>Consolidation done.<\/b> New insight written back to the store — no prompt needed.”); post();
\n },1200);
\n }<\/p>\n

function drawWire(a,b){
\n var svg=$(“wires”), ca=$(“card”+a), cb=$(“card”+b); if(!ca||!cb) return;
\n var box=svg.getBoundingClientRect(), ra=ca.getBoundingClientRect(), rb=cb.getBoundingClientRect();
\n var x1=ra.left-box.left+ra.width\/2, y1=ra.top-box.top+ra.height\/2;
\n var x2=rb.left-box.left+rb.width\/2, y2=rb.top-box.top+rb.height\/2;
\n var ln=document.createElementNS(“http:\/\/www.w3.org\/2000\/svg”,”line”);
\n ln.setAttribute(“x1”,x1);ln.setAttribute(“y1”,y1);ln.setAttribute(“x2”,x1);ln.setAttribute(“y2”,y1);
\n ln.setAttribute(“stroke”,”#FBBC04″);ln.setAttribute(“stroke-width”,”2″);ln.setAttribute(“stroke-dasharray”,”4 3″);
\n svg.appendChild(ln);
\n requestAnimationFrame(function(){ ln.style.transition=”all .5s”; ln.setAttribute(“x2”,x2); ln.setAttribute(“y2”,y2); });
\n }<\/p>\n

function query(){
\n if(i<1){ log(“Ingest something first.”); return; }
\n activate($(“sQuery”),”query”); packet(“#34A853”);
\n $(“qbox”).classList.add(“show”); $(“qask”).textContent=’Q: ‘+Q; $(“qans”).innerHTML=”Reading all memories\u2026”;
\n log(“<b>QueryAgent<\/b> reads every memory”+(consolidated?” and the consolidation insight”:””)+”, then synthesizes…”);
\n [“card2″,”card3″,”card4”].forEach(function(id){ var el=$(id); if(el) el.classList.add(“cite”); });
\n setTimeout(function(){ $(“qans”).innerHTML=A;
\n log(“<b>Answer returned<\/b> with cited memory IDs — grounded only in stored memories.”); post(); },900);
\n }<\/p>\n

function reset(){
\n i=0; consolidated=false; store.innerHTML=””; $(“wires”).innerHTML=””;
\n $(“insight”).className=”insight”; $(“insight”).innerHTML=””;
\n $(“qbox”).className=”qbox”; $(“qans”).innerHTML=””; $(“qask”).textContent=””;
\n $(“bCons”).disabled=true; $(“bQuery”).disabled=true; activate(null);
\n log(“<b>Reset.<\/b> Drop a file into the agent’s inbox to begin.”);
\n }<\/p>\n

$(“bIngest”).onclick=ingest;
\n $(“bCons”).onclick=consolidate;
\n $(“bQuery”).onclick=query;
\n $(“bReset”).onclick=reset;<\/p>\n

window.addEventListener(“load”,post);
\n window.addEventListener(“resize”,post);
\n if(window.ResizeObserver){ new ResizeObserver(post).observe(document.body); }
\n setTimeout(post,150);
\n})();
\n<\/script>
\n<\/body>
\n<\/html>
\n“>\n<\/p><\/div>\n

\n

Supported Inputs<\/strong><\/h2>\n<\/p>

Beyond text, the IngestAgent accepts 27 file types across five categories. Simply drop any supported file into the .\/inbox<\/code> folder for automatic pickup.<\/p>\n

\n\n\n\n\n\n\n\n\n\n
Category<\/th>\nExtensions<\/th>\n<\/tr>\n<\/thead>\n
Text<\/td>\n.txt<\/code>, .md<\/code>, .json<\/code>, .csv<\/code>, .log<\/code>, .xml<\/code>, .yaml<\/code>, .yml<\/code><\/td>\n<\/tr>\n
Images<\/td>\n.png<\/code>, .jpg<\/code>, .jpeg<\/code>, .gif<\/code>, .webp<\/code>, .bmp<\/code>, .svg<\/code><\/td>\n<\/tr>\n
Audio<\/td>\n.mp3<\/code>, .wav<\/code>, .ogg<\/code>, .flac<\/code>, .m4a<\/code>, .aac<\/code><\/td>\n<\/tr>\n
Video<\/td>\n.mp4<\/code>, .webm<\/code>, .mov<\/code>, .avi<\/code>, .mkv<\/code><\/td>\n<\/tr>\n
Documents<\/td>\n.pdf<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

How It Compares to RAG, Summaries, and Knowledge Graphs<\/strong><\/h2>\n

To clarify the difference, it frames three common memory approaches. Each solves part of the problem, yet leaves a gap.<\/p>\n

\n\n\n\n\n\n\n\n\n
Approach<\/th>\nHow it stores<\/th>\nActive processing<\/th>\nMain limitation<\/th>\n<\/tr>\n<\/thead>\n
Vector DB + RAG<\/td>\nEmbeddings in a vector store<\/td>\nNone<\/td>\nPassive; embeds once, retrieves later<\/td>\n<\/tr>\n
Conversation summary<\/td>\nCompressed text<\/td>\nNone<\/td>\nLoses detail; no cross-reference<\/td>\n<\/tr>\n
Knowledge graphs<\/td>\nNodes and edges<\/td>\nManual upkeep<\/td>\nExpensive to build and maintain<\/td>\n<\/tr>\n
Always-On Memory Agent<\/td>\nStructured rows in SQLite<\/td>\nContinuous consolidation<\/td>\nQuery reads up to 50 recent memories<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/figure>\n

Unlike RAG, this agent processes memory actively, not only on retrieval.<\/p>\n

Use Cases With Examples<\/strong><\/h2>\n

Practically, the pattern fits any workload needing durable, evolving context. Consider three examples.<\/strong><\/p>\n