Agent Memory on ICE-ICE-BEAR-BLOG

The OS Layer for AI Coding Agents — agentmemory and agent-skills Land the Same Day

Fri, 08 May 2026 00:00:00 +0900

Overview

Two GitHub links, dropped 30 seconds apart at the same minute. Both target ergonomic gaps in AI coding agents, but they target different gaps. rohitg00/agentmemory tackles cross-session memory infrastructure; addyosmani/agent-skills tackles senior-engineer workflow enforcement. Read together, they sketch out an emerging OS layer for the agent era.

graph TD
 Agent["AI coding agent"] --> Memory["Memory / state layer"]
 Agent --> Skills["Workflow / rules layer"]
 Agent --> Model["Model layer"]
 Agent --> UI["UI layer"]

 Memory --> AM["agentmemory <br/> MCP + REST"]
 Skills --> AS["agent-skills <br/> Markdown skill bundle"]
 Model --> LLM["Claude / GPT / Gemini"]
 UI --> Tools["Claude Code / Cursor / Cline"]

1. agentmemory — Persistent Memory Shared Across Every Agent via MCP

rohitg00/agentmemory brands itself as "#1 Persistent memory for AI coding agents based on real-world benchmarks." Created 2026-02-25, ~2,400 stars, Apache 2.0. Project home: agent-memory.dev.

The problem it solves

Re-explaining the architecture to the agent every session
Rediscovering the same bug
Re-teaching the same preferences (library choices, code style)
Built-in memory like CLAUDE.md or .cursorrules is capped at 200 lines and goes stale fast

How it works

The agent silently captures what it does → compresses → stores as searchable memory → injects only the relevant context at the start of the next session. The key trick: stand up a single MCP server and 16+ agents share the same memory.

Supported clients:

Claude Code · Cursor · Gemini CLI · Codex CLI
Cline · Goose · Windsurf · Roo Code · OpenCode
Any agent without MCP can connect via REST (104 endpoints)

Embeddings run locally with all-MiniLM-L6-v2 — no API keys, free.

Benchmark — LongMemEval-S

Numbers on LongMemEval (ICLR 2025, 500 questions):

Metric	agentmemory	BM25 fallback
R@5	95.2%	86.2%
R@10	98.6%	—
MRR	88.2%	—

Hybrid embedding retrieval beats keyword-only BM25 by 9 percentage points on R@5.

Token cost

Approach	Annual tokens	Annual cost
Full context paste	19.5M+	Exceeds context window
LLM-summarized	~650K	~$500
agentmemory	~170K	~$10
agentmemory + local embeddings	~170K	$0

Quick start

npx @agentmemory/agentmemory

What it really argues

The bet underneath agentmemory is one sentence — “memory belongs in the infrastructure layer, not the agent.” Instead of every agent writing its own memory, one MCP server fans out to all of them. Whatever Claude Code learns flows into the next Cursor session intact. The project started about 50 days earlier as a viral GitHub gist (1,050 stars) and is essentially that design doc rendered into code: Karpathy’s LLM Wiki pattern plus confidence scoring, lifecycle, knowledge graph, and hybrid search.

2. agent-skills — Senior-Engineer Workflow as a Skill Bundle

addyosmani/agent-skills calls itself “Production-grade engineering skills for AI coding agents.” Created 2026-02-15, ~33,500 stars, MIT. At the same point in time it has 14× the stars of agentmemory — currently the strongest candidate for an agent-workflow standard.

The problem it solves

“The agent writes code, but it doesn’t write code like a senior would.”

Skips the spec
Skips the tests
Doesn’t think about security
Drops a giant PR all at once

A six-stage lifecycle

DEFINE → PLAN → BUILD → VERIFY → REVIEW → SHIP
/spec /plan /build /test /review /ship

Each slash command corresponds to one lifecycle stage and auto-activates the right skills.

The 20 skills, by stage

Define: idea-refine, spec-driven-development
Plan: planning-and-task-breakdown
Build: incremental-implementation, test-driven-development, context-engineering, source-driven-development, frontend-ui-engineering, api-and-interface-design
Verify: browser-testing-with-devtools, debugging-and-error-recovery
Review: code-review-and-quality, code-simplification, security-and-hardening, performance-optimization
Ship: git-workflow-and-versioning, ci-cd-and-automation, deprecation-and-migration, documentation-and-adrs, shipping-and-launch

Where it runs

Claude Code (recommended, marketplace-installed): /plugin marketplace add addyosmani/agent-skills
Cursor: copy SKILL.md into .cursor/rules/
Gemini CLI · Windsurf · OpenCode · GitHub Copilot · Kiro IDE · Codex — anything that reads Markdown works

Agent personas

code-reviewer — Senior staff engineer lens, “would a staff engineer approve this?”
test-engineer — QA discipline, the Prove-It pattern
security-auditor — OWASP, threat modeling

What it really argues

