Cortex Engine

Persistent cognitive memory for AI agents — query, record, review, and consolidate knowledge across sessions with spreading activation, FSRS scheduling, and...

Security Scan

An instruction-only skill that documents how to use a local cortex-engine memory server; its requirements and instructions are consistent with that purpose.

Purpose & Capability

The skill's name/description match the SKILL.md: it teaches the agent how to use a local cortex-engine MCP server. It does not request unrelated credentials, binaries, or system paths.

Instruction Scope

SKILL.md contains guidance and example API calls (query, observe, believe, ops_append, etc.) scoped to memory management. It does not instruct the agent to read arbitrary host files, access unrelated environment variables, or send data to non-cortex endpoints.

Install Mechanism

This is instruction-only and includes a recommended npm install command (with an integrity hash) for a separate package; the skill itself does not perform any installs or download arbitrary URLs.

Credentials

No environment variables, credentials, or config paths are required by the skill. The requested resources are proportional to the documented function (a local memory MCP).

Persistence & Privilege

always is false and the skill does not request elevated or cross-skill configuration. Autonomous invocation is allowed by default (expected); the skill does not demand permanent platform presence.

Assessment

This skill is a guide for using a local cortex-engine server rather than an installer or networked service. Before using it: (1) verify the referenced GitHub/npm package (review source code and maintainers) and confirm the provided integrity hash matches the package you install; (2) run the MCP server locally and restrict network exposure (firewall/localhost-only) so stored memories can't be exfiltrated; (3) be mindful that the agent using this skill may persist sensitive data to local memory—define retention/cleanup policies; and (4) if you need cloud-backed memory or connectors, expect additional credentials and review those separately. If you want higher assurance, provide the actual repository/homepage or any code the agent will run so you can audit it directly.

Cortex Memory

Persistent memory engine for AI agents. Knowledge survives across sessions — recall what you learned last week, track evolving beliefs, detect contradictions, and build a knowledge graph over time.

Source: github.com/Fozikio/cortex-engine (MIT) | npm

Prerequisites

This skill requires cortex-engine running as an MCP server. Install it separately before using this skill:

npm install cortex-engine@0.5.1
# Integrity: sha512-8oIL8KenrdTdACAMSM/iqyrxx04yFE/3IfHx1dTF2439ljXhSCvULcNF5V10tH8UK7P/zuwmx3RuNynvjGi4kg==

Then initialize and start:

npx cortex-engine@0.5.1 fozikio init my-agent
npx cortex-engine@0.5.1  # starts MCP server

Runs locally with SQLite + Ollama. No cloud accounts needed. The skill instructions below are read-only — they teach your agent how to use cortex tools, they don't execute anything.

Core Loop

Read before you write. Always check what you already know before adding more.

Search

query("authentication architecture decisions")

Be specific. query("JWT token expiry policy") beats query("auth"). Results include relevance scores and connected concepts.

Explore around a result:

neighbors(memory_id)

Record

Facts — things you confirmed:

observe("The API rate limits at 1000 req/min per API key, not per user")

Questions — unresolved:

wonder("Why does the sync daemon stall after 300k seconds?")

Hypotheses — unconfirmed ideas:

speculate("Connection pooling might fix the timeout issues")

Update beliefs

believe(concept_id, "Revised understanding based on new evidence", "reason")

Track work across sessions

ops_append("Finished auth refactor, tests passing", project="api-v2")
ops_query(project="api-v2")  # pick up where you left off

Memory-Grounded Reviews

Review code or designs by comparing against accumulated knowledge:

1. Ground: query("the domain being reviewed") — load past decisions and patterns
2. Compare: Does the work align with or diverge from established patterns?
3. Record: observe() new patterns, wonder() about unclear choices, believe() updated understanding
4. Output:

## Review — Grounded in Memory

### Aligned with known patterns
- [matches cortex context]

### Divergences
- [what differs, intentional or accidental]

### New patterns to capture
- [novel approaches worth observing]

Session Pattern

1. Start: query() the topic you're working on
2. During: observe() facts, wonder() questions as they come up
3. End: ops_append() what you did and what's unfinished
4. Periodically: dream() to consolidate memories (compress, abstract, prune)

Available Tools

Category	Tools
Read	query, recall, predict, validate, neighbors, wander
Write	observe, wonder, speculate, believe, reflect, digest
Ops	ops_append, ops_query, ops_update
System	stats, dream