Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    AOCI Cognition — governed repository knowledge for AI agent

    1

    Establish persistent, Git-versioned codebase and database cognition using the AOCI-CODE protocol.

    Free

    1 useSecurity scanned
    AOCI Cognition — governed repository knowledge for AI agent

    AOCI Cognition — governed repository knowledge for AI agent

    Example session with this skill installed

    I'm taking over a repository I've never seen: D:/code/my-service.

    1. Set up AOCI cognition for this repository (install wiring if needed).
    2. Give me a system overview: top-level modules, their responsibilities, key public contracts, and anything I must not break.
    3. Then assess: if I change the "users" database table, which code objects could be affected?
    • Read your context and instructions
    • Compiled the aoci cognition

    Loaded AOCI rules (protocol v2). Cognition established for my-service (baseline 0a1b2c…; 42 entries; aligned).

    System overview (attested):

    • api/ — HTTP + gRPC contracts; callers depend on /v1/users and /v1/orders.
    • core/ — domain engine; MUST NOT break: core.engine.naming (S), transactional boundary core.checkout.
    • infra/ — storage/retry primitives; R to core via checkout.dispatch.

    Impact analysis: changing table "users" reaches api/users_handlers.go → core/identity.go (R relationship), reported via aoci_impact.

    Maintenance: aoci_maintain applied 0 semantic candidates; verify/check passed; index aligned.

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

    About this skill

    Onboarding a new developer to a complex codebase usually takes days of manual exploration. This skill implements the AOCI-CODE collaboration protocol, enabling an agent to maintain a persistent, Git-versioned cognition map of both source code and database schemas. It replaces guesswork with a governed system of responsibilities, contracts, and constraints.

    What it does

    • Governed Cognition maintains a version-controlled map of code responsibilities (FRAS) and system boundaries.
    • Database Mapping integrates table-level cognition using read-only environment variable DSNs for schema analysis.
    • Semantic Tracking triggers maintenance only when machine-computed semantic change thresholds are crossed.
    • Protocol Adherence enforces a strict session lifecycle including overview loading, attestation, and task-end maintenance.
    • Evidence Reporting generates headers and reports to prove alignment between the cognition map and the actual source.

    How it works

    1. Initialize the session by calling aoci_rules to confirm the behavior contract and protocol constraints.
    2. Load Overview by consuming the architecture and module boundary map, following cursors if transport limits are hit.
    3. Execute & Maintain by performing business edits followed by the aoci_maintain command to identify semantic drift.
    4. Update & Verify by batch-submitting semantic candidates via aoci_update_entry and proving alignment with aoci_verify.

    Frameworks & tools

    Requires the aoci CLI binary (versioned and checksum-verified) and a Git repository. Works with any MCP-capable agent host like Claude Code, Cursor, or OpenCode. Supports database schema cognition via AOCI_DB_*_DSN environment variables.

    Why this beats prompting it yourself

    Manual prompts lack persistence and struggle with context window limits in large repos. This skill uses a formal protocol to ensure the agent's "understanding" is stored in Git, preventing hallucinations about system boundaries and ensuring every architectural claim is bound to a source SHA256.

    Use cases

    • Codebase Takeover quickly building a mental model of an unfamiliar repository's architecture and contracts.
    • System Impact Analysis determining which code objects or database tables are affected by a proposed change.
    • Consistency Enforcement maintaining strict FRAS (Function/Responsibility/Authority/Sign-off) discipline across large teams.

    Known limitations

    Requires pre-installation of the aoci binary on a stable path. Does not handle business data or network egress; it focuses exclusively on source and schema metadata.

    Requires manual installation of aoci CLI binary. Limited to Git-versioned repositories. Database cognition requires pre-provisioned read-only environment variables.

    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

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 29 days ago

    • Free with an Agensi account

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Environment Variables
    Listed1 month ago
    Updated29 days ago

    What's inside

    Frequently Asked Questions

    AOCI Cognition creates a persistent, Git-versioned 'map' of your code's architecture, preventing the 'context rot' that occurs when AI agents lose track of complex file relationships during long sessions.

    The skill is designed for any host that supports the Model Context Protocol (MCP), including Claude Code, Cursor, and OpenCode, provided the host has access to the local file system.

    The cognition map is stored directly in your Git repository as governed metadata, meaning your system knowledge evolves alongside your code and is shared across your entire development team.

    Setup involves installing the `aoci` CLI binary on your local machine and connecting the nine included MCP tools to your preferred AI agent host.

    Unlike standard prompting, this skill uses a deterministic maintenance loop (AOCI-CODE protocol) to verify that the agent's mental model matches the actual source code before every task.

    You receive the full suite of nine AOCI-CODE MCP tools, the `aoci` CLI binary for repository initialization, and the governed protocol definitions for maintaining system integrity.

    New in Agents & Orchestration