Agentic Stack: One Brain Across 8 AI Coding Agents

Added: 2026-05-05

[00:00:00]Agentic Stack, one portable AI brain that works across eight different coding agents. Claude code, cursor, WinSurf, open code, open claw, Hermes, pie, and standalone Python. Same memory, same skills, same protocols. Switch tools without losing what your agent learned.

[00:00:17]Four-layer memory with nightly staging cycles. Skills that rewrite themselves after repeated failures.

[00:00:23]714 stars on GitHub. Agnetic Stack solves a real problem that anyone using multiple AI coding agents has experienced. Every time you switch tools, you start from zero. Your Claude code agent learned your coding conventions, your testing preferences, your project architecture. Then you try cursor for a week, and all of that knowledge is gone. Switch back to Claude code, and it's still there. But now your cursor experience is siloed. Agentic Stack eliminates this by creating a portable.agent directory that contains your agent's memory, skills, and protocols in a format that plugs into any of eight supported harnesses.

[00:01:00]The memory system has four layers.

[00:01:02]Working memory for the current session, episodic memory for task histories, semantic memory for learned patterns and lessons, and personal memory for your preferences and conventions.

[00:01:14]Skills are reusable capabilities. Five seed skills ship out of the box, and the system can create new ones or rewrite existing ones when they fail too often.

[00:01:24]Protocols define tool schemas, permission boundaries, and sub-agent delegation contracts.

[00:01:30]The entire system is designed around a compounding knowledge loop. Your agent gets smarter over time, and that intelligence is portable across every tool you use. The project has 714 stars and 77 forks, is Apache 2.0 licensed at version 0.7.0, and installs via Homebrew on macOS and Linux or PowerShell on Windows. Created by code junkie99 with credits to av1d live for the original Agnetic Stack concept. Let's look at the repo. 714 stars for a meta framework that works across competing coding agents is strong validation. Developers clearly want their agent knowledge to be portable rather than locked into a single tool.

[00:02:11]The readme is one of the most detailed I've seen. It documents the four-layer memory architecture with schema definitions. The complete review protocol with rationale requirements, all eight harness adapters with their specific configuration files, and the full CLI tool reference. The code base is primarily Python with markdown and JSON for configuration. The 45 commits across a focused development cycle show deliberate, well-documented progress from v0.5.0 through the current v0.7.0 release. The memory architecture is the core innovation. Working memory tracks the current session, what files have been edited, what decisions were made, what the current task context is. Episodic memory records complete task histories.

[00:02:55]What was attempted, what succeeded, what failed, and the rationale behind each decision. Semantic memory stores graduated lessons, proven patterns that the agent should apply to future work, and personal memory contains your preferences, coding style, language choices, testing strategy, commit message conventions. Each layer has configurable decay policies. Working memory decays aggressively because it's session-specific. Episodic memory decays more slowly. Individual task records might be relevant for weeks. Semantic lessons are permanent unless explicitly rejected. Personal preferences never decay. Query-aware retrieval combines salience and relevance metrics. When the agent needs to recall something, it searches across all four layers simultaneously, weighting results by how relevant they are to the current task and how recently they were accessed.

[00:03:45]This means the agent doesn't just remember things. It remembers the right things at the right time. The optional FTS5 full-text search provides fast indexed queries over all markdown and JSON memory documents for larger memory stores. The dream cycle is where raw experience becomes structured knowledge.

[00:04:03]Every night, auto_dream.py runs as a cron job. It performs only mechanical operations, no AI reasoning, no LLM calls, just deterministic processing that's safe for unattended execution. It scans episodic memory for recurring patterns, clusters similar experiences using single-linkage Jaccard similarity with bridge merging, and stages candidate lessons for human review.

[00:04:25]The staging is purely mechanical. It identifies what keeps coming up, but it doesn't decide whether those patterns should become permanent lessons.

[00:04:33]That decision requires human rationale.

[00:04:36]The host agent review protocol is deliberate. When a candidate is staged, you review it using CLI tools. Graduate accepts it with a required rationale, explaining why the evidence holds.

[00:04:46]Reject dismisses it with a required reason. And critically, rejected candidates retain their full history. If the same pattern keeps staging after being rejected, that recurring churn itself becomes a signal worth investigating. Graduated lessons enter lessons.json as the single source of truth.

[00:05:05]Lessons.md re-renders automatically from that file. Future sessions retrieve relevant lessons via recall.py before the agent acts, creating a feedback loop where past experience directly informs current decisions. The skill system provides reusable capabilities that load on demand. Five seed skills ship out of the box. Skill Forge creates new skills from observed patterns. Memory Manager handles the memory life cycle. Staging, graduation, decay. Git proxy wraps common get operations with safety checks and conventions enforcement. Debug investigator provides structured debugging workflows. And deploy checklist runs pre-deployment verification. Each skill has a lightweight manifest that always loads.

[00:05:47]This tells the agent what skills are available and their trigger conditions.

[00:05:51]The full skill files only load when a trigger matches, preventing unnecessary context consumption. The self-evolution mechanism is what makes the skill system genuinely adaptive. Every skill tracks its own success and failure rates. When a skill accumulates three or more failures within a 14-day window, it flags itself for rewrite. The agent then examines the failure patterns, identifies what went wrong, and proposes an updated version of the skill. This means skills improve based on actual usage data rather than remaining static forever. Protocols layer type tool schemas with JSON validation.

[00:06:26]Permissions enforcement via pre-tool call hooks, ensuring skills can only access authorized capabilities. And sub-agent delegation contracts that define how the primary agent can delegate work to specialized sub-agents with bounded authority. The eight harness adapters translate the portable.agent directory into each tool's native configuration format.

[00:06:46]Claude code gets claude.md and claude_settings.json with post-tool use and stop hooks. The hooks trigger memory writes and skill activations at the right moments during Claude code's execution. Cursor gets.cursor_rules with.mdc files that cursor's rule engine reads. WinSurf gets.winsurf_rules.

[00:07:07]Open code gets agents.md plus open code.json.

[00:07:12]Open claw gets system prompt includes that inject the agent's context into open claw sessions. Hermes agent gets agents.md compatible with agent skills.io. Pie coding agent gets agents.md with a symlinked.py_skills directory. And the standalone Python conductor gives you full programmatic hook control for custom integrations.

[00:07:33]Each adapter maintains the same memory, skills, and protocols. The only difference is how they're surfaced to the specific tool. When you switch from Claude code to cursor, your agent's entire knowledge base comes with you.

[00:07:45]When you add a new lesson in cursor, it's available next time you open Claude code. The.agent directory is the agent's brain. The harness is just the body it inhabits. Install via Homebrew, brew tap, brew install, then run Agnetic Stack with your target harness name and your project directory. The onboarding wizard runs automatically, asking about your preferences, name, languages, explanation style, testing strategy, commit conventions, and code review depth. Or pass yes to accept defaults for CI environments. Once scaffolded, you get the full.agent directory with memory layers, skills, protocols, and tools.

[00:08:22]Use learn.py to teach your agent new lessons, recall.py to surface relevant knowledge before making changes, and show.py for a colorful dashboard of your agent's current brain state. Set up the nightly cron job for auto_dream.py, and your agent starts compounding knowledge automatically. That's Agnetic Stack, one portable brain across eight AI coding agents. Four-layer memory, self-evolving skills, nightly dream cycles, and compounding knowledge that travels with you.

[00:08:51]714 stars, Apache 2.0, GitHub link in the description. Subscribe to Prism Labs for more AI agent framework coverage.