Forget

The description states that Forget is a local-first, auditable memory layer for coding agents. It supports integration with tools like Codex, Claude Code, Cursor, and others via MCP (Model Control Protocol). Key features include:

• Shared memory across multiple clients.
• An observation gate to filter low-value content.
• Scoped retrieval by user and project, with temporal reranking.
• Non-destructive updates that supersede old decisions without erasing history.
• Git decision mining with receipts showing commit, author, and date.
• A default runtime using a local SQLite file and deterministic embeddings.

The product is described as not requiring an API key for the judge demo and uses Python 3.11, FastAPI, SQLite, and streamable HTTP MCP. It includes a Node.js CLI (forget-connect) to safely connect supported clients without overwriting existing configurations.

Inference The system appears to be a local memory management tool, not a cloud-based or centralized solution. It is built for developers working in AI-assisted coding environments.

The description states that Forget started from the belief:

“the model may change, but the developer should own the memory.”

It positions itself as an alternative to transcript archiving, which it argues is not a solution due to noise and stale context. Instead, it promotes forgetting well — i.e., retaining only what matters and discarding irrelevant or harmful information.

Key claims:

• Forget is not another transcript archive.
• It enables fresh agents to answer questions like “Why did we switch payment providers?” with current decision, reason, and source commit.
• It preserves prior decisions for audit.
• It uses deterministic local embeddings and does not require API keys for core functionality.

Inference The positioning has evolved from a conceptual memory architecture to a practical tool, with emphasis on scope isolation, provenance, and auditability. The project’s evolution during Build Week suggests a shift toward making the product more robust and testable.

The description does not explicitly name target customers or personas. However, it implies that Forget is aimed at developers using AI coding agents such as Codex, Claude Code, Cursor, and others.

It also suggests that users value:

• Auditability of decisions.
• Context isolation across projects and users.
• Non-destructive memory updates.
• Provenance tracking (e.g., Git commits).

Inference The ICP likely includes technical teams or individual developers who rely on AI-assisted coding tools and are concerned with maintaining clean, traceable, and scoped decision-making in their workflows.

The description does not mention any pricing model, revenue streams, or monetization strategy. It states that the project is open source under Apache-2.0 and that encrypted sync is still in design and not shipped.

Inference No business model or pricing evidence is provided. The product appears to be free and open-source, with optional paid features (e.g., encrypted sync) still under development.

The project is built using:

• Python 3.11
• FastAPI
• SQLite
• Streamable HTTP MCP
• Node.js CLI (forget-connect)

It includes:

• Scoped storage and retrieval.
• Temporal reranking.
• Supersession logic (new decisions override old ones without erasing history).
• Git decision mining with receipts.
• Deterministic local embeddings.
• Evaluation harnesses like LongMemEval and DirtyStores.

The authors claim to have used GPT-5.6 for final integration, review, and documentation but emphasize that it did not create the core engine or earlier benchmark results.

Inference The technical stack is Python-based, with a focus on local-first execution and developer tooling. It shows evidence of engineering rigor in evaluation and testing, including cross-system validation and contamination experiments.

The description states that:

• The project existed before Build Week.
• Development included 51 dated commits from July 13–20 KST.
• A public repository was submitted as a squashed, sanitized snapshot.
• Validation result: 78 tests passed, 1 skipped, plus the judge demo passed in both human-readable and JSON modes.

However, there is no evidence of customers, revenue, usage metrics, or adoption beyond the author’s own testing and development.

Inference The project shows early-stage maturity, with a functional prototype and evaluation framework. It lacks real-world traction or user data.

The description does not mention specific competitors. However, it positions itself as an alternative to:

• Transcript archiving.
• Generic memory systems that do not support scope isolation or provenance.

It is implied to be in the developer tooling space, possibly competing with tools that manage context or memory for AI agents, though no direct competitor names are listed.

Inference The competitive landscape includes tools focused on AI agent memory management, but no specific names or market positioning are provided. The project appears to be early-stage and unproven in the marketplace.

• No evidence of real-world usage or adoption: The product is described only as a prototype, with no data on customers or revenue.
• Unverified claims: All claims are self-reported; there is no third-party validation or benchmarking data beyond internal tests.
• Open-source and non-commercial: No monetization strategy or business model is evident.
• Encrypted sync not shipped: The team acknowledges that encrypted multi-device sync is still in design, not production-ready.
• Limited scope of testing: Benchmarks are limited to internal evaluation harnesses, with no external validation.

Inference The project is highly speculative, with no commercial traction or proven product-market fit. It may be a research prototype or proof-of-concept rather than a viable product.

1. What specific use cases have you identified for Forget in real-world development workflows?
2. How do you plan to validate the effectiveness of scope isolation and provenance tracking in practice?
3. Are there any early adopters or pilot users who are testing the product?
4. What is your roadmap for monetization, if any?
5. How do you intend to scale beyond a single developer’s use case?
6. What are the limitations of the current evaluation harnesses (e.g., LongMemEval, DirtyStores)?
7. Can you provide more details on how the observation gate filters low-value content?