Wye 為編碼智能體保存跨工作階段的決策脈絡

Disclosure: I’m building Wye. This article was drafted with AI assistance.

Have you ever opened a feature you built with an agent and wondered: why did we decide to do it this way?

The code is there. The tests pass. But the conversation that explained the odd exception, the rejected alternative, or the customer promise is buried in an old session.

When you build with a coding agent, decisions happen throughout the work. Some emerge in conversation: you explain a constraint, reject an approach, or agree on an exception. Others happen during implementation, when the agent chooses how to handle something you haven’t specified.

You get the result. The history of why it works that way is easier to lose.

Imagine deciding that edits to published content should create a draft, because customers need to review changes before making them visible. Weeks later, you ask another agent to simplify editing. It removes that distinction. The new implementation might satisfy the immediate request. What it has lost is the reason behind the earlier behaviour.

Preserving that reasoning is one problem. Keeping it consistent as the product changes is another.

That is why I’m building Wye: agentic memory that people and agents can communicate with, inspect and evolve together.

Memory that grows with the work

A product accumulates requirements, constraints, decisions, exceptions, unanswered questions, and reasons certain approaches were rejected. Code captures the implementation. It doesn’t reliably explain whether an unusual behaviour is accidental, a temporary compromise, or a customer commitment.

Wye gives that additional context somewhere to live.

You install a vault alongside your project, with skills that teach agents to read and contribute to its memory. You continue using your coding agent and existing development workflow. The memory grows through the work you’re already doing.

The intention is to capture durable knowledge, rather than preserve every conversation. A session may contain ten possible approaches, several misunderstandings and one consequential decision. Carrying everything forward leaves the next agent to reconstruct which statements matter and which still apply.

A useful memory preserves the decision, its reason, its scope and its relationships to what is already known. Decisions an agent makes independently also deserve visibility: they can shape the product just as much as choices made explicitly in conversation.

Wye provides an interface for people to ask questions, explore those relationships and review proposed knowledge. Agents work with the same memory through their tools and skills.

Product knowledge in Wye’s document interface. Screenshot from the project repository.

Where does that reasoning live in your projects today: a decision log, agent memory files, tickets, or mostly in your head?

Consistency starts when memory is written

Suppose the memory says that editing published content creates a draft. A later session produces a decision that edits should become visible immediately. Saving both statements without reconciling them gives future agents conflicting instructions.

Wye checks incoming knowledge against its neighbours in the graph. Does it duplicate something already recorded? Refine an existing statement? Remain consistent with it? Contradict it?

A contradiction may represent a legitimate change. Perhaps immediate publishing is now allowed for personal pages, while shared pages still require review. Perhaps the original rule has been replaced entirely.

The relationship needs to be made explicit. People review the conflict and decide what holds. When a decision is superseded, its history remains available, including why the product previously worked differently.

This is the purpose of checking consistency on write: address conflicting knowledge as it enters memory, before later agents inherit the ambiguity.

The Inbox brings proposed knowledge and contradictions into a human review surface.

Related research treats memory maintenance as an active process too. Mem0 describes comparing candidate memories with existing ones to decide how memory should change. Its graph variant checks conflicting relationships and retains invalidated relationships for temporal reasoning. Zep similarly describes detecting contradictions between new and existing facts while preserving their history.

Those papers support the design motivation. They do not validate Wye’s implementation or establish a guarantee that every inconsistency will be found.

Markdown beside the code, a connected graph at runtime

Wye’s canonical storage is Markdown because I want product knowledge to live beside the code. It can travel with the repository, be reviewed in a diff, and retain its history in Git. You can read and edit the underlying files without depending on Wye’s interface.

At runtime, Wye represents that knowledge as a connected graph. Retrieval can follow relationships: which decision governs a requirement, why a constraint exists, what depends on it, and which newer decision superseded an older one.

Text similarity helps locate relevant material. Explicit relationships let retrieval reach connected knowledge even when it uses different language. A-MEM explores a related direction through interconnected memories whose links and contextual representations evolve as new memories arrive.

A map view of connected knowledge. The runtime graph also supports retrieval beyond this visual view.

For the publishing example, the useful context includes the review requirement and its rationale, not just passages mentioning editing.

What would make this useful to you?

The difficult balance is capturing enough reasoning to preserve continuity without creating a second documentation job.

Wye is early, local-first and Apache-2.0 licensed. It works with Claude Code and Codex. The repository includes a tour and setup instructions.

I’d especially like to hear about one real decision that got lost between your agent sessions. What was decided, why did it matter, and what happened when that context disappeared?

Or challenge the premise: would you trust an agent to capture this context? Which independent choices should require your review? When should memory flag a contradiction, and when should it leave you alone?

Leave an example or an opinion in the comments. You don’t need to install Wye to contribute to this discussion. If you do try it, start with one feature or one recurring decision—and tell me where the memory helps or gets in your way.