agent-skills’ bet is “the difference between agents isn’t model weight — it’s how strictly the workflow is enforced.” TDD here isn’t “you can do TDD” — it’s “no Red-Green-Refactor, no code.” Code review isn’t a vibe; it’s five-axis review, 100-line size limits, explicit Nit/Optional/FYI severity labels. By expressing all of this in Markdown, it stays agent-agnostic — the same skill bundle works in Claude, Cursor, and Gemini. 33K stars is the market saying this is the closest thing to a workflow standard right now.

3. Side by side

Dimension	agentmemory	agent-skills
Author	rohitg00	addyosmani
Form	TypeScript library + MCP server	Markdown skill bundle
License	Apache 2.0	MIT
Stars (2026-05)	~2,400	~33,500
Created	2026-02-25	2026-02-15
Domain	Memory / state infrastructure	Engineering workflow
Decoupling mechanism	MCP standard	Markdown standard

4. The Combined Picture — An OS Layer for Agents

flowchart LR
 M["Memory / state"] --> AM["agentmemory"]
 W["Workflow / rules"] --> AS["agent-skills"]
 Mo["Model"] --> LLM["Claude / GPT / Gemini"]
 UI["UI"] --> Tools["Claude Code / Cursor / Cline"]

Three or four years ago “which IDE do you use?” was the deciding question. Now it’s becoming “what’s your memory and skills setup?” Both projects deliberately decouple from any one model — MCP for one, plain Markdown for the other — designed so that models can be swapped, but the memory and skills accumulate.

Insights

The headline of this digest isn’t either tool individually — it’s that two links shared 30 seconds apart fill exactly two distinct slots in the agent OS layer. agentmemory pulls state down into the infrastructure; agent-skills pulls process down into the infrastructure. The fact that both decouple from models in similar ways — one MCP server, one Markdown bundle — is the same bet from two angles: models are interchangeable but memory and skills must compound. The 33K vs 2.4K stars gap probably isn’t about timing; it’s a signal that the workflow-standard candidate is consolidating faster than the memory-infrastructure candidate. Two open questions for next quarter — does memory standardize on MCP, and do skill bundles like agent-skills become a new SaaS category inside IDE marketplaces? The decision point has already started shifting from IDE choice to memory and skill setup.

References

Core repos

rohitg00/agentmemory · home: agent-memory.dev
addyosmani/agent-skills

Related agents and clients

Claude Code · Cursor · Cline · Windsurf
Gemini CLI · Codex · OpenCode · Goose · Roo Code
GitHub Copilot · Kiro IDE

Protocols and standards

Model Context Protocol (MCP)
OWASP — basis for the security-auditor persona

Benchmarks and embeddings

Paper: LongMemEval (arXiv:2410.10813, ICLR 2025)
sentence-transformers/all-MiniLM-L6-v2 — local embedding model used by agentmemory

Three arxiv Papers That Drifted Through the Chat — Multiagent Debate, MIA, Husserlian Phenomenology

Wed, 06 May 2026 00:00:00 +0900

Overview

Three arxiv papers landed within a few days of each other. Different eras, different topics, different methods — but read together they answer one question, “where do further gains in AI agent reasoning come from?”, from three angles: cooperation, persistence, and structure. Right at the moment when single-model reasoning gains are visibly plateauing, this is a useful tour of where the next round’s keywords are coming from.

graph TD
 Q["Where do reasoning gains come from?"] --> Coop["Cooperation"]
 Q --> Pers["Persistence"]
 Q --> Struct["Structure"]

 Coop --> P1["Multiagent Debate <br/> 2305.14325 (2023)"]
 Pers --> P2["Memory Intelligence Agent <br/> 2604.04503 (2026)"]
 Struct --> P3["Husserl + Active Inference <br/> 2208.09058 (2022)"]

#	Paper	Year	One-line summary
1	Multiagent Debate	2023	Multiple LLM instances debating each other improve reasoning
2	Memory Intelligence Agent (MIA)	2026	Deep Research Agents need an evolving memory system
3	Husserlian Phenomenology + Active Inference	2022	The phenomenology of consciousness can be mapped to a computational model

1. Multiagent Debate — 2305.14325

Yilun Du, Shuang Li, Antonio Torralba, Joshua B. Tenenbaum, Igor Mordatch — MIT (2023-05). Accepted at ICLR 2025.

The idea

Instead of asking one LLM to reason harder, have several LLM instances propose answers and debate. Across multiple rounds they converge on a shared answer. It is essentially Marvin Minsky’s Society of Mind approach ported to LLMs.

Contribution

A multi-agent debate framework that improves mathematical and strategic reasoning
Reduces hallucinations, improves factual validity
Works on black-box LLMs as-is with the same prompt for every task — no fine-tuning required
The first clean result that lifts reasoning by inter-instance cooperation rather than single-model scaling

Why now

Although it is a May 2023 paper, the 2026 vantage point makes it more relevant. Single-model reasoning gains are visibly plateauing, and this dovetails with the parallel tool call push in GPT-Realtime-2. It is also the theoretical justification for why infrastructure tools like agent-skills are designed assuming many agents running concurrently.

