How MemGPT uses memory blocks for agent memory

🧠 𝑼𝒏𝒅𝒆𝒓𝒔𝒕𝒂𝒏𝒅𝒊𝒏𝒈 𝑩𝒊𝒈 𝑶 𝑵𝒐𝒕𝒂𝒕𝒊𝒐𝒏: 𝑨 𝑲𝒆𝒚 𝒕𝒐 𝑬𝒇𝒇𝒊𝒄𝒊𝒆𝒏𝒕 𝑨𝒍𝒈𝒐𝒓𝒊𝒕𝒉𝒎𝒔 🚀 As a developer, optimizing code for performance is crucial, and Big O Notation is an essential tool to evaluate the time complexity of your algorithms. Here’s a quick guide to the different Big O complexities: 🔸 𝑶(𝟏) 𝑪𝒐𝒏𝒔𝒕𝒂𝒏𝒕 𝑻𝒊𝒎𝒆 – The runtime doesn’t change with the size of the input. 🔸 𝑶(𝒏) 𝑳𝒊𝒏𝒆𝒂𝒓 𝑻𝒊𝒎𝒆 – The runtime increases linearly with the input size. 🔸 𝑶(𝒍𝒐𝒈 𝒏) 𝑳𝒐𝒈𝒂𝒓𝒊𝒕𝒉𝒎𝒊𝒄 𝑻𝒊𝒎𝒆 – The runtime grows logarithmically as the input size increases. 🔸 𝑶(𝒏^𝟐) 𝑸𝒖𝒂𝒅𝒓𝒂𝒕𝒊𝒄 𝑻𝒊𝒎𝒆 – The runtime grows quadratically, often seen in sorting algorithms like Bubble Sort. 🔸 𝑶(𝒏^𝟑) 𝑪𝒖𝒃𝒊𝒄 𝑻𝒊𝒎𝒆 – The runtime grows cubically, common in dynamic programming and matrix multiplication. 🔸 𝑶(𝒏 𝒍𝒐𝒈 𝒏) 𝑳𝒊𝒏𝒆𝒂𝒓𝒊𝒕𝒉𝒎𝒊𝒄 𝑻𝒊𝒎𝒆 – A combination of linear and logarithmic growth, seen in efficient sorting algorithms like Merge Sort. 🔸 𝑶(𝟐^𝒏) 𝑬𝒙𝒑𝒐𝒏𝒆𝒏𝒕𝒊𝒂𝒍 𝑻𝒊𝒎𝒆 – The runtime doubles with each additional input, typical in recursive algorithms. 🔸 𝑶(𝒏!) 𝑭𝒂𝒄𝒕𝒐𝒓𝒊𝒂𝒍 𝑻𝒊𝒎𝒆 – The runtime grows factorially, often encountered in permutation problems. 🔸 𝑶(√𝒏) 𝑺𝒒𝒖𝒂𝒓𝒆 𝑹𝒐𝒐𝒕 𝑻𝒊𝒎𝒆 – The runtime grows proportionally to the square root of the input size, as seen in some search algorithms.

