Every developer pays an orientation tax: the time spent reconstructing where you were before you write a single line of code.
Tenure generates the handoff automatically, so you can pick up where you left off without re-explaining anything.
Context switching between repos isn't free. Neither is returning after a vacation, picking up someone else's ticket, or dipping into a project mid-sprint. The mental work of reconstructing "what state is this work in?" is invisible in velocity metrics and untracked in standups, but developers pay it every single time.
You context-switched to another project for two weeks. Now you're back. Which branch were you on? What was the half-finished thing? What had you decided about the auth flow? You have to re-read your own code to remember.
You're handed a ticket mid-sprint. The description says "add rate limiting to the API." It doesn't say where rate limiting lives, what pattern the team uses, or which service owns it. You spend 30 minutes finding out.
You're a solo dev bouncing between three repos. Claude Code, Cursor, VS Code: none of them remember where you were in any of them. You re-explain the same context over and over across sessions and tools.
You tried keeping context in AGENTS.md, .cursorrules, or a markdown file. It worked for two weeks. Then code changed, the file didn't, and now agents confidently follow stale instructions. The community calls this context rot. Maintenance becomes a second job.
You meant to leave notes before switching to the other repo. You didn't. Two weeks later you're reading your own commit messages trying to remember what "fix auth thing" meant. The context is gone. You start over.
You built a system: write a handover doc at the end of every session, then /clear and resume from it next time. It works when you remember. Most sessions don't end cleanly. Tenure writes the handoff whether you remembered to or not.
When you return to a project, Tenure surfaces a reconstructed summary of your last working session, directly in VS Code. No prompting required. No markdown to maintain. Built from the signals already flowing through Tenure as you work.
● Built from file activity, beliefs, and audit log turns. No telemetry beyond what Tenure already collects. ● Every bullet is traceable to a source event. ● Click "Resume in Chat" to open your AI client pre-loaded with this context.
Tenure doesn't ask you to maintain context files or write session summaries. Project Resume is built automatically from the activity stream flowing through Tenure every time you work, then summarized on demand when you return.
Every time you switch files in VS Code, Tenure records the path, language, and timestamp. No extra step. This is the same workspace sync that powers scoped belief injection. Project Resume is a derived view over data you're already producing.
When you return to a repo, Tenure assembles a source bundle: the most recently visited files for this project, beliefs created or updated since your last session, and the queries you sent through the audit log. No LLM needed yet — this is a deterministic query over existing data.
A single LLM pass over the source bundle produces the summary: files, beliefs, queries, and inferred next steps. Facts and inferences are kept separate. You can always ask "why am I seeing this?" and every item traces back to a source event in the audit log.
The Resume in Chat button injects the full snapshot as a context block into your AI session. Ask "what should I do next?" and the model answers from your actual last session — not a generic suggestion based on the filename.
Developers have tried markdown files, .cursorrules, AGENTS.md, Obsidian notes, and MCP memory servers. They all solve part of the problem. None of them solve the returning-to-work problem.
Great for stable conventions. Breaks when code changes and the file doesn't. Best developers in the Cursor community describe it as "the boring answer", it works until maintenance becomes its own job.
Promising, but cross-tool reliability isn't there yet. Memory that one tool writes, another reads only works if both are disciplined about when to write and retrieve and in practice they're not. Mostly experimental outside single-tool setups.
Good for personal notes. As agent context it goes stale fast. Requires manual updates after every session. The cognitive overhead of maintaining external notes is itself part of the problem.
Derived from signals already flowing through Tenure. No file to maintain. Scoped to the active project. Traceable to source events. Works across every tool that routes through Tenure: VSCode, Windsurf, or Claude Code.
The next layer of Project Resume connects sprint planning to the IDE. A Jira ticket assigned during standup already contains enough information to know which files, services, and patterns are relevant. Tenure will close that gap — so the developer who sits down to code is already oriented before they've typed a character.
Link a ticket to a Project Resume snapshot. Tenure surfaces which files are likely to need changes, based on the ticket description and your project's belief graph.
Coming soonArchitecture decisions in Confluence become part of the context injected when you open a relevant file. The planning doc from last month surfaces when it's actually useful.
On the roadmapRecent commits and open PRs against this project scope fold into the resume. What changed, who changed it, and what review comments were left — visible before you write the next line.
On the roadmapInstall the VS Code extension, point your AI client at localhost:5757/v1, and Tenure starts building context the moment you open a file. Project Resume is available as a button in the Tenure sidebar panel.