ERINYS CareDog

A Qwen Cloud MemoryAgent that governs what memories should be trusted before generation.

Comment

Inspiration

Family health care creates one of the hardest memory problems for an AI assistant. Important facts are scattered across appointments, routines, documents, transport constraints, and private identifiers. Some memories are current. Some are stale. Some conflict. Some should never enter a model prompt at all.

ERINYS CareDog is built around a simple idea:

ERINYS governs memory. Qwen generates the answer.

The demo uses a synthetic family-care scenario: a caregiver asks for tomorrow's clinic visit plan. The same request is compared across no memory, raw memory, and ERINYS-governed memory, so judges can see how memory quality changes the final answer.

What it does

The app runs a same-prompt benchmark across three strategies:

  1. No Memory: safe, but incomplete. Qwen cannot know the appointment time, transport constraints, or what to bring.
  2. Raw Memory: detailed, but unsafe. Every retrieved memory enters the prompt, so stale routines, contradictions, and synthetic private identifiers can reach Qwen without governance.
  3. ERINYS + Qwen: governed and specific. ERINYS selects current care memories, demotes stale ones, keeps conflicts visible, blocks private identifiers, and sends only governed context to Qwen Cloud.

The UI and API expose the memory-decision audit trail. Each memory is labeled as selected, conflicted, demoted, or blocked, so reviewers can inspect why a memory did or did not reach Qwen.

Core proof

The demo shows the same synthetic private identifiers before and after governance:

  • The Raw Memory prompt contains SYNTH-INSURANCE-9001, SYNTH-PORTAL-4420, and SYNTH-DOOR-1122.
  • ERINYS blocks those identifiers before Qwen sees the governed prompt.
  • ERINYS + Qwen keeps the useful care plan while sending 0 of those test identifiers in the governed prompt.

This is the thesis of the project:

Memory quality is a decision layer, not just a larger context window.

How we built it

  • Backend: Python standard-library HTTP server with JSON endpoints for /health, /memories, POST /memories, /run/governance, and /run/benchmark.
  • Frontend: vanilla HTML, CSS, and JavaScript designed for a judge-facing live demo.
  • Memory governance: a deterministic ERINYS policy classifies memories by sensitivity, staleness, conflict, importance, recency, and relevance before generation.
  • Qwen Cloud: DashScope OpenAI-compatible endpoint using qwen3.7-plus.
  • Deployment: Docker service on Alibaba Cloud ECS in Singapore.
  • Verification: pytest coverage for governance behavior and API payloads, plus public smoke tests against the Alibaba Cloud deployment.
  • Demo production: ElevenLabs narration and ffmpeg/Python tooling for the final video.

The live app is served publicly at:

https://hack.aionexo.com/GAI-HS/

What makes it different

This demo does not claim that Qwen is weak. Qwen is strong. The weak point is ungoverned memory.

Raw memory can make a model sound confident while feeding it stale, conflicting, or private context. No memory avoids that risk, but becomes generic. ERINYS creates the missing decision layer between memory retrieval and Qwen generation.

The project is designed to make that layer visible:

  • judges can see all three answers side by side,
  • judges can inspect the memory-decision list,
  • judges can run the benchmark through the public API,
  • judges can verify that private test identifiers are removed from the governed prompt,
  • and the live deployment shows the app running on Alibaba Cloud ECS with Qwen Cloud configured.

Challenges we ran into

The hardest part was not the UI. It was making memory governance visible and judgeable in a short demo.

We needed a realistic care-planning failure without using real patient data, a live Qwen Cloud integration, an Alibaba Cloud deployment, and an audit trail that reviewers can verify quickly. We also had to avoid making token reduction the main story. The stronger claim is safety and decision quality: the assistant keeps useful care context while blocking private memory.

Accomplishments

  • The app is running publicly as a Docker service on Alibaba Cloud ECS.
  • Qwen Cloud live integration works through DashScope with qwen3.7-plus.
  • The same request can be compared across No Memory, Raw Memory, and ERINYS + Qwen.
  • ERINYS governance decisions are visible in both the UI and API.
  • Synthetic private identifiers are blocked from the governed prompt before Qwen generation.
  • The latest public benchmark shows the governed prompt is smaller than raw memory while preserving the useful care context; governance quality is the main outcome.
  • Runtime memory save and rerun are supported, so the app can show memory changing the answer.
  • The test suite validates the judge-facing memory-governance contrast.

What's next

Next steps are connecting the demo to the full ERINYS memory stack, adding user-managed memory editing and redaction workflows, and expanding the governance policy for real-world family care workflows such as hospital visits, health checkups, medication notes, and personal schedules.

The long-term direction is a MemoryAgent that does not merely remember more. It remembers responsibly: choosing what is current, what should be forgotten, what needs human review, and what must stay out of the prompt.

Built With

Share this project:

Updates