Hippo-Qwen 2

The right memory, at the right point in time.

What I built

I built Hippocampus-8, a deterministic, relationship-aware vector and graph memory database for AI agents.

The SRE incident agent is the demonstration application. It shows why agent memory needs more than ordinary semantic similarity when facts change across time, lifecycle state, ownership, and related incidents.

Hippo-Qwen 2 uses that memory layer to help Qwen retrieve what changed before an outage, which fixes genuinely worked, which attempts failed, and who owns a service now—not merely which text looks similar.

The problem

Ordinary vector search asks whether two pieces of text look similar. Incident memory also depends on:

• when a memory was true;
• whether it is active, stale, failed, or superseded;
• which incident, service, change, or owner it relates to;
• whether it belongs inside the agent's limited context window.

Hippocampus-8 vectorizes those signals so the machine can distinguish current evidence from stale, superseded, or merely similar memories without hand-written rules for each query.

What the SRE agent demonstrates

The public application demonstrates three incident-memory decisions:

1. Retrieve the confirmed cause, successful mitigation, and postmortem from the last genuinely similar incident while rejecting failed or stale attempts.
2. Identify the deployment or configuration change immediately preceding an incident.
3. Resolve current service ownership while rejecting superseded ownership records.

The guided workflow spans separate sessions:

1. Historical incident evidence is written into a deterministic graph snapshot.
2. A later incident queries 64 runtime-visible candidate memories.
3. The frozen Hippo-Qwen 2 v3 scorer ranks relationship, time, and lifecycle state.
4. Stale fixes, wrong incidents, and superseded owners are rejected.
5. At most eight traceable memories and 1,200 tokens reach Qwen Cloud.
6. The resolved outcome is written back through the real GraphStore path.
7. A later session rehydrates the snapshot and retrieves the newly recorded experience.

Architecture

The runtime uses the existing Hippocampus-8 vector_graph engine rather than a separate demo store. Candidate memories become real NodeFrame objects, relationships become EdgeFrame objects, and the trained v3 scorer ranks the resulting graph-visible candidate pool.

The evidence gate creates a bounded, stable context frame before Qwen Cloud performs final reasoning and produces a cited response. Recording an outcome creates a new isolated snapshot while retaining superseded history for audit.

• Detailed architecture documentation
• Qwen Cloud integration
• Alibaba ECS deployment path

Qwen Cloud

Qwen Cloud performs the agent's final reasoning and response generation through its OpenAI-compatible API. Qwen3-14B was also used as a teacher to render the synthetic SRE corpus used to train and evaluate the compact relationship scorer.

The UI exposes:

• the selected memory;
• a plausible rejected hard negative;
• active, stale, and superseded pool state;
• the deterministic retrieval trace;
• the exact bounded evidence packet;
• memory citations;
• the final Qwen Cloud response and request receipt.

Evaluation

The final scorer is 2.75 MB and runs at 3.24 ms CPU P95 for 64 candidates with zero deterministic ranking mismatches.

On the sealed synthetic SRE benchmark it achieved:

• Balanced Memory Decision Score: 0.999963920
• Strongest fair baseline: 0.674740
• Absolute improvement: +0.325260
• Three validation seeds: 1.000 mean, 0.000 standard deviation
• Same-entity/wrong-time pairwise accuracy: 0.998016

The sealed test was evaluated once after model selection.

Evidence boundary

The corpus and benchmark are synthetic and Qwen3-14B teacher-rendered. These results demonstrate benchmark mastery and the behavior of the retrieval system; they are not presented as real-world SRE reliability evidence.

Built during the hackathon

Hippo-Qwen 2 was built from scratch for this hackathon beginning June 13, 2026. During the submission period I built:

• the deterministic Python/PyTorch graph engine;
• the SRE incident-memory agent;
• the Qwen Cloud runtime integration;
• the synthetic SRE dataset;
• the compact trained scorer;
• the sealed evaluation protocol;
• the guided cross-session workflow;
• the deployment wrapper and control-room application.

Run it

uv sync --extra demo --extra dev
cp .env.example .env
# Add DASHSCOPE_API_KEY
set -a
source .env
set +a
uv run hippocampus8-sre-demo

Open http://127.0.0.1:8080, then run the guided incident workflow.

The complete CLI workflow is also available:

uv run python scripts/run_guided_workflow.py \
  --device cuda \
  --output /tmp/hippo-guided-workflow.json \
  --proof-output docs/proof/guided-workflow-qwen-cloud.json

Track

Track 1: MemoryAgent

Source

github.com/CameronBadman/Hippocampus-8

Built With

• python
• pytorch
• qwen-cloud
• qwen3-14b