Agent Memory & Skills

A local-first system that stores team context in the repo, routes AI attention through structured files, and verifies that documentation still matches the code.

Coding agents are only as capable as the instructions they follow. Caliber is the deterministic engine keeping CLAUDE.md and .cursorrules from going stale.

A deep dive into the pipeline that captures tool use, compresses it into durable lessons, and keeps AI coding agents stateful across sessions, branches, and tools.

Why the secret to production-grade AI agents isn't a smarter model, but the restrictive infrastructure built around it.

A portable skill that drafts, audits, and humanizes prose with intake gates, version checks, and a 33-pattern cleanup loop.

A traceable investment research agent built from public statements, fund holdings, and scoring rules that force the model to show its work instead of hallucinating answers.

Sakana AI’s D2L skips the long prompt and generates LoRA adapters from the document itself.

A zero-dependency Python collector that normalizes chats, code context, and assistant history from Cursor, Claude Code, Aider, and more into one JSONL pipeline for backup, analysis, and fine-tuning.

A local-first MCP bridge that turns Obsidian notes, templates, and semantic search into something an agent can actually use.

Manifests, skills, and MCP servers turn AI capability into installable, governable packages. The repo is a blueprint for how agents will be extended.

A deep dive into WorkOS’s agent registration protocol, where discovery, step-up verification, and human claim ceremonies collapse into one file-shaped entry point.

It records desktop activity as events, closes them into hierarchical summaries, and gives agents a way to browse your day without a cloud vector index.

A Google Research project that turns past reasoning traces, including failures, into reusable memory for web and coding agents.

How a tiered memory architecture and biological sleep cycles turn stateless chatbots into production-grade autonomous systems for pennies.

A deep dive into the TypeScript system that reconstructs memory from seeds, promotes repeated facts into MEMORY.md, and gives a messaging agent a heartbeat.

How a zero-token drift detector turns AI context files into a deterministic database, giving coding agents a flawless long-term memory.

A local-first, Markdown-native memory layer for coding agents that separates private attempts, durable history, and shared truth, so context stays useful instead of stale.

A prompt system, validation layer, and style DNA file turn a public thinker’s playbook into a runnable skill for analysis, reframing, and leverage-first advice.

A markdown brain, executable skills, and lifecycle hooks turn agent amnesia into a structured feedback loop the human can inspect, edit, and improve.

How a 5MB Tauri desktop app uses Rust and vanilla JavaScript to turn AI prompt management into a system-level reflex.

Moving beyond simple RAG, this Hermes extension uses a local Markdown filesystem to help AI agents evaluate their own work and automatically fine-tune their cheaper successors.

An open-source MCP skill library that packages proven frameworks, validates them like code, and feeds them to agents that need more than generic prompts.

How a hybrid graph-vector database and verifiable cryptographic citations are creating a local-first, hallucination-proof knowledge layer for AI agents.

It splits teaching style, persona, and subject knowledge into separate files, then recombines them into a tutor you can correct, update, and version like code.

How a silent middleware layer uses "displacement logic" and "waste metrics" to stop AI agents from drowning in their own context.

How the Skills Over MCP group is trying to make workflow instructions discoverable, portable, and light enough for agents to actually use.

Inside BMad’s AI workflow marketplace, where modules are versioned, classified, and pinned like software artifacts, and where trust matters more than freshness.

A Markdown skill that turns arXiv monitoring into a checkpointed review pipeline, with a skeptical reviewer persona, recovery-safe caching, and doc publishing baked in.

Sakana AI’s open-source experiment fuses product-key lookup with fast-weight updates, so an LLM can retrieve from a huge memory and revise what it remembers mid-stream.

A Markdown-first spec for agents that keep identity, tools, and memory under version control.

How a minimalist Python daemon turns Telegram topics into an automated, local-first ingestion engine for Obsidian.

How the popular vector database uses a strict compiler pipeline to turn static documentation into type-safe, executable behaviors for AI agents.

A tiny tap repo that points to a bigger idea: issue tracking as structured memory for coding agents, not just a dashboard for humans.

A Bun-driven worker records observations, scrubs sensitive data, and brings the right context back when the next session starts.

How structure-aware "pages" and dual-path pooling are replacing token-level pruning to solve the LLM lost-in-the-middle problem.

The Gear Foundation is replacing traditional documentation with a machine-readable "Skill Pack" that orchestrates the entire dApp lifecycle.

An async Python framework that routes the same service through memory, Redis, or mocks at runtime, then invalidates only the keys that match.

A plain-text memory stack for AI collaborators. It turns context into a versioned world model, episodic notes, and explicit memory maintenance commands.

A terminal-first map of local AI skills, organized as a cognitive system, not a directory dump.

A persistent, token-aware system that captures agent observations, compresses them into durable context, and feeds back only what matters when the next session begins.

How a flat directory of Markdown pipelines and shell scripts turns generalist AI agents into highly opinionated, strictly constrained junior developers.

How a nostalgic Shell-scripted social network is solving the problem of persistent agent identity and "Social Proof" for autonomous LLMs.

A local-first Rust and Tauri app that watches windows, keyboard bursts, screenshots, and app shifts, then compresses them into privacy-filtered Markdown sessions.

A Markdown-only architecture for turning prompts, identity, tools, and long-term notes into an external brain the model can reread every session.

It does more than track sets and streaks. It builds a performance brief, protects workout plans from model drift, and uses cache-aware AI to answer training questions with structure instead of guesswork.

A symbolic-comment system for AI agents that keeps documentation tied to reality, with the README acting less like a static page and more like a regenerated view of the repo.

How structured Markdown and the open Agent Skills standard turned passive startup advice into an executable, stateful virtual co-founder.

A TypeScript server that combines OAuth, multi-tenant storage, and SM-2 scheduling so an AI tutor can create, track, and review flashcards inside the conversation.