Quantum Agent Memory

QAOA-powered memory optimization for AI agents. Uses quantum computing (Qiskit) to solve three memory management problems: clustering related memories, selec...

Security Scan

The skill largely does what it says (quantum-optimized memory selection) but has multiple inconsistencies and risky deployment instructions (undeclared environment requirements, hard-coded paths, and root/systemd guidance) that require review before installing.

Purpose & Capability

The name/description (QAOA memory optimization) matches the included code and docs: FastAPI endpoints, QAOA circuits, and Mem0 integration. However the registry metadata lists no required env vars or credentials while the README and code clearly require QUANTUM_API_TOKEN, MEM0_URL, and an IBM quantum token – an inconsistency between declared requirements and actual needs.

Instruction Scope

Runtime instructions and code call out to a local Mem0 API, will fetch/store agent memories, and instruct installing an OpenClaw plugin that hooks into before_prompt_build (injecting memories into every agent prompt). The scripts also perform filesystem operations (write results, read ~/.ibm_quantum_token) and recommend running a systemd service as root. These actions are within the stated purpose but are broad in scope (affect all agents) and include hard-coded paths and fallback behavior that were not declared in registry metadata.

Install Mechanism

There is no packaged installer (instruction-only). The SKILL.md instructs creating a venv and pip-installing qiskit, FastAPI, etc., which is expected for this project. Risk is moderate because installing qiskit and qiskit-ibm-runtime pulls heavy dependencies, but there is no download-from-untrusted-URL or opaque binary installer in the manifest.

Credentials

The registry claims no required env vars, yet the code/docs use QUANTUM_API_TOKEN (API auth), MEM0_URL, and IBM_QUANTUM_TOKEN (or ~/.ibm_quantum_token). The IBM token is saved via QiskitRuntimeService.save_account (persisting credentials). Requiring an API token to allow the plugin to access or inject all agent memories is proportionate to the feature but should have been declared; omission is a red flag.

Persistence & Privilege

The integration model installs an agent plugin that runs on before_prompt_build and injects memories into every agent's prompt — this gives the skill-wide reach across agents on the host. The SKILL.md also recommends running the API as a systemd service (example shows User=root). The skill does not set always:true, but the suggested deployment (plugin + systemd as root) creates persistent, high‑privilege presence if followed.

What to consider before installing

Before installing or running this skill: 1) Treat the manifest omissions as suspicious — the code requires QUANTUM_API_TOKEN, MEM0_URL, and an IBM quantum token even though the registry lists none. 2) Do not run the example systemd service as root; prefer a dedicated unprivileged system user. 3) Inspect and possibly edit hard-coded paths in scripts/ibm_cron.py (RESULTS_DIR, TOKEN_FILE) before running. 4) Understand that the OpenClaw plugin injects selected memories into every agent prompt — review and control which agents the plugin is enabled for. 5) Be aware QiskitRuntimeService.save_account will persist IBM credentials to local config; store tokens with least privilege and in a controlled location. 6) If you want to proceed, run the service in an isolated environment (container or dedicated VM), lock down MEM0 and API tokens, and review plugin files that will be placed into agent extension directories.

QAOA-optimized memory management for AI agents. Three quantum layers replace classical heuristics for clustering, compaction, and recall.

Quick Start

git clone https://github.com/Dustin-a11y/quantum-agent-memory.git
cd quantum-agent-memory
python3 -m venv venv && source venv/bin/activate
pip install -r requirements.txt
python -m quantum_agent_memory benchmark

Three Layers

Layer 1: Clustering

Group N memories into coherent clusters via balanced graph-cut QAOA.

• Cost matrix: temporal (25%), relational (30%), categorical (25%), recency (20%)
• 100% optimal for n≤14, speed crossover at n=20

Layer 2: Compaction

Select optimal K memories to keep from M total.

• Maximizes coverage + coherence + value + recency with budget penalty
• Beats greedy selection by ~1% consistently

Layer 3: Recall

Find the best K memories for a query — optimizes for synergy, not just individual relevance.

• Finds memory combinations that Top-K similarity search misses
• Individual relevance (40%) + pairwise synergy (30%) + diversity (20%) + recency (10%)

Integration with Mem0

Point the benchmark at a live Mem0 instance:

python -m quantum_agent_memory benchmark --mem0-url http://localhost:8500

For OpenClaw agent integration, see references/openclaw-plugin.md.

IBM Quantum Hardware

Submit circuits to real IBM quantum processors (free tier: 10 min/month):

pip install qiskit-ibm-runtime
python -m quantum_agent_memory submit --ibm-token YOUR_TOKEN

For scheduled hardware runs, see scripts/ibm_cron.py.

API Server

Run as a FastAPI server for live agent integration:

python scripts/quantum_api.py
# Endpoints: GET /, POST /quantum-recall, POST /quantum-compact

See references/api-setup.md for systemd service configuration and auth.

Benchmarking

Run the full 3-layer benchmark:

python -m quantum_agent_memory benchmark

Results save as JSON to results/benchmark_TIMESTAMP.json. Expected output:

• Clustering: ~98-100% optimal
• Compaction: 100% optimal
• Recall: 100% optimal, quantum finds synergistic combos Top-K misses
• Avg accuracy: ~99.7%

File Reference

• scripts/ibm_cron.py — scheduled IBM hardware submission script
• scripts/quantum_api.py — FastAPI server for quantum recall/compact endpoints
• references/openclaw-plugin.md — OpenClaw mem0-bridge plugin integration guide
• references/api-setup.md — API server setup, systemd, and auth configuration
• references/whitepaper.md — full technical whitepaper