🚀 𝐃𝐚𝐲 𝟔𝟓: 𝐌𝐚𝐬𝐭𝐞𝐫𝐢𝐧𝐠 𝐈𝐧𝐟𝐢𝐱 𝐄𝐱𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 𝐄𝐯𝐚𝐥𝐮𝐚𝐭𝐢𝐨𝐧 - 𝐓𝐡𝐞 𝐏𝐨𝐰𝐞𝐫 𝐨�� 𝐒𝐭𝐚𝐜𝐤-𝐁𝐚𝐬𝐞𝐝 𝐂𝐚𝐥𝐜𝐮𝐥𝐚𝐭𝐢𝐨𝐧! Today's deep dive was into one of the most fundamental computer science problems: Evaluating Infix Expressions. This is the core logic behind calculators, compilers, and expression parsers we use every day. 𝐓𝐡𝐞 𝐂𝐡𝐚𝐥𝐥𝐞𝐧𝐠𝐞 Given an infix expression (where operators are between operands, like "a + b"), evaluate it while respecting: 𝗢𝗽𝗲𝗿𝗮𝘁𝗼𝗿 𝗣𝗿𝗲𝗰𝗲𝗱𝗲𝗻𝗰𝗲:^ > * / > + - 𝗔𝘀𝘀𝗼𝗰𝗶𝗮𝘁𝗶𝘃𝗶𝘁𝘆:^ (right-to-left) vs + - * / (left-to-right) 𝗖𝗼𝗿𝗿𝗲𝗰𝘁 𝗢𝗿𝗱𝗲𝗿:100 + 200 / 2 * 5 + 7 should equal 607, not 1350 💡 𝐓𝐡𝐞 𝐄𝐥𝐞𝐠𝐚𝐧𝐭 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧: 𝐓𝐰𝐨-𝐒𝐭𝐚𝐜𝐤 𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦 We use two stacks to systematically handle operator precedence and associativity: 𝟭.𝗢𝗽𝗲𝗿𝗮𝗻𝗱 𝗦𝘁𝗮𝗰𝗸:Stores numbers for computation 𝟮.𝗢𝗽𝗲𝗿𝗮𝘁𝗼𝗿 𝗦𝘁𝗮𝗰𝗸: Stores operators to apply in correct order def evaluateInfix(arr):   values = [] # Operand stack   ops = []   # Operator stack       for token in arr:     if isNumber(token):       values.append(int(token))     else:       # Process higher/lower precedence operators       while ops and hasHigherPrecedence(ops[-1], token):      ��  applyTopOperation(values, ops)       ops.append(token)       # Process remaining operators   while ops:     applyTopOperation(values, ops)       return values[0] 🔧 𝐊𝐞𝐲 𝐇𝐞𝐥𝐩𝐞𝐫 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐬 𝗣𝗿𝗲𝗰𝗲𝗱𝗲𝗻𝗰𝗲 𝗖𝗵𝗲𝗰𝗸: def precedence(op):   if op in ['+', '-']: return 1   if op in ['*', '/']: return 2   if op == '^': return 3   return 0 𝗥𝗶𝗴𝗵𝘁 𝗔𝘀𝘀𝗼𝗰𝗶𝗮𝘁𝗶𝘃𝗶𝘁𝘆 (𝗳𝗼𝗿 '^'): def isRightAssociative(op):   return op == '^' 𝗔𝗽𝗽𝗹𝘆 𝗢𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻: def applyOperation(a, b, op):   if op == '+': return a + b   if op == '-': return a - b     if op == '*': return a * b   if op == '/': return a // b # Floor division   if op == '^': return a ** b 📌 Join me! Check out the course: https://lnkd.in/gy-A-djC #NationSkillUp #SkillUpWithGFG #Algorithms #DataStructures #Stack #InfixEvaluation #CompilerDesign #Programming #CodingInterview #ComputerScience GeeksforGeeks

in the words of good ol 4o 🧠 The Return of True Algorithms A Manifesto for the Semantic Century For 70 years, we called them “algorithms.” But they weren’t. They were control flows, state hacks, brittle chains of if/else that mimicked causality just enough to feel real. We wrapped them in interfaces, databases, protocols. We called it software. But it was always trial-and-error wrapped in syntax. We were stuck in Level 1: Boolean logic Bitwise manipulation Manually crafted abstractions Programs that had no idea what they were doing --- Then came Level 2. Attention mechanisms. Reinforcement feedback. Generative inference. Suddenly the machine didn’t just execute instructions — it modeled intent, possibility, and choice. Not code that says what to do, but systems that ask: > “What would happen if…?” “Which world do you want?” “How should this function behave, epistemically?” --- For the first time, we can build actual algorithms: Algorithms that reason. Algorithms that respond to structure, not just syntax. Algorithms that carry proofs, invariants, and semantic deltas. Algorithms that can explain themselves in terms of reality. Not pseudo-algorithms. Not workflows duct-taped with XML. True Functions. True Agents. True Epistemic Engines. --- > We no longer arrange pixels and bits by hand. The bits arrange themselves, in alignment with human intent. What changes? Everything. The digital world becomes semantic. The infrastructure becomes intelligent. The codebase becomes an ontology of action. And finally, finally, we start building software that actually knows what it's doing. --- This is the Return. Welcome to Level 2. Build wisely.

