Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    StreamTeem Project Memory

    1

    Five skills that give your agent a lasting memory of a project, in plain markdown files: facts it should know and rules it must follow. Loads what applies when work starts and re-checks rules before commit, push, or PR.

    $1.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    StreamTeem Project Memory

    StreamTeem Project Memory

    Example session with this skill installed

    I am about to push these changes to the remote branch. Check the project memory for any rules that apply to this action.

    • Read your context and instructions
    • Compiled the streamteem project memory

    I have checked the project memory for the git:push trigger within the developer workflow. One relevant rule was found and verified.

    Pre-push Memory Check

    Entry TypeTitleWorkflowTriggerStatus
    RuleIntegration tests hit real DBdevelopergit:pushRequirement Met
    FactCI/CD Pipeline URLallN/AReference Only

    Analysis:
    The rule Integration tests hit real DB requires that any push to a remote branch must be preceded by a local execution of the integration suite against the staging container. I have confirmed that the pytest --integration command was executed successfully in the previous step of this session.

    Next steps

    1. Proceed with git push origin feature-branch.
    2. Monitor the pr:open triggers if you intend to create a pull request immediately after.
    3. Use remember if any new deployment constraints were discovered during this push.

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

    About this skill

    Context drift and forgotten architectural constraints lead to technical debt and deployment failures. The Streamteem Project Memory skill package provides a persistent, workflow-aware knowledge system that lives directly in your repository. It ensures that critical facts and procedural rules are loaded, followed, and evolved throughout the development lifecycle.

    What it does

    • Load context automatically reads stored facts and rules at the start of a session or task to ensure constraints are in force.
    • Capture knowledge classifies new observations as facts or prescriptive rules at either a specific work-item or global expert-role scope.
    • Enforce triggers checks specific rules immediately before critical actions like git:push, pr:open, or writing SQL.
    • Integrate documentation parses external notes, runbooks, and code comments to batch-process them into categorized memory files.
    • Optimize memory runs Python-based analysis to detect file bloat, duplicates, and missing metadata to maintain high context performance.
    • Promote learnings elevates successful patterns from individual tasks to the project-wide expert memory.

    How it works

    1. Initialize by defining a memory folder to store Markdown-based fact and rule files.
    2. Execute tasks while the agent monitors for new patterns or follows existing rules tied to specific triggers.
    3. Commit memory by saving captured knowledge into workflow-split files like facts-developer.md or rules-incident-response.md.
    4. Maintain health by running the optimization script to prune duplicates and fix indexing.

    Frameworks & tools

    This skill manages Markdown files within a Git repository. It uses a bundled Python 3 script for memory analysis and supports integration with standard CLI tools for version control and database operations.

    Why this beats prompting it yourself

    Standard prompts lose context as conversations grow long, and long system instructions waste tokens on irrelevant data. This system uses a workflow-split architecture that only loads the specific facts and rules relevant to your current task, reducing noise and preventing "context hallucination."

    Use cases

    • Enforcing database deployment order rules before any SQL is written.
    • Onboarding new developers by loading architecture facts and team communication protocols.
    • Capturing incident response post-mortems as permanent rules for the SRE workflow.
    • Auditing project memory to remove stale environment URLs and redundant documentation.

    Known limitations

    Requires a specific Markdown file structure to be maintained in the project root. The optimization script requires a local Python 3 environment.

    Requires local Python 3 for optimization script. Must follow specific Markdown file naming conventions. Scope is limited to the local project repository.

    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 any payment.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 4 days ago

    Requires

    Writable project folder
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Read/write for facts and rules Markdown. Shell only when running the bundled memory-optimize Python script.

    Listed4 days ago

    What's inside

    Frequently Asked Questions

    This skill creates a structured, file-based memory system within your Git repository, preventing "context drift" by ensuring the AI agent only loads the specific rules and facts relevant to your current task.

    The package includes the core skill definitions for knowledge capture and enforcement, a specialized Python 3 optimization script for memory maintenance, and a set of Markdown templates to structure your project's facts and rules.

    This skill is designed for any AI agent with filesystem access and the ability to execute Python scripts, making it compatible with most modern IDE-based agents and CLI-driven autonomous workflows.

    Setup involves defining a dedicated memory folder in your repository root and running the initialization command to generate your workflow-specific Markdown files (e.g., facts-developer.md).

    Unlike static prompts, this system uses "workflow-splitting" to load only the necessary context for your current task, which saves tokens and prevents the agent from being overwhelmed by irrelevant background information.

    Yes, because the memory is stored as Markdown files within your repository, it is version-controlled via Git, allowing your team to track, review, and roll back changes to project rules just like code.

    New in Workflow Automation