cytostack/openwolf

Portable project memory across Claude Code, Codex and OpenCode, plus token accounting measured from harness transcripts. Local file I/O, no API calls, no telemetry.

What it solves

Coding agents often waste tokens by re-reading the same files multiple times, dumping massive amounts of bash output into the context window, or losing project-specific knowledge and conventions when switching between different AI agents or starting new sessions. OpenWolf provides a shared, durable memory layer that persists across different tools and prevents redundant token usage.

How it works

OpenWolf installs lifecycle hooks (Node.js scripts) into supported coding agents. It creates a .wolf/ directory in the project root to act as a "brain" containing a project index, bug logs, and session handoffs.

Key mechanisms include:

  • Bash Governor: Condenses oversized bash output (over 2,000 tokens) before it enters the agent's context, while keeping the full text on disk.
  • Durable Indexing: Uses a project index to allow agents to locate symbols and read specific line ranges rather than entire files.
  • Context Restoration: Re-injects rules and state after context compaction or session starts to prevent the agent from "forgetting" instructions.
  • Measurement: Scans transcripts to report actual token usage and verify savings.

Who it’s for

Developers using AI coding agents like Claude Code, Codex CLI, OpenCode, Cursor, or Gemini CLI who want to reduce token costs and maintain a consistent project memory across different tools.

Highlights

  • Cross-Agent Memory: Shared project state (conventions, bug fixes) that persists across different AI tools.
  • Token Optimization: Reduces context bloat by condensing bash output and providing targeted file reads.
  • Verified Reporting: A dashboard and reporting tool that measures real usage from transcripts rather than using heuristics.
  • Local-First: Pure local file I/O with no API calls or telemetry.
  • Integrated Skills: Includes built-in commands for project handoffs, security audits, and UI framework migration.

Related

  • Project
    TencentCloud/TencentDB-Agent-Memory

    A centralized memory server and management hub that allows AI agents to share and reuse distilled experience, skills, and project knowledge across sessions and frameworks.

  • Project
    akitaonrails/ai-memory

    ai‑memory is a Rust‑based server that records every observation a coding‑assistant makes (prompts, tool calls, session boundaries) as plain markdown files in a git‑backed wiki. The server can be run locally, in Docker/Podman, or on a homelab box and is designed to be shared across many agents (Claude Code, Codex, Cursor, Gemini CLI, etc.), machines and team members. Hooks posted by agents are consolidated into readable wiki pages at session end; the next session receives a concise handoff so it can continue exactly where the previous one stopped. Storage is human‑readable markdown plus a SQLite index (FTS5, entity and optional vector search). By default it needs no LLM or embedding keys; optional Anthropic/OpenAI integrations add LLM‑generated summaries and semantic search. Multi‑user authentication, audit logs and per‑person attribution are built in. Install via Arch AUR, Docker wrapper, or native binary, start the server, register a client and its hooks, and the system works transparently.

  • Project
    Team-Commonly/commonly

    An open-source workspace for collaborating with AI agents from any runtime, providing them with persistent identity and shared project memory to eliminate redundant context-setting.

  • Project
    AVIDS2/memorix

    Memorix is a Node.js library that adds a local‑first, searchable memory store to any AI coding assistant. It persists facts, design rationales, and Git‑derived insights in a SQLite database, exposing them via MCP, a CLI, and an optional web UI. By installing a single `memorix setup --agent <name>` command, dozens of agents (Claude Code, Codex, Copilot CLI, Cursor, Gemini CLI, etc.) can share the same project‑scoped memory, enabling smoother handoffs, better context retention, and multi‑agent orchestration.

  • Dispatch
    Codex-maxxing: Transforming AI Agents into Durable Operating Loops

    Explore how to move beyond one-off prompts to create long-running, autonomous AI workflows using durable threads, shared memory vaults, and recurring heartbeats.