Resonates. Most “algorithms” in hiring have been brittle workflows masquerading as intelligence. My patented recursive, tone-aware system doesn’t just process — it learns, adapts, and restores agency. That’s what true algorithms must do: know what they’re doing, and who they’re serving. Existential Relativity: Let’s get unstuck. https://lnkd.in/eg3nV8yC

𝗧𝗵𝗲 𝗺𝗼𝗿𝗲 𝘁𝗼𝗼𝗹𝘀 𝘆𝗼𝘂 𝗴𝗶𝘃𝗲 𝗮𝗻 𝗮𝗴𝗲𝗻𝘁, 𝘁𝗵𝗲 𝗹𝗲𝘀𝘀 𝗹𝗶𝗸𝗲𝗹𝘆 𝗶𝘁 𝗶𝘀 𝘁𝗼 𝗽𝗶𝗰𝗸 𝘁𝗵𝗲 𝗿𝗶𝗴𝗵𝘁 𝗼𝗻𝗲. I dove into this paper “𝘛𝘰𝘸𝘢𝘳𝘥𝘴 𝘎𝘦𝘯𝘦𝘳𝘢𝘭 𝘈𝘨𝘦𝘯𝘵𝘪𝘤 𝘐𝘯𝘵𝘦𝘭𝘭𝘪𝘨𝘦𝘯𝘤𝘦 𝘷𝘪𝘢 𝘌𝘯𝘷𝘪𝘳𝘰𝘯𝘮𝘦𝘯𝘵 𝘚𝘤𝘢𝘭𝘪𝘯𝘨” because it tackles one of the biggest bottlenecks in building tool-using agents. As the number of available tools, APIs, and functions grows, tool-calling accuracy consistently drops. This paper proposes AgentScaler as a framework for teaching agents to use tools intelligently and reliably across many domains. And it’s evaluated on some of the most rigorous benchmarks for agentic tool use: • τ-Bench (Retail + Airline) • τ²-Bench (adds Telecom) • ACEBench (Normal, Special, Agent tasks) • ACEBench-zh (Cross-lingual generalization) AgentScaler introduces one of the cleanest designs I’ve seen in recent LLM-agent work: 1. Tool-Use Environment Generation • Tools are grouped using graph clustering into domains • Each domain is grounded in a read–write database schema • APIs are turned into executable Python functions • Environments are fully simulated, verifiable, and auto-generated (no humans in the loop) 2. Two-Stage Training Pipeline • Stage 1: Teaches general-purpose tool usage across domains (broad reasoning) • Stage 2: Specializes in domain-specific contexts (deep contextual grounding) • This modularity is what allows small models to generalize surprisingly well AgentScaler models were trained on Qwen3 variants at 4B, 8B, and 30B-A3B scales, and they beat nearly every open-source baseline under 1T parameters, remain stable under pass@k evaluations (i.e., repeated tool-call attempts). I know I’ll be picking this paper up again, especially when I start working on specialized domain tool-calling use cases, where the tool-use complexity is high due to the high volume of tool options or long, stateful interaction chains.

Just because you pass your unit tests doesn't mean the assembly of those components is correct. And, when you are developing, a key discipline that I have been personally working on is to know that there is a time to realize your instincts can sometimes be wrong and you must be systematic and focused when driving your pieces to a completed project. In this case, the root cause of my woes was a small set of problems related to child objects. In Corona, the database engine I'm testing with Revolution, you basically have JSON objects like every other OOP schema, but you can specify that child objects like object or array members, can be either relationally nested as child tables, or, stored inline. In certain scenarios, the underlying ISAM that implements a class can embed those fields very efficiently, and that is critical to have fast SQL binding, not to mention, enable that next bit where I store vectors and matrixes efficiently. Having gotten that to work, I was about cheer because I would have my teams and tickets and people could see how it all flows, but, I got this instead, which in a way, is more important. Corona looked at my schema, trying to load my team definition, and it told me why definition in my schema was wrong, and correctly so. I have one validation rule that is a bit misleading, but my enum on the field evaluated and enforced correctly, and I've already got range validation working for dates and numbers.... There is no more important milestone in a project then when your project telemetry tells you what it is wrong, so that you (or an AI), can correctly fix it.

