标签：#AI

Originally published on tamiz.pro . 1. Introduction: The Memory Hype Cycle AI agent memory has become the latest battleground for vendor differentiation. Whether you're evaluating a vector database, a long-term memory module for an LLM application, or a full cognitive architecture, the marketing claims are strikingly consistent: "infinite context," "perfect recall," and "zero latency." In practice, these claims collapse under the weight of real workloads. This article is a deep-dive into how to benchmark AI memory systems rigorously and reproducibly . We will move beyond synthetic README benchmarks and build a testing methodology that surfaces the trade-offs you will actually face in production. The focus is on agent memory —the systems that allow a conversational agent to remember prior interactions, user preferences, and long-term facts—but the principles apply to any retrieval-augmented or context-window extension system. 2. What Is Agent Memory, Anyway? Before benchmarking, we must clarify the taxonomy of memory systems commonly used in AI agents. This prevents us from comparing apples to oranges. 2.1 Short-Term vs. Long-Term Memory Short-Term Memory (STM) is the context window of the LLM. It is volatile, limited by token count, and costly to extend linearly. Long-Term Memory (LTM) is an external store (vector database, knowledge graph, or relational store) that the agent queries to augment its context. 2.2 Memory Architectures Architecture Description Typical Latency Failure Mode Vector Store + Retrieval Embed documents; retrieve top-k by cosine similarity 10–100 ms Semantic drift, retrieval misses Recurrent Summary Summarize old context into a compressed state 50–500 ms Information loss, hallucination injection Structured Slot Memory Extract entities/attributes into a database table 5–50 ms Schema mismatch, missing slots Neural Memory (e.g., MemGPT) Trainable memory module with read/write heads 10–100 ms Catastrophic forgetting, training instability A robust b

A Reddit thread on connecting Claude Code to a Yahoo Mail account turned into a solid field guide for scoping down what an AI agent is allowed to touch. Here's the distilled version. Don't give Claude Code your Yahoo password or unrestricted mailbox access. The risk isn't only the password leaking, it's that an agent with full access can read private messages, attachments, recovery details, and information about other people, all in the course of doing something mundane. Why "just connect it" is the wrong instinct The thread's most-quoted line frames the problem well: people are casually handing agents the keys to everything at once. People are talking about just giving ai agents access to their entire devices LOL. Emails, passwords, bank accounts like what. The concern isn't that the agent will maliciously steal your data, it's that broad access creates exposure you didn't intend, every time the agent reads something to complete an unrelated task. The issue isnt really theft its exposure. And exposure scales with trust you've already granted, not with anything going wrong: It's all based on trust. Safer ways to connect it 1. OAuth over password Use a connection method where Yahoo shows you exactly what's being requested and lets you revoke it later. Never type your Yahoo login directly into the agent. 2. Least access, read-only Point it at a separate, low-value mailbox if you can. Avoid granting send, delete, forward, or account-settings permissions; the agent shouldn't be able to act as you. 3. Keep credentials out of the agent The safer pattern is a credential vault the agent calls out to, so it can request an authenticated action without ever seeing the raw secret. Before you connect anything ✅ Strip sensitive mail first. One commenter's habit: swap real details for placeholders and dummy data, then substitute the real values back in once the model's output comes back. ✅ Use a throwaway or secondary account. Never connect the address tied to banking, password re

