Persistent project context for AI
Your project should not reset every time the chat does.
Every time you start a new conversation, switch AI tools, come back a week later or hand the work to someone else, part of the project disappears.
Palimpse keeps the project together: the decisions and their why, the work still open, the documents that matter, and the history of how it all changed. So the next person or AI can pick the project back up exactly where it stands.
Free for solo. Works with the AI tools you already use.
Same project. Different AI. Nothing to rebuild.
“Pick up the Palimpse project.”
Here’s where things stand
- The landing direction changed yesterday
- The new demo structure was approved
- One technical issue is still blocking search
- The old positioning was ruled out, with the reason preserved
“Pick up the Palimpse project.”
Here’s where things stand
- The landing direction changed yesterday
- The new demo structure was approved
- One technical issue is still blocking search
- The old positioning was ruled out, with the reason preserved
The conversation changed. The project did not.
The chat is temporary.
The project is not.
AI tools are built around conversations. Projects are not. A real project lasts across dozens of sessions. It accumulates choices, unfinished work, false starts, documents, questions and people. But today, most of that history is scattered across chat windows and individual memories.
So every restart costs you something.
- You explain the context again.
- An old idea comes back as if it were new.
- A decision survives, but the reason behind it disappears.
- Someone takes over without knowing what happened before.
- You switch tools and leave the context behind.
The problem is not that AI forgets facts. The problem is that the project loses continuity.
Everything the project needs to continue.
Not every trace. The things that change what should happen next.
Decisions
What was chosen, why, and what was ruled out.
A decision is not just an answer. It is the reasoning that should stop the same question from being reopened by accident.
Open work
Tasks and unresolved threads stay visible until they are actually closed.
The project does not just remember the past. It knows what still needs attention now.
Documents
The knowledge the project depends on stays part of the project itself.
Documents are versioned, connected to their history and available to whoever or whatever picks the work up next.
Sessions
A record of what changed, who moved it forward and where the work stopped.
Sessions connect one state of the project to the next.
Decisions preserve the why. Open work preserves the present. Documents preserve the knowledge. Sessions preserve the movement.
That is what continuity is made of.
How it works
Come back briefed.
Start a new session. Ask your AI to pick up the project. Palimpse gives it the current state before the work begins.
What changed
The landing was simplified around project continuity.
What was decided
The simulated chat demo was removed. It made the product feel narrower than it is.
What is still open
Test the onboarding flow and fix the remaining search issue.
What matters to read
The positioning document was updated and is part of the current project context.
You do not reconstruct the project from memory. You continue it.
Then just work.
Use the AI that makes sense today.
You do not need to move your work into Palimpse. Palimpse stays underneath it. The AI reads the project history when it needs context. You keep working where you already work.
When the session ends, the project moves forward.
The useful trace is kept:
- what changed;
- what was decided;
- why it was decided;
- which tasks were opened, advanced or closed;
- what is still unresolved;
- which documents were created or changed.
The next session starts from that new state.
No separate report to write. No archaeology through old conversations. No perfect documentation discipline required.
The history becomes a by-product of the work.
You can leave.
The project stays.
Come back tomorrow. Come back in six months. Open another AI. Let someone else take over.
You, next week
You reopen the project and immediately see what happened since you left.
Another AI
It starts with the same history instead of rebuilding its own version of the project.
A teammate
They inherit the current state of the project: the decisions, the reasoning, the open work and the documents that matter.
The person changes. The model changes. The conversation changes. The project keeps its thread.
This is not another AI memory.
AI memory
It usually remembers things about you.
- Your preferences
- Your habits
- Facts that may be useful later
A project needs something different
It needs a living state and a history of intent.
- Why one direction was chosen
- Why another was abandoned
- What has already been tried
- What still needs to be done
- Which documents carry the knowledge of the project
- Where the work actually stopped
Memory helps an AI remember. Palimpse helps a project continue.
AI memory vs project continuity, compared What AI project memory misses
Built with itself.
Palimpse keeps the history of Palimpse. The product decisions behind this page are in the project. The rejected versions are there too. The tasks still open are visible. The documents that carry the current thinking are part of the same history.
When work resumes, we do not search through old chats to remember what we were thinking. We ask Palimpse where the project stands.
Stop making the demo look like a chatbot conversation.
The earlier version simulated a long exchange. It was rejected because the conversation was not the product. The important thing was what survived after the conversation ended.
This is what Palimpse is for.
One project history.
Many ways back in.
Palimpse works with compatible AI clients through MCP. Connect it once. Then the same project can be picked up from different tools without rebuilding its context each time.
Your project does not belong to Claude. It does not belong to ChatGPT. It does not belong to the next model either.
The tools are how you work with the project. They are not where the project lives.
Start alone. Share the continuity when the work becomes shared.
Solo
For people running projects across multiple sessions and AI tools.
- Unlimited projects
- Project history
- Decisions and reasoning
- Open threads
- Documents
- Portable context across compatible AI tools
Team
For teams that need humans and AI to work from the same project history.
- Everything in Solo
- Shared workspaces
- Shared project history
- Session attribution
- Invitations and roles
- Visibility into what moved forward
Free during V1 for early teams.
The project should outlive the conversation.
Today, Palimpse gives continuity to projects that work with AI. Over time, the ambition is larger: to become the place where the history of a project lives, independently of the human, AI or tool touching it at any given moment.
The work moves. The people change. The models change. The tools come and go.
The continuity stays.