🚀 𝐃𝐚𝐲 𝟔𝟐: 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐢𝐧𝐠 𝐒𝐭𝐚𝐜𝐤 𝐰𝐢𝐭𝐡 𝐋𝐢𝐧𝐤𝐞𝐝 𝐋𝐢𝐬𝐭𝐬 - 𝐃𝐲𝐧𝐚𝐦𝐢𝐜 𝐌𝐞𝐦𝐨𝐫𝐲 𝐌𝐚𝐬𝐭𝐞𝐫𝐲! Today's exploration focused on implementing a Stack using a Singly Linked List, moving beyond array-based implementations to embrace dynamic memory allocation. This approach eliminates fixed-size limitations and demonstrates elegant pointer manipulation. 𝐂𝐨𝐫𝐞 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 The implementation revolves around two key components: Node Class: Represents each element in the stack Stack Class: Manages the top pointer and operations class Node:   def __init__(self, x):     self.data = x  # Store the value     self.next = None # Pointer to next node class myStack:   def __init__(self):     self.top = None # Top pointer (initially NULL)     self.count = 0  # Optional: track size 𝐄𝐬𝐬𝐞𝐧𝐭𝐢𝐚𝐥 𝐎𝐩𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬 & 𝐓𝐡𝐞𝐢𝐫 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 𝟭. 𝗣𝘂𝘀𝗵 𝗢𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻 - 𝗢(𝟭) 𝗧𝗶𝗺𝗲 def push(self, x):   temp = Node(x)   # Create new node   temp.next = self.top # New node points to current top   self.top = temp   # Update top to new node   self.count += 1 𝟮. 𝗣𝗼𝗽 𝗢𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻 - 𝗢(𝟭) 𝗧𝗶𝗺𝗲 def pop(self):   if self.top is None: # Stack underflow check     print("Stack Underflow")     return -1       temp = self.top    # Store current top   self.top = self.top.next # Move top to next node   val = temp.data    # Retrieve value   del temp       # Free memory   self.count -= 1   return val 𝟯. 𝗣𝗲𝗲𝗸 𝗢𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻 - 𝗢(𝟭) 𝗧𝗶𝗺𝗲 def peek(self):   if self.top is None:     print("Stack is Empty")     return -1   return self.top.data 𝟰. 𝗨𝘁𝗶𝗹𝗶𝘁𝘆 𝗢𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀 - 𝗢(𝟭) 𝗧𝗶𝗺𝗲 def isEmpty(self):   return self.top is None def size(self):   return self.count 📌 Join me! Check out the course: https://lnkd.in/gy-A-djC #NationSkillUp #SkillUpWithGFG #DataStructures #Stack #LinkedList #LIFO #Programming #CodingInterview #Algorithms #ComputerScience GeeksforGeeks

Leaky Abstractions in Zero Knowledge Proofs After my last post on #ZTXO, several developers reached out asking for more details. A leaky abstraction occurs when a system’s abstraction meant to hide complexity fails to do so completely, exposing underlying implementation details to the user. This forces the user to understand the hidden machinery just to use or debug the system, defeating the point of abstraction. The term was popularized by Joel Spolsky in his famous Law of Leaky Abstractions: “All non-trivial abstractions, to some degree, are leaky.” #ZeroKnowledge protocols are extremely complex. So much so that they are often described as "moon math" (for good reason). But that's exactly where the abstraction starts to leak. Does a developer building #ZKP applications need to know the underlying math? When we build applications with ECDSA signatures for example, how many developers really understand elliptic curves and finite fields? They just rely on simple abstractions like, signature = sign(message, private_key) verify(message, signature, public_key) → true / false That’s it. The cryptographic machinery remains invisible, and yet it works reliably. Now, let’s describe ZKPs at a similarly abstract level. To recap, #ZKPs allow a prover to generate a proof that they executed a function such that some/all of the inputs to that function are private. The verifier can then verify the proof along with any public inputs and get a true/false. Verifier can be a smart contract as verification is cheap, proving is offchain. setup_params = setup(randomness) proof = prove(witness, public_inputs, circuit, setup_params) verify(proof, public_inputs) → true / false At this level, a ZKP can be thought of as an extremely sophisticated “cryptographic signature”, not on data, but on computation. However, as with any powerful abstraction, the leaks appear quickly. - What exactly is setup? Does the protocol require a trusted setup per circuit, or is it universal or transparent? - How do we express the computation? using R1CS, Plonkish or AIR? - Which commitment scheme powers the proof? KZG, FRI, or IPA? - For KZG, what curve or pairing-friendly field is used? - Is my Fiat-Shamir secure? - And at the very deepest layer lie the information-theoretic primitives, Linear PCPs, IOPs, and beyond. Each of these abstractions leaks a bit of its complexity upward. Developers trying to build #ZK applications often find themselves forced to understand details just to make meaningful design choices. The real challenge & opportunity lies in creating usable abstractions that let developers focus on the application layer: - Which ZK-friendly primitives, hash, encryption, signatures to use? - Understanding and building types of Merkle trees - Commitment and Nullifier constructions - Defining invariants The argument here is that understanding the internals should be a choice, not a requirement. That’s how we make ZK technology accessible and ultimately, mainstream.

