Uncategorized

arXiv:2602.14100v1 Announce Type: new Abstract: Whether neural networks can serve as cognitive models of morphological learning remains an open question. Recent work has shown that encoder-decoder models can acquire irregular patterns, but evidence that they generalize these patterns like humans is mixed. We investigate this using the Spanish emph{L-shaped morphome}, where only the first-person singular indicative (e.g., textit{pongo} `I put’) shares its stem with all subjunctive forms (e.g., textit{ponga, pongas}) despite lacking apparent phonological, semantic, or syntactic motivation. We compare five encoder-decoder transformers varying along two dimensions: sequential vs. position-invariant positional encoding, and atomic vs. decomposed tag representations. Positional encoding proves decisive: position-invariant models recover the correct L-shaped paradigm clustering even when L-shaped verbs are scarce in training, whereas sequential positional encoding models only partially capture the pattern. Yet none of the models productively generalize this pattern to novel forms. Position-invariant models generalize the L-shaped stem across subjunctive cells but fail to extend it to the first-person singular indicative, producing a mood-based generalization rather than the L-shaped morphomic pattern. Humans do the opposite, generalizing preferentially to the first-person singular indicative over subjunctive forms. None of the models reproduce the human pattern, highlighting the gap between statistical pattern reproduction and morphological abstraction.

arXiv:2505.12185v5 Announce Type: replace-cross Abstract: Evaluating the programming robustness of large language models (LLMs) is paramount for ensuring their reliability in AI-based software development. However, adversarial attacks exhibit fundamental limitations that compromise fair robustness assessment: they demonstrate contradictory evaluation outcomes where different attack strategies tend to favor different models, and more critically, they operate solely through external perturbations, failing to capture the intrinsic stability essential for autonomous coding agents where subsequent inputs are endogenously generated by the model itself. We introduce EVALOOOP, a novel assessment framework that evaluates robustness from a self-consistency perspective, leveraging the natural duality inherent in software engineering tasks (e.g., code generation and code summarization). EVALOOOP establishes a self-contained feedback loop where an LLM iteratively transforms between code and natural language until functional failure occurs, with robustness quantified by a novel Average Sustainable Loops (ASL) metric-the mean number of iterations maintaining functional correctness across benchmark tasks. This cyclical strategy intrinsically evaluates robustness without relying on external attack configurations, providing a unified metric that reveals how effectively LLMs preserve semantic integrity through sustained self-referential transformations. We evaluate 96 popular LLMs, ranging from 0.5B to 685B parameters, on EVALOOOP equipped with the MBPP Plus benchmark, and found that EVALOOOP typically induces a 2.65%-47.62% absolute drop in pass@1 accuracy within ten loops. Intriguingly, robustness does not always align with initial performance (i.e., one-time query); for instance, Qwen3-235B-A22B-Instruct-2507, despite inferior initial code generation compared to OpenAI’s o-series models and DeepSeek-V3, demonstrated the superior robustness (ASL score).

Building AI agents is the new gold rush. But every developer knows the biggest bottleneck: getting the AI to actually communicate to your data. Today, travel giant Agoda is tackling this problem head-on. They have officially launched APIAgent, an open-source tool designed to turn any REST or GraphQL API into a Model Context Protocol (MCP) server with 0 code and 0 deployments. The Problem: The ‘Integration Tax‘ Until recently, if you wanted your AI agent to check flight prices or look up a database, you had to write a custom tool. When Anthropic released the Model Context Protocol (MCP), it created a standard way for Large Language Models (LLMs) to connect to external tools. However, even with MCP, the workflow is tedious. A developer must: Write a new MCP server in Python or TypeScript. Define every tool and its parameters manually. Deploy and maintain that server. Update the code every time the underlying API changes. Agoda team calls this the ‘integration tax.’ For a company with 1000s of internal APIs, writing 1000s of MCP servers is not realistic. APIAgent is their answer to this scaling problem. What is APIAgent? APIAgent is a universal MCP server. Instead of writing custom logic for every API, you use APIAgent as a proxy. It sits between your LLM (like Claude or GPT-4) and your existing APIs. The tool is built on a specific technical stack: FastMCP: Powers the MCP server layer. OpenAI Agents SDK: Handles the language model orchestration. DuckDB: An in-process SQL engine used for SQL post-processing. The ‘magic’ lies in its ability to understand API documentation. You provide a definition of your API—using an OpenAPI specification for REST or a schema for GraphQL—and APIAgent handles the rest. How It Works? The architecture is straightforward. APIAgent acts as a gateway. When a user asks an AI agent a question, the flow looks like this: The Request: The user asks, ‘Show me the top 10 hotels in Bangkok with the most reviews.’ Schema Introspection: APIAgent automatically inspects the API schema to understand the available endpoints and fields. The SQL Layer (DuckDB): This is the secret sauce. If the API returns 10,000 unsorted rows, APIAgent uses DuckDB to filter, sort, and aggregate that data locally via SQL before sending the concise result back to the LLM. The Response: The JSON data travels back through APIAgent, which formats it for the AI to read. This system uses Dynamic Tool Discovery. You can point APIAgent at any URL, and it automatically generates the necessary tools for the LLM without manual mapping. Key Feature: ‘Recipe’ Learning One of the key features is Recipe Learning. When a complex natural language query successfully executes, APIAgent can extract the trace and save it as a ‘Recipe.’ These recipes are parameterized templates. The next time a similar question is asked, APIAgent uses the recipe directly. This skips the expensive LLM reasoning step, which significantly reduces latency and cost. Key Takeaway Universal Protocol Bridge: APIAgent acts as a single, open-source proxy that converts any REST or GraphQL API into a Model Context Protocol (MCP) server. This removes the need to write custom boilerplate code or maintain individual MCP servers for every internal microservice. Zero-Code Schema Introspection: The tool is ‘configuration-first.’ By simply pointing APIAgent at an OpenAPI spec or GraphQL endpoint, it automatically introspects the schema to understand endpoints and fields. It then exposes these to the LLM as functional tools without manual mapping. Advanced SQL Post-Processing: It integrates DuckDB, an in-process SQL engine, to handle complex data manipulation. If an API returns thousands of unsorted rows or lacks specific filtering, APIAgent uses SQL to sort, aggregate, or join the data locally before delivering a concise answer to the AI. Performance via ‘Recipe Learning’: To solve high latency and LLM costs, the agent features Recipe Learning. It records the successful execution trace of a natural language query and saves it as a parameterized template. Security-First Architecture: The system is ‘Safe by Default,‘ operating in a read-only state. Any ‘mutating’ actions (like POST, PUT, or DELETE requests) are strictly blocked by the proxy unless a developer explicitly whitelists them in the YAML configuration file. Check out the PR Here. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post Agoda Open Sources APIAgent to Convert Any REST pr GraphQL API into an MCP Server with Zero Code appeared first on MarkTechPost.

Machine learning models built with frameworks like scikit-learn can accommodate unstructured data like text, as long as this raw text is converted into a numerical representation that is understandable by algorithms, models, and machines in a broader sense.

When he was just a teenager trying to decide what to do with his life, César de la Fuente compiled a list of the world’s biggest problems. He ranked them inversely by how much money governments were spending to solve them. Antimicrobial resistance topped the list.  Twenty years on, the problem has not gone away. If anything, it’s gotten worse. Infections caused by bacteria, fungi, and viruses that have evolved ways to evade treatments are now associated with more than 4 million deaths per year, and a recent analysis, published in the Lancet, predicts that number could surge past 8 million by 2050. In a July 2025 essay in Physical Review Letters, de la Fuente, now a bioengineer and computational biologist, and synthetic biologist James Collins warned of a looming “post­antibiotic” era in which infections from drug-resistant strains of common bacteria like Escherichia coli or Staphylococcus aureus, which can often still be treated by our current arsenal of medications, become fatal. “The antibiotic discovery pipeline remains perilously thin,” they wrote, “impeded by high development costs, lengthy timelines, and low returns on investment.” But de la Fuente is using artificial intelligence to bring about a different future. His team at the University of Pennsylvania is training AI tools to search genomes far and deep for peptides with antibiotic properties. His vision is to assemble those peptides—molecules made of up to 50 amino acids linked together—into various configurations, including some never seen in nature. The results, he hopes, could defend the body against microbes that withstand traditional treatments.  His quest has unearthed promising candidates in unexpected places. In August 2025 his team, which includes 16 scientists in Penn’s Machine Biology Group, described peptides hiding in the genetic code of ancient single-celled organisms called archaea. Before that, they’d excavated a list of candidates from the venom of snakes, wasps, and spiders. And in an ongoing project de la Fuente calls “molecular de-­extinction,” he and his collaborators have been scanning published genetic sequences of extinct species for potentially functional molecules. Those species include hominids like Neanderthals and Denisovans and charismatic megafauna like woolly mammoths, as well as ancient zebras and penguins. In the history of life on Earth, de la Fuente reasons, maybe some organism evolved an antimicrobial defense that could be helpful today. Those long-gone codes have given rise to resurrected compounds with names like ­mammuthusin-2 (from woolly mammoth DNA), mylodonin-2 (from the giant sloth), and hydrodamin-1 (from the ancient sea cow). Over the last few years, this molecular binge has enabled de la Fuente to amass a library of more than a million genetic recipes. At 40 years old, de la Fuente has also collected a trophy case of awards from the American Society for Microbiology, the American Chemical Society, and other organizations. (In 2019, this magazine named him one of “35 Innovators Under 35” for bringing computational approaches to antibiotic discovery.) He’s widely recognized as a leader in the effort to harness AI for real-world problems. “He’s really helped pioneer that space,” says Collins, who is at MIT. (The two have not collaborated in the laboratory, but Collins has long been at the forefront of using AI for drug discovery, including the search for antibiotics. In 2020, Collins’s team used an AI model to predict a broad-­spectrum antibiotic, halicin, that is now in preclinical development.)  The world of antibiotic development needs as much creativity and innovation as researchers can muster, says Collins. And de la Fuente’s work on peptides has pushed the field forward: “César is marvelously talented, very innovative.”  A messy, noisy endeavor De la Fuente describes antimicrobial resistance as an “almost impossible” problem, but he sees plenty of room for exploration in the word almost. “I like challenges,” he says, “and I think this is the ultimate challenge.”  The use, overuse, and misuse of antibiotics, he says, drives antimicrobial resistance. And the problem is growing unchecked because conventional ways to find, make, and test the drugs are prohibitively expensive and often lead to dead ends. “A lot of the companies that have attempted to do antibiotic development in the past have ended up folding because there’s no good return on investment at the end of the day,” he says. Antibiotic discovery has always been a messy, noisy endeavor, driven by serendipity and fraught with uncertainty and misdirection. For decades, researchers have largely relied on brute-force mechanical methods. “Scientists dig into soil, they dig into water,” says de la Fuente. “And then from that complex organic matter they try to extract antimicrobial molecules.”  But molecules can be extraordinarily complex. Researchers have estimated the number of possible organic combinations that could be synthesized at somewhere around 1060. For reference, Earth contains an estimated 1018 grains of sand. “Drug discovery in any domain is a statistics game,” says Jonathan Stokes, a chemical biologist at McMaster University in Canada, who has been using generative AI to design potential new antibiotics that can be synthesized in a lab, and who worked with Collins on halicin. “You need enough shots on goal to happen to get one.”  Those have to be good shots, though. And AI seems well suited to improving researchers’ aim. Biology is an information source, de la Fuente explains: “It’s like a bunch of code.” The code of DNA has four letters; proteins and peptides have 20, where each “letter” represents an amino acid. De la Fuente says his work amounts to training AI models to recognize sequences of letters that encode antimicrobial peptides, or AMPs. “If you think about it that way,” he says, “you can devise algorithms to mine the code and identify functional molecules, which can be antimicrobials. Or antimalarials. Or anticancer agents.”  Practically speaking, we’re still not there: These peptides haven’t yet been transformed into usable drugs that help people, and there are plenty of details—dosage, delivery, specific targets—that need to be sorted out, says de la Fuente. But AMPs are appealing because the body already uses them.They’re a critical part of the immune system and often

The AI industry is currently obsessed with ‘agents’—autonomous programs that do more than just chat. However, most current multi-agent systems rely on brittle, hard-coded heuristics that fail when the environment changes. Google DeepMind researchers have proposed a new solution. The research team argued that for the ‘agentic web’ to scale, agents must move beyond simple task-splitting and adopt human-like organizational principles such as authority, responsibility, and accountability. Defining ‘Intelligent’ Delegation In standard software, a subroutine is just ‘outsourced’. Intelligent delegation is different. It is a sequence of decisions where a delegator transfers authority and responsibility to a delegatee. This process involves risk assessment, capability matching, and establishing trust. The 5 Pillars of the Framework To build this, the research team identified 5 core requirements mapped to specific technical protocols: Framework Pillar Technical Implementation Core Function Dynamic Assessment Task Decomposition & Assignment Granularly inferring agent state and capacity. Adaptive Execution Adaptive Coordination Handling context shifts and runtime failures. Structural Transparency Monitoring & Verifiable Completion Auditing both the process and the final outcome. Scalable Market Trust & Reputation & Multi-objective Optimization Efficient, trusted coordination in open markets. Systemic Resilience Security & Permission Handling Preventing cascading failures and malicious use. Engineering Strategy: ‘Contract-First’ Decomposition The most significant shift is contract-first decomposition. Under this principle, a delegator only assigns a task if the outcome can be precisely verified. If a task is too subjective or complex to verify—like ‘write a compelling research paper’—the system must recursively decompose it. This continues until the sub-tasks match available verification tools, such as unit tests or formal mathematical proofs. Recursive Verification: The Chain of Custody In a delegation chain, such as 𝐴 → 𝐵 → 𝐶, accountability is transitive. Agent B is responsible for verifying the work of C. When Agent B returns the result to A, it must provide a full chain of cryptographically signed attestations. Agent A then performs a 2-stage check: verifying B’s direct work and verifying that B correctly verified C. Security: Tokens and Tunnels Scaling these chains introduces massive security risks, including Data Exfiltration, Backdoor Implanting, and Model Extraction. To protect the network, DeepMind team suggests Delegation Capability Tokens (DCTs). Based on technologies like Macaroons or Biscuits, these tokens use ‘cryptographic caveats’ to enforce the principle of least privilege. For example, an agent might receive a token that allows it to READ a specific Google Drive folder but forbids any WRITE operations. Evaluating Current Protocols The research team analyzed whether current industry standards are ready for this framework. While these protocols provide a base, they all have ‘missing pieces’ for high-stakes delegation. MCP (Model Context Protocol): Standardizes how models connect to tools. The Gap: It lacks a policy layer to govern permissions across deep delegation chains. A2A (Agent-to-Agent): Manages discovery and task lifecycles. The Gap: It lacks standardized headers for Zero-Knowledge Proofs (ZKPs) or digital signature chains. AP2 (Agent Payments Protocol): Authorizes agents to spend funds. The Gap: It cannot natively verify the quality of the work before releasing payment. UCP (Universal Commerce Protocol): Standardizes commercial transactions. The Gap: It is optimized for shopping/fulfillment, not abstract computational tasks. Key Takeaways Move Beyond Heuristics: Current AI delegations relies on simple, hard-coded heuristics that are brittle and cannot dynamically adapt to environmental changes or unexpected failures. Intelligent delegation requires an adaptive framework that incorporates transfer of authority, responsibility, and accountability. ‘Contract-First’ Task Decomposition: For complex goals, delegators should use a ‘contract-first’ approach, where tasks are decomposed until the sub-units match specific, automated verification capabilities, such as unit tests or formal proofs. Transitive Accountability in Chains: In long delegation chains (e.g., 𝐴 → 𝐵 → 𝐶), responsibility is transitive. Agent B is responsible for the work of C, and Agent A must verify both B’s direct work and that B correctly verified C’s attestations. Attenuated Security via Tokens: To prevent systemic breaches and the ‘confused deputy problem,’ agents should use Delegation Capability Tokens (DCTs) that provide attenuated authorization. This ensures agents operate under the principle of least privilege, with access restricted to specific subsets of resources and allowable operations. Check out the Paper here. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well. The post Google DeepMind Proposes New Framework for Intelligent AI Delegation to Secure the Emerging Agentic Web for Future Economies appeared first on MarkTechPost.

In this tutorial, we build a fully stateful personal tutor agent that moves beyond short-lived chat interactions and learns continuously over time. We design the system to persist user preferences, track weak learning areas, and selectively recall only relevant past context when responding. By combining durable storage, semantic retrieval, and adaptive prompting, we demonstrate how an agent can behave more like a long-term tutor than a stateless chatbot. Also, we focus on keeping the agent self-managed, context-aware, and able to improve its guidance without requiring the user to repeat information. Copy CodeCopiedUse a different Browser !pip -q install “langchain>=0.2.12” “langchain-openai>=0.1.20” “sentence-transformers>=3.0.1” “faiss-cpu>=1.8.0.post1” “pydantic>=2.7.0″ import os, json, sqlite3, uuid from datetime import datetime, timezone from typing import List, Dict, Any import numpy as np import faiss from pydantic import BaseModel, Field from sentence_transformers import SentenceTransformer from langchain_core.messages import SystemMessage, HumanMessage, AIMessage from langchain_core.language_models.chat_models import BaseChatModel from langchain_core.outputs import ChatGeneration, ChatResult DB_PATH=”/content/tutor_memory.db” STORE_DIR=”/content/tutor_store” INDEX_PATH=f”{STORE_DIR}/mem.faiss” META_PATH=f”{STORE_DIR}/mem_meta.json” os.makedirs(STORE_DIR, exist_ok=True) def now(): return datetime.now(timezone.utc).isoformat() def db(): return sqlite3.connect(DB_PATH) def init_db(): c=db(); cur=c.cursor() cur.execute(“””CREATE TABLE IF NOT EXISTS events( id TEXT PRIMARY KEY,user_id TEXT,session_id TEXT,role TEXT,content TEXT,ts TEXT)”””) cur.execute(“””CREATE TABLE IF NOT EXISTS memories( id TEXT PRIMARY KEY,user_id TEXT,kind TEXT,content TEXT,tags TEXT,importance REAL,ts TEXT)”””) cur.execute(“””CREATE TABLE IF NOT EXISTS weak_topics( user_id TEXT,topic TEXT,mastery REAL,last_seen TEXT,notes TEXT,PRIMARY KEY(user_id,topic))”””) c.commit(); c.close() We set up the execution environment and import all required libraries for building a stateful agent. We also define core paths and utility functions for time handling and database connections. It establishes the foundational infrastructure that the rest of the system relies on. Copy CodeCopiedUse a different Browser class MemoryItem(BaseModel): kind:str content:str tags:List[str]=Field(default_factory=list) importance:float=Field(0.5,ge=0,le=1) class WeakTopicSignal(BaseModel): topic:str signal:str evidence:str confidence:float=Field(0.5,ge=0,le=1) class Extracted(BaseModel): memories:List[MemoryItem]=Field(default_factory=list) weak_topics:List[WeakTopicSignal]=Field(default_factory=list) class FallbackTutorLLM(BaseChatModel): @property def _llm_type(self)->str: return “fallback_tutor” def _generate(self, messages, stop=None, run_manager=None, **kwargs)->ChatResult: last=messages[-1].content if messages else “” content=self._respond(last) return ChatResult(generations=[ChatGeneration(message=AIMessage(content=content))]) def _respond(self, text:str)->str: t=text.lower() if “extract_memories” in t: out={“memories”:[],”weak_topics”:[]} if “recursion” in t: out[“weak_topics”].append({“topic”:”recursion”,”signal”:”struggled”, “evidence”:”User indicates difficulty with recursion.”,”confidence”:0.85}) if “prefer” in t or “i like” in t: out[“memories”].append({“kind”:”preference”,”content”:”User prefers concise explanations with examples.”, “tags”:[“style”,”preference”],”importance”:0.55}) return json.dumps(out) if “generate_practice” in t: return “n”.join([ “Targeted Practice (Recursion):”, “1) Implement factorial(n) recursively, then iteratively.”, “2) Recursively sum a list; state the base case explicitly.”, “3) Recursive binary search; return index or -1.”, “4) Trace fibonacci(6) call tree; count repeated subcalls.”, “5) Recursively reverse a string; discuss time/space.”, “Mini-quiz: Why does missing a base case cause infinite recursion?” ]) return “Tell me what you’re studying and what felt hard; I’ll remember and adapt practice next time.” def get_llm(): key=os.environ.get(“OPENAI_API_KEY”,””).strip() if key: from langchain_openai import ChatOpenAI return ChatOpenAI(model=”gpt-4o-mini”,temperature=0.2) return FallbackTutorLLM() We define the database schema and initialize persistent storage for events, memories, and weak topics. We ensure that user interactions and long-term learning signals are stored reliably across sessions. It enables agent memory to be durable beyond a single run. Copy CodeCopiedUse a different Browser EMBED_MODEL=”sentence-transformers/all-MiniLM-L6-v2″ embedder=SentenceTransformer(EMBED_MODEL) def load_meta(): if os.path.exists(META_PATH): with open(META_PATH,”r”) as f: return json.load(f) return [] def save_meta(meta): with open(META_PATH,”w”) as f: json.dump(meta,f) def normalize(x): n=np.linalg.norm(x,axis=1,keepdims=True)+1e-12 return x/n def load_index(dim): if os.path.exists(INDEX_PATH): return faiss.read_index(INDEX_PATH) return faiss.IndexFlatIP(dim) def save_index(ix): faiss.write_index(ix, INDEX_PATH) EXTRACTOR_SYSTEM = ( “You are a memory extractor for a stateful personal tutor.n” “Return ONLY JSON with keys: memories (list of {kind,content,tags,importance}) ” “and weak_topics (list of {topic,signal,evidence,confidence}).n” “Store durable info only; do not store secrets.” ) llm=get_llm() init_db() dim=embedder.encode([“x”],convert_to_numpy=True).shape[1] ix=load_index(dim) meta=load_meta() We define the data models and the fallback language model used when no external API key is available. We formalize how memories and weak-topic signals are represented and extracted. It allows the agent to consistently convert raw conversations into structured, actionable memory. Copy CodeCopiedUse a different Browser def log_event(user_id, session_id, role, content): c=db(); cur=c.cursor() cur.execute(“INSERT INTO events VALUES (?,?,?,?,?,?)”, (str(uuid.uuid4()),user_id,session_id,role,content,now())) c.commit(); c.close() def upsert_weak(user_id, sig:WeakTopicSignal): c=db(); cur=c.cursor() cur.execute(“SELECT mastery,notes FROM weak_topics WHERE user_id=? AND topic=?”,(user_id,sig.topic)) row=cur.fetchone() delta=(-0.10 if sig.signal==”struggled” else 0.10 if sig.signal==”improved” else 0.0)*sig.confidence if row is None: mastery=float(np.clip(0.5+delta,0,1)); notes=sig.evidence cur.execute(“INSERT INTO weak_topics VALUES (?,?,?,?,?)”,(user_id,sig.topic,mastery,now(),notes)) else: mastery=float(np.clip(row[0]+delta,0,1)); notes=(row[1]+” | “+sig.evidence)[-2000:] cur.execute(“UPDATE weak_topics SET mastery=?,last_seen=?,notes=? WHERE user_id=? AND topic=?”, (mastery,now(),notes,user_id,sig.topic)) c.commit(); c.close() def store_memory(user_id, m:MemoryItem): mem_id=str(uuid.uuid4()) c=db(); cur=c.cursor() cur.execute(“INSERT INTO memories VALUES (?,?,?,?,?,?,?)”, (mem_id,user_id,m.kind,m.content,json.dumps(m.tags),float(m.importance),now())) c.commit(); c.close() v=embedder.encode([m.content],convert_to_numpy=True).astype(“float32”) v=normalize(v); ix.add(v) meta.append({“mem_id”:mem_id,”user_id”:user_id,”kind”:m.kind,”content”:m.content, “tags”:m.tags,”importance”:m.importance,”ts”:now()}) save_index(ix); save_meta(meta) We focus on embedding-based semantic memory using vector representations and similarity search. We encode memories, store them in a vector index, and persist metadata for later retrieval. It enables relevance-based recall rather than blindly loading all past context. Copy CodeCopiedUse a different Browser def extract(user_text)->Extracted: msg=”extract_memoriesnnUser message:n”+user_text r=llm.invoke([SystemMessage(content=EXTRACTOR_SYSTEM),HumanMessage(content=msg)]).content try: d=json.loads(r) return Extracted( memories=[MemoryItem(**x) for x in d.get(“memories”,[])], weak_topics=[WeakTopicSignal(**x) for x in d.get(“weak_topics”,[])] ) except: return Extracted() def recall(user_id, query, k=6): if ix.ntotal==0: return [] q=embedder.encode([query],convert_to_numpy=True).astype(“float32”) q=normalize(q) scores, idxs = ix.search(q,k) out=[] for s,i in zip(scores[0].tolist(), idxs[0].tolist()): if i<0 or i>=len(meta): continue m=meta[i] if m[“user_id”]!=user_id or s<0.25: continue out.append({**m,”score”:float(s)}) out.sort(key=lambda r: r[“score”]*(0.6+0.4*r[“importance”]), reverse=True) return out def weak_snapshot(user_id): c=db(); cur=c.cursor() cur.execute(“SELECT topic,mastery,last_seen FROM weak_topics WHERE user_id=? ORDER BY mastery ASC LIMIT 5”,(user_id,)) rows=cur.fetchall(); c.close() return [{“topic”:t,”mastery”:float(m),”last_seen”:ls} for t,m,ls in rows] def tutor_turn(user_id, session_id, user_text): log_event(user_id,session_id,”user”,user_text) ex=extract(user_text) for w in ex.weak_topics: upsert_weak(user_id,w) for m in ex.memories: store_memory(user_id,m) rel=recall(user_id,user_text,k=6) weak=weak_snapshot(user_id) prompt={ “recalled_memories”:[{“kind”:x[“kind”],”content”:x[“content”],”score”:x[“score”]} for x in rel], “weak_topics”:weak, “user_message”:user_text } gen = llm.invoke([SystemMessage(content=”You are a personal tutor. Use recalled_memories only if relevant.”), HumanMessage(content=”generate_practicenn”+json.dumps(prompt))]).content log_event(user_id,session_id,”assistant”,gen) return gen, rel, weak USER_ID=”user_demo” SESSION_ID=str(uuid.uuid4()) print(” Ready. Example run:n”) ans, rel, weak = tutor_turn(USER_ID, SESSION_ID, “Last week I struggled with recursion. I prefer concise explanations.”) print(ans) print(“nRecalled:”, [r[“content”] for r in rel]) print(“Weak topics:”, weak) We orchestrate the full tutor interaction loop, combining extraction, storage, recall, and response generation. We update mastery scores, retrieve relevant memories, and dynamically generate targeted practice. It completes the transformation from a stateless chatbot into a long-term, adaptive tutor. In conclusion, we implemented a tutor agent that remembers, reasons, and adapts across sessions. We showed how structured memory extraction, long-term persistence, and relevance-based recall work together to overcome the “goldfish memory” limitation common in most agents. The resulting system continuously refines its understanding of a user’s weaknesses. It proactively generates targeted practice, demonstrating a practical foundation for building stateful, long-horizon AI agents that improve with sustained interaction. Check out the Full Codes here. Also, feel