<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Guy Korland on Medium]]></title>
        <description><![CDATA[Stories by Guy Korland on Medium]]></description>
        <link>https://medium.com/@gkorland?source=rss-5ca1c9c12550------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*HBHX2w0hm26ZRlK8.</url>
            <title>Stories by Guy Korland on Medium</title>
            <link>https://medium.com/@gkorland?source=rss-5ca1c9c12550------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 20:34:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@gkorland/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Software Factory Pointed at Itself: Why Self-Improving Agents Will Fail Without Adaptive Memory]]></title>
            <link>https://medium.com/@gkorland/the-software-factory-pointed-at-itself-why-self-improving-agents-will-fail-without-adaptive-memory-033e99434aa3?source=rss-5ca1c9c12550------2</link>
            <guid isPermaLink="false">https://medium.com/p/033e99434aa3</guid>
            <category><![CDATA[graphrag]]></category>
            <category><![CDATA[knowledge-graph-rag]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[agentic-memory]]></category>
            <category><![CDATA[knowledge-graph]]></category>
            <dc:creator><![CDATA[Guy Korland]]></dc:creator>
            <pubDate>Fri, 10 Jul 2026 15:26:00 GMT</pubDate>
            <atom:updated>2026-07-10T15:26:00.951Z</atom:updated>
            <content:encoded><![CDATA[<p>A fascinating idea has been making the rounds on tech Twitter lately, perfectly encapsulated by <a href="https://www.yohei.me/">Yohei Nakajima</a> in this <a href="https://x.com/i/status/2074796886817481000">foundational post</a>:</p><blockquote><strong><em>“A self-improving agent is a software factory pointed at itself.”</em></strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/935/1*wnntGQiY53oxlVMf5M2K3g.png" /><figcaption><strong><em>self-improving agents</em></strong></figcaption></figure><p>It’s an incredible mental model, and it’s (I guess) what drove the creation of Yohei’s newest framework, <a href="https://activegraph.ai/">ActiveGraph</a>. ActiveGraph fundamentally inverts traditional agent design by using an append-only event log as the source of truth, building a live graph projection that behaviors dynamically react to. The promise of an autonomous system rewriting its own execution loops, optimizing its prompt paths, and patching its own code on the fly to become exponentially smarter is the holy grail of software engineering.</p><p>But as anyone who has actually spent time building low-latency, autonomous agentic frameworks knows, there is a massive catch.</p><p>If you point a software factory at itself, <strong>how do you survive the intermediate damage?</strong> (As I later pointed on <a href="https://x.com/g_korland/status/2075448163289215441?s=20">the realities of managing that blast radius</a>). More importantly, if the factory only upgrades its reasoning logic while leaving its data layout static, doesn’t the whole system eventually choke on its own complexity?</p><p>If we want agents that truly self-improve without bricking themselves, we need to address the missing link pointed out regarding <a href="https://x.com/Shilong_Liu_AI/status/2074942031676461216">the layers of self-improvement</a>: <strong>Adaptive Memory Architecture.</strong></p><h3>The Blast Radius of Self-Improvement</h3><p>In systems engineering, we constantly think about the “blast radius” - the maximum damage a failure can cause. When a human developer pushes a bad update, CI/CD pipelines catch it, or we roll it back.</p><p>But when an autonomous agent is continuously refactoring its own logic in a tight loop, it is essentially performing open-heart surgery on itself while running a marathon.</p><p>The risks are glaring:</p><ul><li><strong>The Intermediate Brick:</strong> A slightly buggy intermediate version of the agent’s code gets deployed. It breaks the agent’s ability to parse structural schemas or connect to the LLM orchestrator. The agent has effectively lobotomized itself, breaking the very mechanism it needs to fix the bug.</li><li><strong>Logic-Memory Mismatch:</strong> The agent upgrades its reasoning logic to a highly sophisticated n-step execution path, but its memory layer is still stuck retrieving flat, unindexed text chunks via basic semantic search. The brilliant new “brain” remains completely throttled by an archaic data layout.</li></ul><p>To build a real software factory that doesn’t blow itself up, the agent cannot just upgrade its <em>code</em>. It has to dynamically upgrade its <em>knowledge base</em> right alongside it.</p><h3>Enter the 4th Pillar: Adaptive Knowledge Graphs</h3><p>Our brains don’t just upgrade our logic circuits while leaving our memories as a messy, unorganized pile of sticky notes. As we learn, the way we link, index, and contextualize knowledge changes structurally.</p><p>For an AI agent, this means its memory architecture, specifically a <strong>Knowledge Graph (KG)</strong>, must be an active, fluid participant in the self-improvement loop.</p><p>This is where a graph-native engine like <a href="https://github.com/FalkorDB/falkordb"><strong>FalkorDB</strong></a> becomes critical. Because it views data as a collection of interconnected entities and relationships rather than disconnected chunks, an agent can refactor its memory schema just as easily as it refactors its Python or Rust code.</p><h3>A Concrete Example: The Evolving Schema</h3><p>Imagine a web-automation agent designed to handle complex workflows (like navigating intricate corporate portals or parsing multi-step legacy data fields).</p><h4>Phase 1: The Initial State</h4><p>When first spun up, the agent uses a simple, naive schema to log its memory in FalkorDB:</p><pre>(Agent) -&gt; [:EXECUTED] -&gt; (Task) -&gt; [:RESULTED_IN] -&gt; (TextLog)</pre><p>It’s functional, but slow. Every time the agent needs to recall how it solved a previous contextual error, it has to traverse a massive, linear chain of historical text logs, eating up latency and token budgets.</p><h4>Phase 2: The Self-Improved State</h4><p>As the agent runs its self-improvement factory, it realizes that traversing raw logs is a massive bottleneck. It doesn’t just rewrite its execution code, it fires a Cypher query to <strong>restructure its own memory graph</strong> into a highly optimized, semantic state machine:</p><pre>// The agent dynamically creates a new, abstracted relationship pattern<br>MATCH (t1:Task)-[:RESULTED_IN]-&gt;(l:TextLog)&lt;-[:RESULTED_IN]-(t2:Task)<br>WHERE l.outcome = &#39;Success&#39; AND t1.type = t2.type<br>CREATE (t1)-[:OPTIMIZED_PATH {latency_ms: 45}]-&gt;(t2)</pre><p>Suddenly, the schema has evolved. The agent has pruned the intermediate dead-weight logs and built a direct, high-performance graph highway:</p><pre>(Agent) -&gt; [:USES] -&gt; (OptimizedPath) -&gt; [:BYPASSES_LOGS] -&gt; (TargetState)</pre><p>By using an in-memory graph engine, this restructuring happens in milliseconds. The agent’s logic layer and memory layer scale <em>together</em>. If the logic changes, the graph adapts to serve it perfectly.</p><h3>Navigating the Sandbox: How to Prevent Self-Destruction</h3><p>If we are letting an agent rewrite both its codebase and its knowledge graph schema simultaneously, how do we prevent total chaos?</p><ul><li><strong>Strict Multi-Tenant Isolation:</strong> The “factory” must build and test the new agent version (and the new graph schema) in an isolated sandbox. You never let a self-improving loop write directly to production state.</li><li><strong>Graph-Backed Rollbacks:</strong> Because a knowledge graph tracks explicit relationships, you can version the schema itself. If Version 2.1 of the agent introduces a logic bug that corrupts how facts are linked, the system must be able to instantly roll back the graph state to the last known stable snapshot.</li><li><strong>Formal Verification of Memory:</strong> Before a newly optimized memory structure is adopted globally, a separate, static “guardian” agent must verify that the new graph paths don’t violate core constraints (e.g., ensuring security permissions or multi-tenant boundaries aren’t accidentally merged away).</li></ul><h3>The Path Forward</h3><p>Building autonomous agents isn’t just an LLM prompt engineering problem anymore, it is a complex systems engineering problem.</p><p>The software factory is pointed at itself. But if we want that factory to build a skyscraper instead of a pile of rubble, we have to stop treating memory like a passive file cabinet. The agent of the future will be defined by its ability to dynamically refactor its own knowledge, using high-performance, graph-native architectures to keep pace with its evolving mind.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=033e99434aa3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exploring GenAI: A Comparative Analysis with the Human Brain Through the Lens of Copilot]]></title>
            <link>https://medium.com/@gkorland/exploring-genai-a-comparative-analysis-with-the-human-brain-through-the-lens-of-copilot-6894b5e7960e?source=rss-5ca1c9c12550------2</link>
            <guid isPermaLink="false">https://medium.com/p/6894b5e7960e</guid>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[genai]]></category>
            <category><![CDATA[graphrag]]></category>
            <category><![CDATA[brain-structure]]></category>
            <dc:creator><![CDATA[Guy Korland]]></dc:creator>
            <pubDate>Sat, 08 Jun 2024 06:52:34 GMT</pubDate>
            <atom:updated>2024-06-08T06:57:34.753Z</atom:updated>
            <content:encoded><![CDATA[<p>For quite some time, we see (in <a href="https://www.falkordb.com/">FalkorDB</a>) the analogy between AI and brain evolving. And I’m not only talking about how Deep learning in general, or how LLMs specifically are mimicking the brain Neural Network, which in my eyes very similar to the <strong>Frontal Lob</strong>e. There’s another pivotal element in this process: the <strong>Hippocampus</strong>, which plays a key role in memory retrieval.</p><p>The <strong>Hippocampus </strong>is also a neural network but is mostly responsible about memory storage and quick retrieval of it, supporting the Frontal Lobe. And that is exactly how <strong>GraphRAG</strong> (Graph Retrieval Augmented Generation) supports LLM based applications.</p><p>It’s interesting to note that the hippocampus is one of the few areas in the brain where neurogenesis, the process of generating new neurons, occurs. This is significant for learning and memory formation. And that is another great analogy to draw, where the LLM is mostly static after a long training process, while the GraphRAG, based on a Knowledge Graph can keep on evolving and accumulate more data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-PEfDJmxTF4uwEwkF045eQ.jpeg" /><figcaption><strong>Neural Tapestry: The Vibrant Complexity of the Mind</strong></figcaption></figure><p>So I turned to Microsoft Copilot and asked for its help to describe brain processing flow so I can compare it to the GraphRAG+LLM process.</p><blockquote><strong>You</strong>: I’m trying to simplify the thinking process for kids, trying to create a flow that describes what happens in the brain from the time they hear a question to the time they give an answer. Can you help?</blockquote><p>It didn’t take it too long to answer…</p><blockquote><strong>Copilot</strong>: I see. That sounds like a great way to teach kids about the brain and how it works.</blockquote><blockquote>Maybe you can use this flow as a starting point:</blockquote><blockquote>* When a kid hears a question, the sound waves travel through the ear and reach the brain stem(1). The brain stem sends the sound signals to the temporal lobe(2) of the cerebrum, where they are processed as words and language.</blockquote><blockquote>* The temporal lobe then communicates with the frontal lobe(3) of the cerebrum, where the question is understood and analyzed. The frontal lobe also uses working memory to hold the question in mind and search for relevant information.</blockquote><blockquote>* The frontal lobe may also send signals to the hippocampus(4), which is a part of the limbic system that helps to access long-term memory. The hippocampus retrieves the stored information from the neocortex(5), which is the outer layer of the cerebrum that holds general knowledge and facts.</blockquote><blockquote>* The frontal lobe(6) then uses reasoning and logic to generate an answer based on the information from the temporal lobe, the hippocampus, and the neocortex. The frontal lobe also controls speech production by activating the Broca’s area, which is a region that helps to form words and sentences.</blockquote><blockquote>* The frontal lobe then sends the answer signals to the motor cortex(7), which is a part of the cerebrum that controls the voluntary muscles. The motor cortex then activates the muscles of the mouth, tongue, and throat to produce the answer sound.</blockquote><blockquote>* The answer sound then travels through the air and reaches the ear of the person who asked the question. And the cycle repeats! I hope this helps you to create a simple and fun flow for the kids. If you have any more questions, feel free to ask me.</blockquote><p>I’ve created a diagram based on the Copilot flow, which illustrates how computer science continues to emulate the intricate processes that nature has perfected over millions of years</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/722/1*gNmtuUOIpsql3YWOpjVXLQ.png" /></figure><blockquote><strong>Copilot</strong>: I hope this helps you to create a simple and fun flow for the kids. If you have any more questions, feel free to ask me.</blockquote><p>If you’re interested in keeping up with our progress, feel free to explore our GitHub repository: <a href="https://github.com/FalkorDB/falkordb">https://github.com/FalkorDB/falkordb</a></p><p>..</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6894b5e7960e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>