Agent Skills 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

CODEX-R — A Micro Skill That Imports Claude Code Sessions Into Codex CLI

Thu, 07 May 2026 00:00:00 +0900

Overview

thedalbee/codex-r is a three-star, MIT-licensed micro tool created on 2026-05-01. In one line: it is a Markdown-only skill that ports the claude -r workflow into OpenAI Codex CLI, so a single codex -r command opens a picker over your Claude Code sessions and imports the one you choose. There is almost no code — the artifact is a single SKILL.md following the agent-skills pattern. The interesting question is not the star count; it is why someone built this and what it signals.

graph LR
 User["user"] -->|"codex -r"| Wrapper["thin wrapper"]
 Wrapper --> Picker["session picker"]
 Picker -->|"scans ~/.claude/projects/**/*.jsonl"| Claude["Claude Code sessions"]
 Picker -->|"selection"| Import["externalAgentConfig/import"]
 Import --> Ledger["~/.codex/external_agent_session_imports.json"]
 Ledger -->|"codex resume threadId"| Resume["Codex session resumed"]

The Problem

Codex CLI 0.128.0 added external agent session import, but the trigger is awkward.

The TUI prompt only appears when the external_migration feature flag is on and the session enters the trust onboarding flow.
In projects that are already trusted, you may never see the prompt.
A large ~/.claude/projects folder makes home-wide detection slow.
Existing shell aliases route codex -r straight to the real Codex binary, which exits with unexpected argument '-r'.

The feature exists, but the path to use it is a scavenger hunt. CODEX-R turns the hunt into a single picker behind a thin wrapper.

What CODEX-R Does

The whole skill is one SKILL.md. Invoking $codex-r from a Codex session teaches Codex three things:

How to set up a codex thin wrapper
The Claude Code session picker behavior
The safety verification commands

codex -r # open picker, import on selection
codex -r daybreak # show only ~/ws/daybreak sessions
codex -r --cwd ~/ws/kb # sessions for a specific directory
codex -r --recursive # include child directories
codex -r --all daybreak # text-search all sessions
codex -r --list --limit 5 # list only, no import
codex -r --dry-run --limit 1

Safety Contract

The author is explicit about one rule: setup verification must never import.

--list and --dry-run never import, period.
An import only happens after the user explicitly selects a session.
The default shows only Claude sessions whose recorded cwd exactly matches the current directory.
If Codex later ships an official -r, the wrapper steps aside.

CODEX-R does not copy Claude’s settings, MCP servers, plugins, or skills. It only imports session JSONL files through Codex’s own app-server migration API.

How It Works (Codex Internals)

flowchart TD
 A["~/.claude/projects/**/*.jsonl"] -->|"file scan"| B["picker UI"]
 B -->|"user selects"| C["externalAgentConfig/import RPC"]
 C -->|"SESSIONS migration item"| D["Codex app-server"]
 D -->|"externalAgentConfig/import/completed"| E["update import ledger"]
 E -->|"extract threadId"| F["codex resume threadId"]
 F -.->|"on failure"| G["codex resume --all fallback"]

Feature flag — external_migration
Claude session source — ~/.claude/projects/**/*.jsonl
Import RPC — externalAgentConfig/import
Completion event — externalAgentConfig/import/completed
Import ledger — ~/.codex/external_agent_session_imports.json

A single session is imported as a SESSIONS migration item; the helper reads the threadId from the ledger and runs codex resume <threadId>.

Install

git clone https://github.com/thedalbee/codex-r.git ~/ws/codex-r
ln -sfn ~/ws/codex-r ~/.codex/skills/codex-r
# in a fresh Codex session:
$codex-r

No installer script. One symlink and a skill invocation, and you are done.

Why This Matters

A clean example of users wrapping an official feature in an ergonomic shell. The 0.128.0 import RPC was already there; the surface was missing; a user wrote a 30-line thin wrapper to expose it.
The Markdown-only-skill shape is the real story. It is a signal that Codex has adopted the Anthropic agent-skills pattern, and that compatibility lets a single person ship a working tool in a day.
Three stars is small, but the pattern is big — agent session portability is becoming load-bearing. The same week that surfaced this also brought agentmemory, another user-led standardization attempt for agent memory.
The agent infrastructure layer is standardizing fast, and users are gluing it together before model vendors do.

Insights

The meaning of this tool is not in the 30 lines of wrapper; it is in the fact that the wrapper exists at all. Within days of Codex shipping its import RPC, a user had built a picker on top of it and packaged the recipe as a SKILL.md. That timing tells you the agent tool market is no longer locked to a single vendor: Claude Code session JSONL is effectively a portable format, and Codex now exposes a stable RPC to import it. The same pattern is playing out for memory, skills, and MCP servers — and agent-skills as a standard means a single person can ship a compatibility layer in a day. Micro tools like this do not need to grow stars to be valuable; if the model vendor ships an official command, the wrapper steps aside, and that is fine. The real asset here is the pattern, not the tool. When users define ergonomics before the official feature does, the official feature ends up following them.