2. Memory Intelligence Agent (MIA) — 2604.04503

Jingyang Qiao et al. (2026-04). A memory architecture paper aimed squarely at the Deep Research Agent family.

The idea

The weak link in Deep Research Agents — LLM reasoning combined with external tools — is memory. Conventional approaches (retrieving past trajectories) are inefficient, with storage and retrieval costs blowing up. MIA solves it with a Manager-Planner-Executor three-tier architecture, plus non-parametric memory and two parametric agents.

flowchart LR
 M["Manager <br/> (memory compression/management)"] --> P["Planner <br/> (search planning)"]
 P --> E["Executor <br/> (information analysis)"]
 E -->|"trajectory"| M
 M -.->|"non-parametric ↔ parametric"| P
 M -.->|"non-parametric ↔ parametric"| E

Contribution

Non-parametric memory storing compressed search trajectories
Alternating reinforcement learning — Planner and Executor are reinforced in alternation, separating search-plan synthesis from information analysis
Test-time learning — the Planner updates on-the-fly without pausing inference
Bidirectional conversion between parametric and non-parametric memory for efficient memory evolution
Strong results across eleven benchmarks

Why now

This is the academic background for tools like agentmemory. The fact that agentmemory and this paper landed within days of each other reflects the industry consensus that memory is the key differentiator for the next round of agents. The Manager-Planner-Executor split looks like a strong candidate for a de facto standard pattern in future multi-agent frameworks. It should be read alongside the rise of standard tool interfaces like MCP.

3. Husserlian Phenomenology + Active Inference — 2208.09058

Mahault Albarracin, Riddhi J. Pitliya, Maxwell J. D. Ramstead, Jeffrey Yoshimi (2022-08). A mapping of Karl Friston’s active inference framework onto Edmund Husserl’s phenomenology.

The idea

Phenomenology is the rigorous descriptive study of conscious experience. The paper maps Husserl’s descriptions of consciousness onto the mathematical building blocks of active inference — the neuroscience framework in which the brain predicts the world through a generative model.

Contribution

Connects Husserl’s theory of time consciousness — retention/protention — to active inference
A theoretical bridge between phenomenological description and computational neuroscience models
Reinterprets the structure of consciousness as components of a generative model
A push for computational phenomenology as an interdisciplinary field

Why now

This is the most abstract of the three but possibly the most interesting. As AI agents acquire “memory” and “reasoning,” how an agent structures its experience becomes a philosophical question again.

MIA’s evolving memory ≈ Husserl’s retention/protention?
Multiagent debate ≈ the self-reflective structure of consciousness?

The paper was shared as a direct PDF link (/pdf/), which suggests somebody actually read the full text. Probably one senior in the chat is making the bet that the next move for AI agents comes from cognitive science.

Reading the three together

The three papers point in the same direction: single-LLM limits → inter-instance cooperation + evolving memory + borrowed structure of consciousness.

Axis	Answer	Paper
Cooperation	Multi-instance debate	Multiagent Debate (2023)
Persistence	Compressed/evolving memory	MIA (2026)
Structure	Time consciousness → generative model	Husserl + Active Inference (2022)

The chat’s pick of the week accidentally forms a clean three-layer stack. Set alongside agentmemory + agent-skills (previous post), it shows that research, tooling, and practice are converging in the same direction.

Insights

The three papers come from different years and different topics, but read together they point at the same consensus — the way past the single-LLM reasoning plateau is not one more size class of model, but inter-instance cooperation, evolving memory, and explicit modeling of the structure of experience. Multiagent Debate is the first clean answer to “how do we get instances to cooperate”; MIA answers “how do we accumulate that cooperation across time”; the Husserl + Active Inference mapping throws a longer-range coordinate for “what structure that accumulation should ultimately resemble.” The fact that practical tools like agentmemory and agent-skills surface alongside these three papers within days is itself a signal — research, tooling, and practice are converging in the same direction. The differentiator in the next round is much more likely to be cooperation topology, memory evolution policy, and experience-structure modeling than raw model size.

References

Papers

Improving Factuality and Reasoning in Language Models through Multiagent Debate (2305.14325) — Du, Li, Torralba, Tenenbaum, Mordatch (MIT, 2023)
Memory Intelligence Agent (2604.04503) — Qiao et al. (2026)
Mapping Husserlian Phenomenology onto Active Inference (2208.09058) — Albarracin, Pitliya, Ramstead, Yoshimi (2022)

Related concepts

Society of Mind — Marvin Minsky’s multi-agent theory of cognition
Deep Research Agent — OpenAI’s tool-using agent system
Active Inference / Free Energy Principle — Karl Friston
Husserlian phenomenology (SEP) · Phenomenology (SEP)
Model Context Protocol (MCP) — emerging tool-interface standard
ICLR 2025

Background reading

arxiv.org — preprint server
Yilun Du · Joshua Tenenbaum · Antonio Torralba · Igor Mordatch
Maxwell J. D. Ramstead
GPT-Realtime-2 (parallel tool calls)