codejunkie99/agentic-stack

One brain, many harnesses. Portable .agent/ folder (memory + skills + protocols) that plugs into Claude Code, Cursor, Windsurf, OpenCode, OpenClaw, Hermes, or DIY Python — and keeps its knowledge when you switch.

agentic‑stack

What it is

agentic-stack is a toolbox that lets you give a portable “brain” to any of a dozen code‑generation agents (Claude Code, Cursor, GitHub Copilot CLI, Gemini CLI, etc.). The brain lives in a hidden .agent/ directory that contains:

  • Memory layers – working, episodic, semantic and personal files with configurable retention policies.
  • Skills – reusable, self‑documented command snippets that agents can call.
  • Protocols – permission schemas and tool‑call contracts that enforce safe tool usage.
  • Data layer – a local dashboard that aggregates token‑costs, KPI summaries, run logs and daily reports across all agents.
  • Fly‑wheel export – approved runs can be turned into trace records, evaluation cases or training‑ready JSONL without sending anything to the cloud.

The idea is that you can switch from Claude Code to Cursor (or run several at once) and the agent will retain its learned lessons, preferences, and custom skills because they are stored outside any single harness.

Core concepts

Concept What it does
Portable brain (.agent/) Holds memory, skills, and protocol definitions that any supported harness can read.
Bounded loops Deterministic, budget‑constrained “agentic loops” (agentic-stack loop run …) that run inside a project, with checkpoints, git work‑tree isolation and audit logs.
Review protocol Nightly auto_dream.py stages candidate lessons; a human (or host‑agent) must explicitly graduate or reject them via CLI tools, preserving a rationale.
Data layer & dashboard Local‑only TUI (agentic-stack dashboard) and optional web UI (mission‑control) that show agent health, token usage, and KPI summaries.
Fly‑wheel export data_flywheel_export.py converts approved runs into trace records, context cards, eval cases, or JSONL ready for downstream model training.

Supported agents (adapters)

The repo ships a thin shim for each of the following, all of which read the same .agent/ structure:

  • Claude Code
  • GitHub Copilot CLI
  • Cursor
  • Google Gemini CLI
  • Windsurf
  • OpenCode
  • OpenClaw
  • Hermes
  • Pi Coding Agent
  • Codex
  • Autohand Code
  • Stand‑alone Python loops
  • Antigravity

You can add or remove adapters after installation with agentic-stack add <adapter> / remove.

Quick start (macOS / Linux)

# Homebrew install (adds a tap and the formula)
brew tap codejunkie99/agentic-stack https://github.com/codejunkie99/agentic-stack
brew install agentic-stack

# Initialise a project – the wizard installs the chosen adapter and creates .agent/
cd my‑project
agentic-stack claude-code   # or cursor, codex, etc.

Windows users can clone the repo and run install.ps1 with the desired adapter.

Typical workflow

  1. Onboard – run ./install.sh (or the adapter shortcut). The wizard asks a few preference questions (name, primary language, explanation style, etc.) and writes them to .agent/memory/personal/PREFERENCES.md.
  2. Run a bounded loop – e.g. agentic-stack loop run ci‑sweeper "make the failing test green" ./my‑project --yes. The loop respects token/runtime limits and logs its actions.
  3. Review – after the nightly auto_dream.py stages candidate lessons, use the CLI tools:
    • list_candidates.py to see pending lessons
    • graduate.py <id> --rationale "…" to accept
    • reject.py <id> --reason "…" to decline
  4. Inspect – agentic-stack dashboard (TUI) or agentic-stack mission‑control (local web UI) shows memory health, token usage, and KPI charts.
  5. Export – data_flywheel_export.py turns approved runs into JSONL, trace records, or evaluation cards for downstream analysis.

Advanced features

  • External Brain integration – optional codejunkie99/brain server can act as a git‑backed long‑term memory store. Install it via Homebrew and wire it with agentic-stack brain … commands.
  • Memory search (beta) – enable full‑text search over all memory documents (.agent/memory/.features.json → Enable FTS memory search). Uses SQLite FTS5, falling back to rg/grep.
  • Transfer wizard – move a brain from one project to another (or to a pure‑Python harness) with a single ./install.sh transfer command that produces a curl‑compatible bundle.
  • Upgrade safety – agentic-stack upgrade --dry-run previews changes to the .agent/ skeleton without touching your existing lessons or preferences.

Project health

  • License – Apache 2.0
  • Release cadence – Semantic versioning; the README lists recent patches (v0.19.1) and a detailed CHANGELOG.md.
  • Installation – Available via Homebrew, a plain git clone + installer script, or PowerShell on Windows.
  • Testing – Includes harness‑specific validation scripts (e.g., test_claude_code_hook.py).
  • Community – Primary maintainer is @Av1dlive (Twitter/X link in README). No explicit contribution guide is shown, but the repo is open‑source and the code is organized for extension.

Who might use it?

  • Developers who work with multiple AI coding assistants and want a consistent set of preferences, learned lessons, and reusable skills across them.
  • Teams building internal AI‑augmented development pipelines that need audit trails, token‑cost monitoring, and the ability to export approved runs for model fine‑tuning.
  • Researchers exploring agentic loops, bounded reasoning, or memory‑augmented LLM workflows without relying on external services.

Bottom line

agentic-stack is a fairly complete, open‑source framework for giving code‑generation agents a shared, portable memory and skill set, plus tooling for safe bounded execution, review, monitoring, and data export. It sits squarely in the AI‑agent tooling space and is ready for use by anyone comfortable with command‑line installation on macOS/Linux/Windows.

Related

  • Project
    shibing624/agentica

    Agentica is an open‑source, Apache‑2.0‑licensed Python framework that lets you run LLM‑based agents locally. A single chat session becomes an autonomous agent that can call built‑in tools (search, file I/O, code execution, OCR, image generation), remember past work, and spawn sub‑agents or delegate whole tasks. It works via a CLI, a local web UI, a desktop app, and IM gateways (WeChat, Feishu, Telegram). Supports many model providers (OpenAI, DeepSeek, Claude, Ollama, etc.), offers async‑first APIs, safety guardrails, multimodal input, persistent memory, a markdown‑based skill system, and RAG integration. Install with `pip install -U agentica` (add `[gateway]` for the web UI) and configure an API key. Ideal for developers, researchers, and power users who want a self‑hosted “LLM OS” with collaborative multi‑agent capabilities.

  • Project
    K-Dense-AI/agentic-data-scientist

    An adaptive multi-agent framework that automates complex data science workflows by separating planning from execution and utilizing a self-correcting, iterative validation loop.

  • Project
    thedivergentai/GD-Agentic-Skills

    GD Agentic Skills is a curated library of 99 Godot 4.7+ “Domain Skills” plus a master orchestrator skill, built as an external long‑term memory for AI coding agents. It provides best‑practice GDScript snippets, migration guides, performance budgets, and a vision skill that lets agents capture and score editor screenshots. Install via the `skills` CLI—either the all‑in‑one `godot‑master` for full‑project guidance or individual domain skills for focused features—while avoiding the “install all” trap that would flood the model’s context.

  • Dispatch
    Command Center: An Agentic Coding Environment for Production Quality

    Command Center is an agentic coding environment designed to reduce the time spent reviewing AI-generated code by providing structured walkthroughs and refactoring agents to ensure production-grade quality.

  • Dispatch
    AI & Frontier Tech Roundup – Agentic Systems, Local Models, and Billion‑Agent Simulations

    This roundup highlights the surge in agentic AI platforms, the rise of powerful local models, and breakthroughs in massive multi‑agent simulations.