Every project starts the same way. Someone asks "do we have notes from the last one?" Half an hour of Slack search ends with "I think it's in someone's drive." We rebuild the same context every quarter, and the hardest-won lessons leave with whoever moves on.
Projects ship. Lessons don't. The kickoff doc, the decision log, the post-mortem — they exist, in twelve places, in three formats, in two people's heads. We didn't build another project tool. We built the part that survives the project — the part that hands the next team the precedent before they ask for it. Some people will call this project documentation. We call it the missing function of project memory.
The problem isn't that your team doesn't document. It does — kickoff briefs in Notion, meeting notes in Granola, decisions buried inside Slack threads, retrospectives nobody reads twice. The artifacts exist. They just don't talk to each other, and they don't survive the team that made them.
Three months later, when a new project asks the same question the last project answered, the archive is silent. Someone Slacks the original lead, who's now on parental leave or another team. The decision gets remade — sometimes the same way, sometimes wrong — without ever touching the lesson sitting one folder away.
That's not a documentation problem. It's a precedent problem. Project tools are built for the project that's running. Almost none of them are built for the project that just ended, or the one starting next quarter that needs to know.
Knovya is the part of the workflow that remembers between projects — so the next team doesn't pay for the same lesson the last team learned. Decisions, meetings, and retrospectives link to each other automatically through backlinks. Experience Envelope quietly attaches the past project's similar moment to the new one, with its outcome attached.
When a kickoff doc opens, the relevant retros from the last three projects surface alongside the blank page. When a mid-project decision feels familiar, the precedent shows up before you ask whether it should. Through MCP, Claude and Cursor read the project archive natively — the context follows you into the tool you're already working in.
We don't call ourselves a project tool. We call it the missing function of project memory — the part that turns each finished project into the foundation for the next one.
The lesson, surfaced beside the new decision, before you remake the same call.
Three moments inside a project's life. Pick one — the archive lights up the part of itself it would actually use. No live data, no signup; the moves are real, the project is illustrative.
The kickoff conversation lands as a structured project entry — context, scope, stakeholders, the unknowns named.
Last project's kickoff doc and retro surface beside the new one — the scope you wrote three months ago is right there to compare.
The brief writes its first draft from your kickoff thread. You start with two-thirds of a document, not a blank page.
The brief ships to the team. Claude reads it for the standup. Cursor reads it before the first commit.
Forte called these four moves CODE. We borrowed them and pointed them at the work that runs across projects, not just inside one.
Same CODE that runs a personal archive runs a project archive — pointed at decisions, meetings, and retrospectives instead of highlights and quotes. Here's which features carry which move, mapped to the elements you'll find on the periodic table at /features.
Project context arrives faster than people can write it down — kickoff conversations, research, post-meeting reflections, voice on the drive home.
A kickoff in Claude or ChatGPT, saved as a structured project entry.
Benchmarks, references, competitor scans become project notes with source attached.
Drive-home reflections after a kickoff or retro arrive as structured entries.
The project arranges itself by what it's connected to — meetings link to decisions, decisions link to outcomes, the load-bearing notes rise.
Every meeting, decision, and doc visible from both sides, automatically.
The load-bearing project notes — the ones everything else points at — rise to the top.
A view of where the project's dense regions are forming — kickoff, decisions, retro, the threads between them.
Past projects answer the new project before you ask. Precedents surface alongside decisions; status writes itself from the trail.
Past project decisions surface alongside new ones — outcomes attached, lessons in reach.
"What did we decide last time about X" — keyword and meaning, ranked together.
Status from your trail, retrospective summary from your meetings, brief from your kickoff thread.
Forgotten project decisions return when their topic comes up — even months later.
The project is the start of the next project — exposed to the team, to leadership, to every AI you already work with.
Public-team-private layered access — the retrospective shareable, the decision rationale workspace-only.
Claude, Cursor, and ChatGPT read the project archive natively — context follows you into the tool.
Project work has had names since 1910s. The artifacts changed — bar charts, methodologies, SaaS, AI — but the question stays the same: how does this project hand the next one what it learned? Knovya is the latest answer, with a different bet than the ones before it.
Gantt's bar chart gives projects a shape outside someone's head — tasks, durations, dependencies, drawn. For the first time, a project's plan can be reviewed by people who weren't in the room when it was made.
The Project Management Institute publishes the PMBOK guide — initiation, planning, execution, monitoring, closure. Documents become deliverables in their own right. The artifact set is named: charter, scope, schedule, risk register, lessons learned.
Allen names what Gantt and PMI couldn't reach: projects live in your head between status meetings. Capture, clarify, organize, reflect, engage. The book teaches a generation of knowledge workers that the inbox isn't a file cabinet — it's a thinking instrument.
Three tools split the project into pieces and each picks one to be best at: Linear takes the issue-as-spec, Notion takes the doc-as-source-of-truth, Asana takes the task tree. Teams stack them. The execution layer gets sharper. The memory layer between projects stays where it was.
Height, Linear's AI features, Notion AI, Granola — typing finally falls to the machine. Status updates auto-generate, action items extract themselves, summaries arrive before the meeting ends. CODE survives; the manual labor doesn't. Inside the project, the friction is gone. Between projects, the silence is the same.
We built the part Gantt's chart couldn't carry, PMBOK couldn't enforce, Allen couldn't externalize, and the modern stack chose not to: the precedent layer between projects. Backlinks bond the trail. Experience Envelope surfaces the matching past moment. MCP exposes the archive to the tools you already work in. The missing function, finally external.
Most apps in this category are wagering on a piece of the project that's running now — the doc, the issue, the task tree, the spec. The honest comparison isn't features. It's which part of the project each tool decided to be best at, and which it leaves to the next team to rebuild.
The bet A flexible structure for everything project-shaped — briefs, databases, wikis, templates. If you can model your project as a schema, Notion will hold it.
What's left to you The precedent layer. Past projects archive cleanly; they don’t surface when the new one needs them. The lessons sit in pages nobody re-reads.
The bet Engineering speed, ticketed. Every project becomes a tree of issues — small, assignable, statused. The execution layer for shipping software gets exceptionally sharp.
What's left to you The why. The decisions and rationale that produced the tickets sit outside Linear. When the new project asks "why did we choose X last time," the issue tree can’t answer.
The bet Hierarchy of work, dependencies tracked. Asana models the project as nested tasks with owners and dates. The Gantt instinct, productized for cross-functional teams.
What's left to you The qualitative project memory. The kickoff context, the decision rationale, the retrospective insight — they don’t fit inside a task and don’t carry to the next project’s tree.
The bet Each team builds its own project tool from blocks. Docs become apps; tables become workflows. If your project is unique enough to need its own shape, Coda lets you ship one.
What's left to you The build cost — and the precedent layer underneath it. Teams don’t ship a doc-as-app for every project, and the apps they do ship rarely talk to last quarter’s.
The bet The part between projects. Backlinks bond the trail; Experience Envelope surfaces the matching past moment with its outcome attached; MCP exposes the project archive to Claude, Cursor, ChatGPT — the tools the team already lives in.
What's left to you Picking which lesson to act on. Recall is on the system. Recognition — the part the team is good at — is the only piece left for you.
Notion, Linear, Asana, Coda execute the project. We built the part that remembers it.
A project memory is only useful if it reaches the meeting where the decision lands, the chat where the next call gets framed, the doc where the next team will start. Knovya works on every surface where those moments happen.
Voice-note the kickoff reflections before they evaporate — they land as a structured project note, linked to the kickoff doc by morning.
Kickoff at the center, decisions and meetings branching out, the retro pulling them back together. The graph view shows where the project is dense — and where the next one will look for it.
Experience Envelope quietly attaches the past project's similar moment — and what it actually cost — beside the new one. You read the precedent before remaking the call.
Through MCP, every tool the team already lives in can read the project archive — the decision rationale, the retros, the precedent — without a single copy-paste.
Project notes don't stand alone — they bond with the meetings that produced them, the decisions they record, and the team they outlive. Here's the constellation around this page.
Past project decisions surface beside new ones — outcomes attached, lessons in reach.
See featureEvery meeting, decision, and doc visible from both sides — the project trail stays walkable.
See featureClaude, Cursor, and ChatGPT read the project archive natively — context follows the team.
See featureThe retro shareable, the rationale workspace-only — layered access without four tools.
See feature"Every meeting starts with re-explaining the last meeting."
Meetings that compound into decisions — transcribed, structured, action items extracted, linked to the project trail.
See the workflow Problem 08 · Chapter II"We keep remaking decisions we already made."
Decisions with their context, alternatives, and outcomes — searchable, linkable, and surfacing when they're relevant again.
See the workflowThe 110-year arc from Gantt to AI-native, the four phases (initiation, planning, execution, closure), and what AI changed in 2024.
Read the primer DefinitionThe team-memory system underneath project notes, internal wikis, and onboarding docs — and where the precedent layer fits in.
Read the primerA project memory isn't built in one sprint. It's built one captured decision, one surfaced precedent, one re-read retro at a time. The archive starts compounding the moment your second project does.
Or scroll back to the diagnosis.
Eight questions that come up before adoption. If yours isn't here, the contact page reaches us directly.
Project documentation is the written record a team keeps so the project can survive its participants — the kickoff brief, the meeting notes, the decisions and their reasoning, the status updates, the post-mortem. The PMI organizes it into initiation, planning, execution, and closure documents. In practice it's whatever a future teammate would need to understand why this project went the way it did, without asking anyone who was there.
A complete project archive usually carries seven artifacts: a project brief or charter, a kickoff document, meeting notes, a decision log with alternatives and outcomes, status updates, a retrospective, and a post-mortem. Knovya treats them as a single connected trail rather than seven separate documents — every meeting links to the decisions it produced, every decision links to the project that ran into the consequences.
Most teams classify project documentation into four kinds: planning documents (briefs, scope, charters), process documents (meeting notes, status updates), decision documents (decision logs, ADRs, technical specs), and outcome documents (retrospectives, post-mortems, hand-offs). Knovya bonds the four together — a decision links forward to its outcome and back to the planning context that produced it.
Three habits separate documentation that survives from documentation that decays: (1) capture decisions with their alternatives, not just the verdict, so future readers can re-evaluate context; (2) link every meeting to the decisions and action items it produced, so the chain stays walkable; (3) close every project with a retrospective that names what would change next time — and store it where the next team will actually find it. Knovya is built around the third habit.
Project notes are the live trail — the running record a team makes during the work: kickoff captures, meeting notes, decision threads, mid-project status. Project documentation is the curated subset that survives the project for future teams. Knovya doesn't ask you to maintain both — the notes become the documentation through linking, retrieval, and the precedent layer.
Notion, Linear, Asana, and Coda are project execution tools — they organize the work happening now. Knovya is a project memory tool — it organizes what the last project learned so the next project doesn’t pay for the same lesson twice. Through Experience Envelope, similar past decisions surface alongside the current one. Through MCP, Claude, ChatGPT, and Cursor read the project archive natively. Different category, complementary stack.
Experience Envelope is Knovya's precedent layer. When you're writing a new decision, opening a similar meeting, or drafting a kickoff brief, Knovya quietly surfaces past project moments that match — the decision your team made under similar pressure, the outcome it had, the team that owned it. You read the precedent before remaking the call, without searching for it.
Yes. Knovya Free is forever-free with 50 notes, 50 AI credits per month, and 50 MCP calls per month — enough to run a complete two-project arc (kickoff, meetings, decisions, retro × 2) and watch the precedent layer start to compound before paying anything.