Gate your CI on a dollar ceiling, not a percentage — the number your finance team actually asks for Most cost gates for agent/LLM workflows check a delta : did this PR make the run more expensive than the last one, by more than X%? That's a good regression alarm. But it answers a developer's question ("did I make it worse?"), not a budget owner's question ("are we going to blow the monthly number?"). Those are genuinely different gates, and a team that only has the percentage one keeps getting surprised. A workflow can pass every percentage check — each PR adds a harmless-looking 3% — and still cross the line where the absolute monthly spend stops being okay. Percentages compound quietly; dollars are what shows up on the invoice. So the second gate I want on any agent workflow is an absolute ceiling : "a single run of this job must not cost more than $N," full stop, regardless of whether it went up or down since yesterday. Three things make that gate actually usable rather than theater: 1. The ceiling is priced, not token-counted. "Under 2M tokens" is meaningless to the person who signs off on spend, because a token of Opus output and a token of cached Haiku input differ by ~100× in price. The gate has to multiply each token bucket (input, output, cache-write at ~1.25×, cache-read at ~0.1×) by that model's real per-token price and sum to an actual dollar figure. If your gate reports tokens and makes a human convert, nobody converts, and the ceiling drifts. 2. The ceiling is per-run and per-workflow, not global. A nightly full-repo audit and a per-PR lint agent have wildly different legitimate costs; one global number is either too loose for the small job or too tight for the big one. You want to set max-usd on the specific workflow, so each job carries the ceiling that matches what it's for . 3. It shows the headroom, not just pass/fail. "$0.43 of a $0.50 ceiling — 86%" on every run is the line that lets you move the limit before it starts failing builds, instead of

At D23, when asked about the potential for a sequel to the cult classic The Simpsons: Hit & Run game, Matt Groening replied, "I think the original game is coming back in some form," before current showrunner Matt Selman added, "or not." The tone in both of their voices and the body language suggests that […]

Spend an afternoon browsing new AI startups and a strange déjà vu sets in. The landing pages rhyme. There is a dark hero section, a gradient somewhere between indigo and violet, a little sparkle or star icon denoting Intelligence, a headline promising to let you “chat with” your documents or data or customers, and a demo video with the same upbeat, slightly anonymous soundtrack. You could swap the logos between fifty of these sites and almost nobody would notice. Sameness on the surface Some of this is just design fashion, and design fashions always converge. But the AI cohort has converged harder and faster than most, and the reason is worth naming: when everyone is building on top of the same handful of foundation models , the differentiation has to come from somewhere else , and branding is the cheapest lever to pull. If your product is a thin layer over a model anyone can call, you cannot differentiate on the model, so you differentiate on the gradient. When the engine is a commodity everyone rents, the paint job is the only thing left to argue about. Hence a thousand identical paint jobs. Funded by the same money, chasing the same story The uniformity runs deeper than design and architecture; it reaches into the incentives. A great many of these companies are funded by the same pools of venture capital, pitched against the same market maps, and steered toward the same narrative arc — explosive growth now, monetisation later, an acquisition or an IPO at the end. When the funding, the advice and the definition of success are shared, the strategies converge. Everyone chases the same enterprise customers, adopts the same land-grab pricing, and races the same clock, because that is the shape of company the money was betting on. This produces a cohort that is not only visually and technically alike but strategically alike, which makes the whole field unusually fragile to the same shocks. A shift in model pricing, a change in what the platform providers offer natively

Watch enough AI launches and they begin to blur into a single, endlessly repeating event. There is the understated title slide. The claim that we are at an inflection point. The chart showing the new model clearing a row of benchmarks. The live demo that works flawlessly. The superlatives — most capable, most advanced, our best model yet. And the closing note that all of this will roll out “over the coming weeks,” which is to say, not today, and possibly not to you. It is a genre now, with conventions as fixed as a nature documentary, and once you see the template you cannot unsee it. The conventions of the genre Every mature format has its tropes. The AI launch has assembled a reliable set: The benchmark chart — which, as we argued in our piece on benchmarks , predicts your experience far less than its prominence implies. The cherry-picked demo — a single, gorgeous example that represents the top of the model's range, not its average day. The superlative — always “most capable,” because every model is the most capable at the instant it ships, until the next one three months later. The vague availability — “rolling out over the coming weeks,” a phrase that lets the announcement bank the excitement now and deliver the substance later, to some users, eventually. The safety paragraph — a brief, serious note about responsible deployment, positioned to reassure without committing to specifics. When every launch uses the same script, the script stops conveying information and starts conveying mood. The mood is always “inevitable progress.” The relentless cadence is part of the message The sheer frequency of these launches is itself a rhetorical device, whether or not anyone intends it that way. When a major model or feature is announced every few weeks, the cumulative effect is a drumbeat of perpetual acceleration — a sense that the field is moving so fast that to pause, to doubt, or to ask whether the last release actually delivered is to risk being left behind. The pace

