ai

My agent's memory only ever grew, so I built a weekly no-agent cron that turns seven days of messages into a ratify-it-myself candidate report.

TL;DR: The author audited their agent's memory files and found everything only accumulates, never gets pruned or corrected. ChatGPT and Letta solve this with out-of-band batch synthesis, so the author built a weekly Python script that generates a candidate report instead. They insist on manual ratification since a single fabricated entry could poison a single-agent setup.

Queries returned just a path and a score. So I stole OpenViking's L0 summary pattern: one line per dossier, no new infrastructure.

TL;DR: Search results in my knowledge base showed only scores, so I kept opening dossiers just to judge relevance. Rather than install OpenViking, I stole its L0 tier pattern and added a mandatory one-line summary field to each dossier in about 40 lines of Python. Making summaries a hard requirement keeps them consistent, no new dependency needed.

ChatGPT memory is not a real-time summary of your sessions. I break down the real mechanism: periodic synthesis, system prompt injection, and the privacy cost.

TL;DR: ChatGPT doesn't scan your chat history with RAG. Instead, it periodically synthesizes your conversations into a static profile injected into every new session's system prompt, including roughly your last 40 typed messages. Since deleting one chat won't erase derived insights, treat memory as a managed archive, not a perfect record.

A repo with many coding agents needs more than one instruction file: AGENTS.md for procedures, user memory for preferences, a fact store for on-demand facts.

TL;DR: Repeated agent mistakes in a repo pointed to missing documentation, not a bad agent. The fix is a three-layer setup: AGENTS.md for repo procedures, user memory for personal preferences, and a fact store for reference material. Claude Code reads the same rules through a CLAUDE.md that imports AGENTS.md, keeping every session consistent.

A plain-language glossary of AI agent terms from primary sources: agent vs workflow, skills, three kinds of memory, RAG, and pipelines.

TL;DR: Agents decide their own next steps while workflows run on fixed code paths, and the distinction comes down to who holds the steering wheel. Skills are procedural SOP files loaded only when needed, unlike memory, which carries procedural, semantic, or episodic information across sessions. Pipelines add triggers, gates, and watchdogs to make autonomous agents trustworthy.

A blog pipeline that researches, writes, verifies, and publishes on its own, plus the four gates that make it trustworthy.

TL;DR: The author's blog publishes articles fully automatically via a 2-hour cron pipeline that researches, drafts, verifies, and posts without human touch. Safety comes from strong brakes: verification gates that reject bad content, automatic rollback after publishing, and escalation to humans for taste calls. Full-auto is trusted only for mechanical tasks; editorial judgment stays human.

A per-need comparison of ChatGPT, Claude, Gemini, and Perplexity, plus where consumer assistants meet self-hosted agent runtimes: OpenClaw, Hermes Agent, and Agent Zero.

TL;DR: The best AI assistant in 2026 is no longer about the smartest chatbot but about persistence and autonomy. Pair a strong brain like ChatGPT or Claude with a self-hosted agent runtime such as OpenClaw, Hermes Agent, or Agent Zero for memory and autonomous execution. Go hybrid: match tools to your workflow instead of chasing one all-in-one winner.

Search snippets claimed 95-96% on SWE-bench Verified. The official board says 79.2%. Four rules to keep benchmark numbers honest.

TL;DR: The author checked the actual SWE-bench Verified leaderboard and found the top score is 79.20%, not the 95%+ figures circulating in search snippets. The gap exposed how easily benchmark numbers get cited without opening primary sources. The fix: log access dates, trust only opened primaries, snippets lose conflicts, report tied scores as-is.

A chatbot needs both a quick summary and a full explanation from one LLM generation. The answer: marker-based splitting in the SSE stream, with separate cache storage and mid-stream parsing.