Inspiration

What it does

How we built it

Challenges we ran into

Accomplishments that we're proud of

What we learned

What's next for Agentix - Qwen

Agentix

Agentix started from a simple problem: conversational agents keep losing the thread, or they keep too much of the wrong thread. In practice, model apps tend to mix short-term conversation state, long-term knowledge, summaries, and old turns into one blob of context. That makes behavior harder to explain, harder to debug, and easier to get wrong.

We built Agentix to separate those layers. Qwen Code is one client, but it does not own the memory. Agentix acts as a standalone, local-first memory harness with a clear boundary: short-term conversation state stays conversation-scoped, long-term memory stays persistent and policy-governed, and the Explorer shows why records were included or excluded. The goal was not just to store memory, but to make memory auditable.

## How we built it

We built the project in Node.js with a read-only local Explorer powered by Cytoscape.js. The harness applies lifecycle and relevance rules before anything is surfaced, so superseded or archived records do not accidentally outrank current ones. It also applies provider-aware privacy filtering, which matters when the same memory could be projected to local and remote models differently.

For development, we kept the memory engine opaque and worked only through the published boundary. That forced the project to stay honest about contracts instead of depending on private internal state. We also built a synthetic fixture mode so the Explorer could be developed and demonstrated even when live structured graph data was not available.

## What we learned

The biggest lesson was that memory is not one thing. A good agent system needs at least two timescales:

• short-term memory for the active conversation
• long-term memory for durable knowledge, decisions, and preferences

We also learned that a graph is only useful if it is attributable. A pretty visualization is not enough. If the system cannot explain where a node came from, whether it is current, or why it was selected, the graph becomes decoration instead of infrastructure.

## Challenges

The hardest part was the boundary between useful context and too much context. If you send raw history everywhere, you waste tokens and blur conversations together. If you compress too aggressively, you lose important details. Agentix was built to keep that tradeoff visible and controllable.

Another challenge was making the Explorer accurate without fabricating structure. When structured graph records were unavailable from the live backend, we made the UI fail closed and used clearly labeled fixtures for development instead of pretending synthetic data was real memory.

## Outcome

Agentix is a memory harness and Explorer for agent workflows that need better context control, better privacy boundaries, and better explainability. It is designed to work with Qwen Code today, but the architecture is model-independent. That means the same memory boundary can support future clients, local models, and cloud models without each one inventing its own memory system.

Built With

• agent
• code
• context
• cytoscape.js
• javascript
• llm
• local-first
• management
• memory
• node.js
• obsidian
• openclaw
• privacy
• qwen
• systems
• tooling