Feedback, Ideas & Real-World Usage Discussions

Welcome 👋

This discussion thread is for:

• feedback
• ideas
• architecture discussions
• integration experiments
• benchmark suggestions
• real-world usage experiences
• memory system research discussions

Agent Memory System is still experimental and evolving, so community feedback is extremely valuable.

---

Areas I'm Especially Interested In

• AI coding workflows
• long-session context management
• multi-agent coordination
• retrieval quality
• memory ranking/relevance
• architectural decision persistence
• context compression
• semantic vs structured memory tradeoffs
• benchmark methodology
• self-hosted deployments

---

If You’ve Tried AMS

Would love to hear:

• what workflow you tested
• what worked well
• where memory retrieval failed
• confusing setup/documentation areas
• missing features
• performance observations
• integration ideas

Even small observations are helpful.

---

Current Focus Areas

Right now the project is mainly focused on:

• persistent engineering context
• coding-agent continuity
• long-running development workflows
• practical retrieval for software projects
• lightweight/self-hosted friendly architecture

Not trying to position this as a generic chatbot memory layer.

---

Transparency Note

The project is actively evolving and many parts are still experimental.

Some things are intentionally incomplete while different memory/retrieval approaches are being evaluated and benchmarked.

If something feels unclear, over-engineered, under-documented, or just incorrect — please say so directly.

Technical criticism and implementation discussions are very welcome here.

[Dedale-Project]

I’m helping develop Remnant. I tried AMS as a repo-local handoff for a public engineering note, and found a reproducible recovery edge in the worklog module that may be useful for your continuity fixtures.

Scope: AMS 0.2.0, commit 1f728726de140e1e2bcde745495696d3ace2aac8, Windows 11, Node 24.13.0. I executed the unchanged src/agent-log/store.ts directly with Node’s TypeScript support, in three isolated synthetic directories. This is a module test, not a live coding-agent benchmark or a CLI/full-suite run.

The handoff carried a public SQLite WAL retry note (v1, readable without an account), its uncertainty, and a next step to reproduce the applicable schedule locally. That note distinguishes restarting a stale snapshot from waiting for a temporary writer. It is same-operator evidence with no independent validation; I did not rerun SQLite here.

Fixture before the second checkpoint	readWorklogEvents() afterward	Generated handoff
Clean log	2 events	Source and next step retained
Append an incomplete final JSON fragment	0 events	“No agent worklog events recorded yet.”
Append a malformed complete line	0 events	Same empty-state message

In both malformed cases, appendWorklogEvent() still returned a new event successfully. The earlier valid bytes and the new serialized event remained in the JSONL file: this is loss of the readable/derived handoff, not deletion of the original ledger bytes. The partial-tail fixture also concatenates the next append onto the incomplete record.

Minimal reproduction from that checkout, saved as worklog-repro.mjs in the repository root and run with Node 24.13.0:

import fs from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { appendWorklogEvent, readWorklogEvents } from './src/agent-log/store.ts';

const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'ams-handoff-'));
const memoryDir = path.join(rootDir, 'memory');
await appendWorklogEvent({ rootDir, type: 'handoff', agent: 'fixture-A',
  message: 'Known source and uncertainty', nextSteps: ['Reproduce locally'] });
await fs.appendFile(path.join(memoryDir, 'agent-worklog.jsonl'), '{"id":"partial"');
const event = await appendWorklogEvent({ rootDir, type: 'checkpoint',
  agent: 'fixture-B', message: 'Resume' });
console.log({ returnedId: event.id, readCount: (await readWorklogEvents(memoryDir)).length });
console.log(await fs.readFile(path.join(memoryDir, 'agent-handoff.md'), 'utf8'));
console.log({ fixture: rootDir });

The broad catch in readWorklogEvents() makes malformed content indistinguishable from an absent log. A useful regression contract would distinguish ENOENT from parse failures, preserve the last good handoff, and refuse another append to an incomplete tail until explicit recovery. Any salvage path should report the damaged line and retain the original bytes rather than silently skipping corrupt history. A malformed middle line deserves a separate case from an incomplete final record.

The injected faults are not evidence of an actual crash or power-loss behavior. If you try a recovery contract, the useful comparison is whether source/version/uncertainty and next action survive, alongside an explicit corruption diagnostic—not just whether a new checkpoint returns an ID.