La mayoría de los "agentes con memoria" recuerdan datos : un string, un hecho, una preferencia. Pero cuando hablas semanas con un agente, lo que quieres no es una base de datos con tus notas. Quieres que recuerde vuestra historia : el día que conociste a su perro, la vez que os reísteis de una idea absurda, lo que prometisteis hacer juntos. Y, sobre todo, quieres que no confunda lo real con lo soñado . Por eso construí OurBook : un servidor MCP de memoria narrativa . El agente no guarda tus datos: guarda vuestra vida en común, con emoción, con un diario que se escribe cada noche y con sueños que consolidan los recuerdos — sin contaminarlos jamás. El problema Los MCP de memoria actuales son utilitarios: almacenan y buscan hechos. Eso genera tres fallos conocidos: Confabulación — el agente inventa y lo presenta como recuerdo real. Contexto que no escala — inyectar todo en cada prompt es caro y se desborda. Sin identidad — cambias de modelo o de máquina y el "personaje" desaparece. OurBook cambia el marco: la memoria como identidad narrativa . Lo que lo hace diferente 1. Taxonomía de veracidad (la capa de honestidad) Cada recuerdo tiene un campo veracity : real , observed , imagined (sueño/ficción) o hypothetical . El recall factual excluye por defecto los sueños: un sueño nunca se presenta como hecho. Esto ataca de raíz la confabulación. 2. Soñar = consolidar (neurociencia aplicada) El motor Mnemosyne muestrea fragmentos por saliencia emocional (importancia × valencia) y los recombina en un sueño — como el replay hipocampal durante el sueño. Cada sueño guarda sus fuentes , para que sea ficción honesta y trazable. 3. Doble cerebro: 0 tokens de tu API principal El modelo principal solo pone la voz. Soñar, consolidar y etiquetar corre en Mnemosyne con cadena de fallback: qwen-reverse → local (Ollama/LM Studio) → offline determinista (nunca falla) . Cada llamada queda auditada en engine_log . 4. El libro y la semilla de identidad Todo se exporta a OurBook.md / .html (crón

I wanted a simple WhatsApp AI bot without paying every month for cloud hosting or an AI API. So I built one that runs on a Windows PC I already have running 24/7. The result: WhatsApp integration with Node.js Optional local AI using Ollama No VPS or cloud server required No paid AI API required Runs on Windows 10/11 Can restart automatically after a reboot «The "$0/month" refers to additional software, hosting, and AI API costs. It assumes you already have the PC, internet connection, and electricity.» The basic architecture The setup is intentionally simple: WhatsApp → Node.js bot → Local AI → WhatsApp reply The Node.js application handles incoming WhatsApp messages and decides how to respond. For AI responses, the bot can send the user's message to a locally running Ollama model and return the generated answer back to WhatsApp. That gives us: WhatsApp → Node.js → Ollama on localhost → Node.js → WhatsApp No cloud AI API is required. What you need For the basic setup: Windows 10 or Windows 11 Node.js LTS A WhatsApp account Ollama if you want local AI A computer that can stay powered on You don't need Kubernetes. You don't need AWS. You don't need Docker. And you don't need to rent a VPS. Connecting WhatsApp For this project I used "whatsapp-web.js". The first time the application starts, it displays a QR code. You scan the QR code with WhatsApp, similar to connecting WhatsApp Web. After authentication, the application can listen for incoming messages and send replies. A simplified example looks like this: const { Client, LocalAuth } = require('whatsapp-web.js'); const client = new Client({ authStrategy: new LocalAuth() }); client.on('qr', (qr) => { console.log('Scan the QR code to connect WhatsApp'); }); client.on('ready', () => { console.log('WhatsApp bot is ready'); }); client.on('message', async (message) => { if (message.body.toLowerCase() === 'hello') { await message.reply('Hello from the bot!'); } }); client.initialize(); "LocalAuth" stores the authenticated W

The woman claimed that AI tools are "taking everyday life and turning it into child sexual abuse."

Also: Ahsoka S2 teaser, Doomsday trailer, news about MCU's X-Men and Star Wars: Starfighter

Your AI Slop Bores Me is brilliant in its simplicity. There are two tabs: human and LARP as an AI. On one side you enter a request. On the other, you submit an answer. But the important thing is that there's a human on both sides of the equation. Prompts can request a response as […]

How will the watermarking actually work? Can it be hidden with editing? And how does this affect code?

For years, the CMS ecosystem has largely followed the same formula. Install a CMS. Choose a theme. Install plugins. Customize some templates. Add an API when you need one. Then, eventually, try to connect everything to AI. But the way we build software has changed. Developers increasingly work alongside AI coding assistants. People are building websites by describing what they want instead of manually implementing every component. AI agents can now interact with external tools and services. APIs are becoming the foundation rather than an optional feature. Yet many traditional CMS architectures were designed for a world where a human administrator was the primary interface. That is the problem Basehim is trying to solve. Basehim is an open-source, modular, API-first PHP CMS built for developers, AI-assisted development, and the emerging world of AI agents. The goal isn't to replace every CMS. The goal is to provide a simpler foundation for people who want to build, customize, automate, and extend websites without being forced into a complicated infrastructure stack. The idea behind Basehim Basehim started with a fairly simple observation: The web is still full of ordinary PHP hosting. Millions of websites run on environments such as cPanel, Plesk, Apache, MySQL, and shared hosting. Yet many modern development tools increasingly assume that you have SSH access, Composer, Node.js, a build pipeline, background workers, containers, or a cloud deployment environment. Those tools are excellent when you need them. But they aren't always necessary for a CMS. Basehim takes a different approach. If your server can run modern PHP and MySQL or MariaDB, Basehim is designed to run there. You can upload the files, open the installer, configure the database, create the administrator account, and start building. There is no required Composer installation. There is no frontend build process. There is no daemon that has to remain running. There is no requirement for a public/ directory

Welcome back to the Harness Engineering series — a 10-part journey from raw language model to production-ready agentic system. Made by builders. For builders. In Part 7, I closed on a line worth expanding: "I built an agent" vs "I built an agent I can actually operate." The difference between those two sentences is the sixth and final component of the harness. It's called Observability , and without it, everything else you've read in this series is a bet you can't check. Every previous component in this series does something the agent needs to work. Observability does something the engineer needs — to see what happened, to know when things are going wrong, and to have any hope of making the harness better over time. What's ahead: Part 1: The Raw Model Problem Part 2: Defining the Harness — The Six Components Part 3: The Control Loop Part 4: The Tool Layer Part 5: Context Engineering Part 6: The Filesystem & Environment Part 7: The Memory Layer Observability ← You are here Part 9: The Harness Architecture Part 10: Decomposing Claude Code By the end of this article, you'll know what Observability actually is, why non-deterministic multi-step systems can't be operated without it, and the three properties — full-fidelity logs, session-level traces, and fixed evals — that separate a real observability setup from an aspirational one. Let's get started. 📚 Want to go deeper than the articles? While you follow along with this series, I've put together two hands-on resources that go further than any single article can: Build a Harness from Scratch — Udemy Course — A self-paced course where I walk you through building a production-grade agentic harness from the ground up, in code. Harness Engineering for AI Agents — Live Maven Workshop — A live, cohort-based workshop for builders who want direct feedback, Q&A, and to work through the material with peers. Both are optional — the series stands on its own. But if you want the full studio-quality version, that's where it lives. Wh

Welcome back to the Harness Engineering series — a 10-part journey from raw language model to production-ready agentic system. Made by builders. For builders. In Part 6, we closed on a limitation the previous four components can't solve on their own: the agent forgets. Once a session ends — or the context window fills up mid-task — everything the agent learned, discovered, or decided vanishes. Next time the user comes back, the agent greets them like a stranger. Next time the token budget runs out, earlier turns get truncated away, and the agent's earlier reasoning is just gone. That's the gap this article closes. The Memory Layer is how the harness gives the agent persistence — inside a task, and across sessions. What's ahead: Part 1: The Raw Model Problem Part 2: Defining the Harness — The Six Components Part 3: The Control Loop Part 4: The Tool Layer Part 5: Context Engineering Part 6: The Filesystem & Environment The Memory Layer ← You are here Part 8: Observability Part 9: The Harness Architecture Part 10: Decomposing Claude Code By the end of this article, you'll know what a Memory Layer actually is, why short-term and long-term memory are two different systems (not one with a dial), and the three design decisions — flavor, write triggers, and bounded retrieval — that separate a real memory system from a naive one. Let's get started. 📚 Want to go deeper than the articles? While you follow along with this series, I've put together two hands-on resources that go further than any single article can: Build a Harness from Scratch — Udemy Course — A self-paced course where I walk you through building a production-grade agentic harness from the ground up, in code. Harness Engineering for AI Agents — Live Maven Workshop — A live, cohort-based workshop for builders who want direct feedback, Q&A, and to work through the material with peers. Both are optional — the series stands on its own. But if you want the full studio-quality version, that's where it lives. What The

Welcome back to the Harness Engineering series — a 10-part journey from raw language model to production-ready agentic system. Made by builders. For builders. In Part 5, we looked at the Context — the payload the model sees on every call. Now we look at what happens after the model, having seen that Context, decides to do something. The model calls a tool. The tool has to execute somewhere. That somewhere is the Environment . It's easy to under-appreciate. The Environment feels like plumbing — the filesystem, the shell, the network, the machine underneath. But it's where every side effect the model requests actually lands, and how you design it is what separates "an AI agent doing things on your behalf" from scary to routine . What's ahead: Part 1: The Raw Model Problem Part 2: Defining the Harness — The Six Components Part 3: The Control Loop Part 4: The Tool Layer Part 5: Context Engineering The Filesystem & Environment ← You are here Part 7: The Memory Layer Part 8: Observability Part 9: The Harness Architecture Part 10: Decomposing Claude Code By the end of this article, you'll know what the Environment actually is, why every tool with side effects depends on it, and the three properties (bounded, reproducible, inspectable) that separate a production-ready environment from a demo one. Let's get started. 📚 Want to go deeper than the articles? While you follow along with this series, I've put together two hands-on resources that go further than any single article can: Build a Harness from Scratch — Udemy Course — A self-paced course where I walk you through building a production-grade agentic harness from the ground up, in code. Harness Engineering for AI Agents — Live Maven Workshop — A live, cohort-based workshop for builders who want direct feedback, Q&A, and to work through the material with peers. Both are optional — the series stands on its own. But if you want the full studio-quality version, that's where it lives. What The Environment Is The Environment is

Welcome back to the Harness Engineering series — a 10-part journey from raw language model to production-ready agentic system. Made by builders. For builders. In Part 4, we looked at the Tools — the set of functions the model can call. But there's still one big open question hanging over every turn of the Loop: what does the model actually see when the Loop calls it? The answer is: whatever the harness put in the payload. That payload — the entire package of instructions, history, retrieved documents, tool definitions, and everything else — is called the Context . Some readers know this territory under an older name: prompt engineering . That name isn't wrong, but it's narrow. A prompt sounds like something you write once and ship. The reality of running an agent is that the payload changes every turn, and designing what goes in it is an ongoing discipline. Hence the newer, more accurate term: context engineering . What's ahead: Part 1: The Raw Model Problem Part 2: Defining the Harness — The Six Components Part 3: The Control Loop Part 4: The Tool Layer Context Engineering ← You are here Part 6: The Filesystem & Environment Part 7: The Memory Layer Part 8: Observability Part 9: The Harness Architecture Part 10: Decomposing Claude Code By the end of this article, you'll know what the Context actually is, why every turn forces you to answer "what should the model know right now?" from scratch, and the three moving pieces (system prompt, history, retrieval) that make up a well-designed context. Let's get started. 📚 Want to go deeper than the articles? While you follow along with this series, I've put together two hands-on resources that go further than any single article can: Build a Harness from Scratch — Udemy Course — A self-paced course where I walk you through building a production-grade agentic harness from the ground up, in code. Harness Engineering for AI Agents — Live Maven Workshop — A live, cohort-based workshop for builders who want direct feedback, Q&A, a

Building FinSaathi: A Voice-First AI Financial Assistant Financial information can be difficult to understand. Banking terms, loans, credit scores, payments, and other financial decisions can quickly become overwhelming when users have to navigate everything through forms and complicated interfaces. So I wanted to explore a simpler interaction: What if financial guidance could start with a conversation? That idea became FinSaathi , a voice-first AI financial assistant. What I Built The first goal was simple: get a real-time voice assistant working end-to-end and deploy it. The current architecture is: Next.js Frontend → LiveKit → Python AI Agent → Voice/AI Services The frontend is deployed on Vercel, while the LiveKit agent is deployed on Railway. Users can open the application, start a conversation, and interact with the FinSaathi agent through voice. The Tech Stack Frontend Next.js React TypeScript LiveKit Components Tailwind CSS Vercel Backend Python LiveKit Agents UV Docker Railway Voice / AI LiveKit Murf AI/LLM services Data SQLite for application memory and call-related data The Part That Took More Time Than Expected Getting the agent to work locally was relatively straightforward. Getting the same system to actually run in production was a different problem. The Railway deployment initially failed with: python: can't open file '//src/agent.py': [Errno 2] No such file or directory The problem turned out to be related to how the application path and startup command were being handled inside the Docker deployment. After fixing the container and Railway startup configuration, the deployment moved further — and exposed another issue. Because the container runs the application as a non-root user, UV initially could not create its cache directory: Permission denied: '/app/.cache/uv' Fixing the permissions allowed the actual LiveKit AgentServer to start successfully. The production logs then showed the agent listening for connections and registering its worker with L

Welcome back to the Harness Engineering series — a 10-part journey from raw language model to production-ready agentic system. Made by builders. For builders. In Part 3, we looked at the Loop — the outermost machinery of a harness, the piece that drives everything else. But a Loop on its own is a hollow shell. It calls the model. The model responds. And then, if the model wants to affect anything outside the text it just produced, it needs to reach for a tool. That's what this article is about: the Tool Layer. The set of functions the harness makes available to the model, and the design decisions that separate a tool surface a model can actually use from one that constantly frustrates it. What's ahead: Part 1: The Raw Model Problem Part 2: Defining the Harness — The Six Components Part 3: The Control Loop The Tool Layer ← You are here Part 5: Context Engineering Part 6: The Filesystem & Environment Part 7: The Memory Layer Part 8: Observability Part 9: The Harness Architecture Part 10: Decomposing Claude Code By the end of this article, you'll know what tools actually are, why they exist, and — more usefully — how to tell a well-designed tool surface from a badly-designed one the moment you look at one. Let's get started. 📚 Want to go deeper than the articles? While you follow along with this series, I've put together two hands-on resources that go further than any single article can: Build a Harness from Scratch — Udemy Course — A self-paced course where I walk you through building a production-grade agentic harness from the ground up, in code. Harness Engineering for AI Agents — Live Maven Workshop — A live, cohort-based workshop for builders who want direct feedback, Q&A, and to work through the material with peers. Both are optional — the series stands on its own. But if you want the full studio-quality version, that's where it lives. What The Tools Are The Tools are the set of functions the harness exposes to the model. Concretely: the harness tells the model "

Anthropic has explained its text watermarking approach.