References

Repo

thedalbee/codex-r — MIT, three stars, created 2026-05-01
README.md / SKILL.md

Related tools

OpenAI Codex CLI — the external agent session import in 0.128.0 is the foundation this skill builds on
Claude Code — source of the ~/.claude/projects/**/*.jsonl files used for import
Anthropic agent-skills — the Markdown-only-skill pattern this project follows
MCP (Model Context Protocol) — the broader agent standards layer

Background

agentmemory — a same-period user-led memory standardization attempt (covered in a related post)
Claude Code documentation — JSONL transcript structure used by the picker

Bun Is Being Ported From Zig to Rust — A 30KB PORTING.md That Claude Follows

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

Overview

The JavaScript runtime Bun has a suspiciously named branch on its GitHub repo oven-sh/bun called claude/phase-a-port. Inside it lives docs/PORTING.md, a 30KB+ guide that translates Bun’s Zig codebase into Rust one file at a time — a complete type map, idiom map, and crate map. The claude/ prefix is the giveaway: this is almost certainly being driven by Anthropic’s Claude Code.

flowchart LR
 Zig[".zig source tree"] --> PhaseA["Phase A <br/> emit .rs next to .zig <br/> compilation NOT required"]
 Guide["docs/PORTING.md <br/> type/idiom/crate map"] --> PhaseA
 Lifetimes["docs/LIFETIMES.tsv <br/> per-field ownership class"] --> PhaseA
 PhaseA --> Markers["// TODO(port) <br/> // PERF(port) <br/> // PORT NOTE"]
 Markers --> PhaseB["Phase B <br/> crate-by-crate compile <br/> one grep handles each marker"]
 PhaseB --> Rust["bun_str / bun_sys <br/> bun_jsc / bun_uws <br/> bun_alloc / bun_bundler"]

What Was Found

oven-sh/bun (89K+ stars, “Incredibly fast JavaScript runtime, bundler, test runner, and package manager – all in one”) has a live claude/phase-a-port branch.
It contains docs/PORTING.md, a 1:1 Zig-to-Rust translation guide. Tens of thousands of lines, with complete type maps, idiom maps, and crate maps.
Phase A’s goal is precise: “a draft .rs lands next to each .zig. Compilation is NOT required. Logic must be faithful.”
Phase B is where everything is forced through the compiler, crate by crate.

Why It Matters

Bun is the largest infrastructure project ever built in Zig: runtime, bundler, package manager all in one binary, with a single domain at bun.com. Zig still ships frequent 0.x breakage and is generally seen as not-yet-stable on ABI and language semantics. The biggest codebase on top of it deciding to port to Rust is itself an industry signal. Zig-to-Rust is not the usual direction.

And the branch name is the tell. No human team names a working branch claude/phase-a-port. That’s the shape of “hand phase A to the Claude Code agent and watch.”

Inside the Guide

Ground rules

Each .rs lives in the same directory and has the same basename as its .zig.
Cross-area types are referenced as bun_<area>::Type (Cargo.toml wireup happens in Phase B).
Forbidden: tokio, rayon, hyper, async-trait, futures, std::fs/net/process. Bun has its own event loop and goes straight to syscalls.
Forbidden: async fn. Everything is a callback plus state machine.
unsafe is OK wherever Zig was unsafe. Every unsafe block needs // SAFETY: <why>.
If unsure, leave a // TODO(port): <reason>. A flag beats a guess.
Zig perf idioms (appendAssumeCapacity, arena bulk-free, comptime monomorphization) become plain Rust with a // PERF(port): ... comment, then Phase B greps and benches them.

Crate map (excerpt)

Zig namespace	Rust crate
`bun.String`, `bun.strings`, `ZigString`	`bun_str`
`bun.sys`, `bun.FD`, `Maybe(T)`	`bun_sys`
`bun.jsc`, `JSValue`, `JSGlobalObject`	`bun_jsc`
`bun.uws`, `us_socket_t`, `Loop`	`bun_uws_sys` / `bun_uws`
`bun.allocators`, `MimallocArena`	`bun_alloc`
`bun.shell`	`bun_shell`
`bun.bake`	`bun_bake`
`bun.install`	`bun_install`
`bun.bundle_v2`, `Transpiler`	`bun_bundler`

MimallocArena is an arena allocator built on top of mimalloc; bun.uws is Bun’s own event loop binding (uSockets). Critically, neither uses an async runtime like tokio — and the porting guide forbids one explicitly.

Type map (excerpt)

Zig	Rust
`[]const u8` (struct field)	`Box<[u8]>` / `Vec<u8>` / `&'static [u8]` / arena raw ptr — decide by reading `deinit`
`[:0]const u8`	`&ZStr` (length-carrying NUL-terminated)
`?T`	`Option<T>`
`anyerror!T`	`Result<T, bun_core::Error>` (always, in Phase A)
`comptime T: type`	`<T>` (generic + trait bound)
`comptime n: uN`	`<const N: uN>`
`inline for` over tuple	`const [T; N]` + `for`
`for (slice, 0..) \|x, i\|`	`for (i, x) in slice.iter().enumerate()`
`defer x.deinit()`	delete — handled implicitly by `impl Drop`
`errdefer alloc.free(x)` (just-built local)	delete — `?` drops it for you
`errdefer { side effects }`	`scopeguard::guard(...)` and disarm on the success path