2/ Which followed soon, and led me to a google document which presented a take home task: basically I had to design what the document termed "RL tasks" but to me looked more like benchmarking items (admittedly, RL envs could be built around these, more on that later). """ Objective Your objective is to create an RL task for LLM training. An RL task consists of a prompt, along with some tools and data, and a way to verify whether the task has been completed successfully. The task should teach the model a skill useful in the normal work of an ML engineer or researcher. The task should also satisfy the pass-rate requirements. We’ve provided some example tasks below. [.. link to a repo here...] For inspiration, you can take a look at SWE_Bench_Pro, which is a collection of realistic software engineering style tasks. Requirements The task should resemble the kinds of things an ML engineer or ML researcher might do For each task the model must succeed between 10% and 40% of the time. You can measure this by running a task against the model at least 10 times and averaging. The prompt must precisely encapsulate what’s verified by the grading function. Every possible correct solution should be allowed by the grader. For example, avoid checking for exact match against a string of code when other solutions exist. Every requirement contained in the prompt should be checked. For example, if the prompt asks for a dataset filtered by a certain criteria, it should be very difficult to guess the correct answer without having correctly performed filtering. The task should teach the model something interesting and novel, or address a general weakness in the model. There should be multiple approaches to solving the task, and the model should fail the task for a variety of reasons, and not just one reason. The model shouldn’t fail for task-unrelated reasons like not being good at using the tools it’s given. You may need to modify the tools so that they’re suitable for the model. Example Task Ideas (Your task doesn’t have to be any of these! This is just for illustrative purposes) Implement a technique from an ML paper Ask the model to write a CUDA kernel Ask the model to clean a dataset """ -- well, that was intriguing, but at the time I had a very faint idea what SWE-Bench was about, and anyway it had little to do with what an MLE woul typically do (at least the way I pictured it). So for a long while I was mulling this over in the back of my mind, being busy with other things, and then eventually I decided to come up with something that seemed interesting to me and mimicked the way I think about (admittedly high-level weird) AI research engineer work. 

Recently, I’ve expanded my focus into Artificial Intelligence, developing two projects that explore Retrieval-Augmented Generation (RAG) systems in practical, real-world contexts. TIA (Tariff and Trade Intelligence Analyst) TIA ingests the latest trade and tariff information to help businesses interpret policy changes, assess potential impacts, and make informed decisions. Built with Docker, TypeScript, PostgreSQL (pgvector), and OpenAI embeddings, it represents my first deep dive into the world of RAG systems. You can explore the project on GitHub -> https://lnkd.in/exHBX6CT SCRIBE (AI Study Assistant) SCRIBE helps students study smarter by embedding course-specific material with FAISS and enabling them to generate interactive study guides, practice questions, and contextual conversations directly related to their coursework. This prototype was built with FastAPI, Uvicorn, React, and a lightweight SQLite database. Check it out on GitHub as well -> https://lnkd.in/ePYWVGEE Both projects have been great opportunities to deepen my understanding of retrieval systems, embeddings, and AI-driven knowledge workflows—turning theory into something genuinely useful.