Agent Brain Skill

    1

    A local Markdown-based memory vault for tracking project context, technical lessons/errors, and handoffs across AI sessions.

    Free

    Security scanned

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Agent Brain Skill

    Example session with this skill installed

    We just finished the Auth0 integration. Record that we switched to the Authorization Code Flow with PKCE because the implicit flow was causing token renewal issues in the SPA.

    • Read your context and instructions
    • Compiled the agent brain

    I have recorded the decision and the technical reasoning in the project memory. A new pending contribution has been created for the curator to merge into the project overview.

    Memory Capture Result

    FieldValue
    Projectauth-service
    Kindsession
    StatusCaptured
    Contribution IDcontrib_20231027_PKCE_auth
    Path.brain/inbox/auth-service/session_20231027_1430.md
    Evidenceobserved (Integrated Auth0 SDK and verified PKCE handshake)

    Summary of Captured Entry

    Moved from Implicit Flow to Authorization Code Flow with PKCE.

    • Reason: Addressed token renewal failures observed in the Single Page Application.
    • Evidence: Verified successful token exchange and silent refresh using the new flow.
    • Next Action: Update the client-side configuration documentation to reflect the new redirect_uri requirements.

    Next steps

    • Run python scripts/brain.py --root ".brain" status to see all pending contributions.
    • Use the publish command to merge this into projects/auth-service/overview.md.
    • Check mistakes.md to see if a generic lesson regarding implicit flow should be added.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Development projects often lose critical context between chat sessions, leading to repeated mistakes and redundant onboarding. This skill implements a durable Markdown-based "memory" system that tracks project states, user preferences, and technical lessons across different agents and harnesses.

    What it does

    • Persistent memory maintains a local Markdown vault to store project overviews, practices, and mistakes.
    • Context retrieval searches for project-specific pitfalls and historical decisions before starting new tasks.
    • Lesson capture records technical failures with their specific symptoms, causes, and verified prevention steps.
    • State tracking documents milestones, evidence, and next actions to ensure smooth handoffs between sessions.
    • Memory curation merges atomic contributions into canonical project files while preserving source provenance.

    How it works

    1. Locate the brain via AGENT_BRAIN_ROOT or brain.local.json and verify the environment has Python 3.10+.
    2. Retrieve project context using brain.py search and read to check for relevant mistakes or practices.
    3. Capture new observations or milestones using the capture command to create a pending contribution.
    4. Curate the vault by merging pending notes into the overview.md or mistakes.md using the publish command.

    Frameworks & tools

    This tool uses a Python 3.10+ CLI helper (scripts/brain.py) to manage a local filesystem vault. It stores data in UTF-8 Markdown files and manages state via a structured JSON configuration.

    Why this beats prompting it yourself

    Relying on a system prompt to remember past sessions is unreliable and consumes token window. This skill provides a structured CLI for atomic updates and deduplication, ensuring that "lessons learned" from a bug in one chat are actually available to the agent in the next.

    Use cases

    • Preventing the agent from suggesting a library or approach that previously failed in the project.
    • Resuming a complex multi-step migration after the context window has cleared.
    • Standardizing coding practices across multiple agents working on the same repository.
    • Managing handoffs between a "researcher" agent and a "coder" agent using shared evidence.

    Known limitations

    Requires a local Python environment and filesystem access. It does not provide real-time cloud synchronization or an automated agent scheduler.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Agents & Orchestration.

    Requires Python 3.10+. Manual curation is needed to merge contributions into canonical notes. No built-in cloud sync or multi-user locking beyond basic atomic file writes.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 7 days ago

    • Free with an Agensi account

    Software
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables
    Listed7 days ago

    What's inside

    Frequently Asked Questions

    It creates a local Markdown-based 'memory vault' that tracks project context, technical lessons, and progress milestones, preventing AI agents from repeating past mistakes or losing track of your goals when a session ends.

    This skill works with any AI agent or harness that has local filesystem access and can execute Python 3.10+ scripts, making it ideal for CLI-based agents and local development workflows.

    You receive the full 'agent brain' framework, including the core Python CLI helper, a structured Markdown vault template, and the integration logic needed to connect it to your agent's workflow.

    No cloud account is needed; all project data is stored locally in UTF-8 Markdown files on your machine, ensuring complete privacy and allowing you to track changes via your own version control system like Git.

    Simply ensure you have Python 3.10+ installed, set your 'AGENT_BRAIN_ROOT' environment variable to your project folder, and the agent will be able to search, capture, and curate project context immediately.

    Unlike a system prompt which has a limited token window, this skill uses a structured CLI to search and retrieve only relevant snippets, saving tokens while providing more accurate, long-term historical context.

    New in Agents & Orchestration

    Free