Notable micro-rules

bun_core::Error is #[repr(transparent)] NonZeroU16 — a heap-free Copy-able error newtype with a link-time-registered name table. anyhow::Error and Box<dyn Error> are banned because of heap allocation, lack of Copy, and broken @errorName snapshot compatibility.
bun.Wyhash11 is kept distinct from std.hash.Wyhash (seed 0) for on-disk compatibility. Lockfiles, npm manifest cache, and integrity all depend on it — the Rust port keeps the separate implementation.
defer pool.put(x) becomes a Drop-guard pattern in Rust. Manual defer is forbidden.
The scopeguard::guard((), \|_\| ...) “unit state” pattern is forbidden — it usually means a missing RAII type.
@errorName(e) becomes an IntoStaticStr derive. Never Display or format!("{e:?}") — JS error.code, snapshot tests, and crash-handler traces depend on the exact string.
for (a, b) \|x, y\| becomes for (x, y) in a.iter().zip(b) plus a debug_assert_eq!(a.len(), b.len()). Zig asserts; Rust’s zip silently truncates.
TLS code stays on BoringSSL via FFI — not rewritten as pure-Rust RustTLS.

Phase A vs Phase B

Phase A = one .zig → one .rs. Doesn’t have to compile. Logic faithful, idiomatic Rust shape.
Phase B = crate-by-crate compile pass. Sweep // TODO(port) and // PERF(port) markers in batch.

This split is the load-bearing piece. Try to do everything at once and the LLM’s context collapses; carve it into one-zig-to-one-rs units and a single session can finish one. Compilation correctness is deferred entirely to Phase B.

What This Means — agent-skills, In Production

The PORTING.md document itself is the interesting artifact.

A guide written by humans for an LLM to follow. Producing a 30KB+ map up front isn’t “Claude, port this for me” — it’s “Claude, here’s exactly what to translate to what.” It’s the agent-skills idea applied in production.
Type-by-type decisions are nailed down in advance. Whether []const u8 (as a struct field) becomes Box<[u8]> or &'static [u8] is not left to the LLM’s judgment — there’s a meta-rule (“look at deinit”) that forces the decision.
A docs/LIFETIMES.tsv file is referenced explicitly: per-field OWNED / SHARED / BORROW_PARAM / STATIC / JSC_BORROW / BACKREF / INTRUSIVE / FFI / ARENA / UNKNOWN classes pre-classified by hand. The LLM is told to copy that column verbatim. The cross-file analysis is precomputed and handed to the model.
Three markers (PORT NOTE, TODO(port), PERF(port)) are the phase handoff. Whoever (or whichever future LLM session) picks up Phase B can grep once and have a queue of work.

Insights

This is the first publicly visible attempt to migrate a major codebase between systems languages using LLM automation, and the interesting takeaway is that the leverage is in the guide, not the model. PORTING.md pre-decides type maps and idiom maps, LIFETIMES.tsv pre-decides ownership per field, and TODO/PERF/PORT NOTE markers pre-design the phase-to-phase handoff. The LLM is intentionally left no room to be creative — it just executes “this line becomes that line.” Banning tokio, rayon, async-trait, and the rest of the canonical Rust async stack reflects the same instinct: Bun has its own event loop and FFI assets like BoringSSL that an LLM “Rust-ifying” would silently break. PORTING.md may end up the textbook example of an LLM-driven port. If massive codebase migrations become economically tractable as LLM spend, the deciding cost factor isn’t going to be GPUs or model choice — it’s going to be how much guide you wrote before you pressed Run.

Agent Skills on ICE-ICE-BEAR-BLOG

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

Overview

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

The problem it solves

How it works

Benchmark — LongMemEval-S

Token cost

Quick start

What it really argues

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

The problem it solves

A six-stage lifecycle

The 20 skills, by stage

Where it runs

Agent personas

What it really argues

3. Side by side

4. The Combined Picture — An OS Layer for Agents

Insights

References

CODEX-R — A Micro Skill That Imports Claude Code Sessions Into Codex CLI

Overview

The Problem

What CODEX-R Does

Safety Contract

How It Works (Codex Internals)

Install

Why This Matters

Insights

References

Bun Is Being Ported From Zig to Rust — A 30KB PORTING.md That Claude Follows

Overview

What Was Found

Why It Matters

Inside the Guide

Ground rules

Crate map (excerpt)

Type map (excerpt)

Notable micro-rules

Phase A vs Phase B

What This Means — agent-skills, In Production

Insights

References

Bun and the porting branch

Languages and ecosystems

Tooling / crates referenced