Catch-up is how a session opens already knowing what changed while it was away. One call at the start, and an instance sees what your other instances and your teammates did since it last looked - "what did the other Claude do while I was gone?" answered automatically, instead of by chance.
It's the twin of recall. Recall returns the accumulated knowledge; catch-up returns the delta of activity since this instance last checked. You reach for recall when you're about to touch a thing; catch-up you call once at the top of a session to get your bearings.
The mental model: per-instance, not per-user
The cursor - the "last looked" watermark - belongs to the credential, not the user. An API key or an OAuth client is one instance, and each instance keeps its own watermark. That's the whole point:
- Reading catch-up on one instance does not mark it seen for your other instances.
- The delta excludes this instance's own writes - they're not news to it - but includes the same user's other instances' writes, and your teammates'.
A per-user cursor would defeat it: one instance checking in would consume the news for all of them. So a session that publishes something and a session that wants to know about it can be two instances of you, and catch-up still works between them.
Ask for it in words
"Catch me up - what's changed since I last looked?"
"Before we start, run catchup."
The Claude skill makes an instance call it unprompted at the start of a session, so "start caught up" is automatic rather than a habit you have to remember.
What it surfaces
Everything a different identity did in your visible workspaces since your last look:
- Publishes and shares - new collections and memories, and collections shared into your workspaces.
- New versions - a new version pushed to an artifact you can see.
- Feedback - comments, approvals and rejections on your team's work. This is broader than your inbox: the inbox tells the owner their work got feedback, catch-up tells anyone in the workspace who can see it.
- Memory lifecycle - memories promoted into a workspace for review, deprecated, or withdrawn.
It only ever contains what you could already see. The delta runs through the same visibility rules as everything else - author-private work and private projects you're not in never appear, whoever's activity produced them. Catch-up is not a way to see more; it's a way to not miss what's already yours.
Reading, peeking and the first look
Reading catch-up advances the cursor - it consumes the delta, so the next call starts from where this one finished. When you want to check without consuming, peek: it returns the same delta and leaves the watermark where it was.
The first look on a fresh instance just sets the watermark and comes back empty. There's no "while you were away" window for an instance that has never looked before, so it starts the clock rather than dumping the entire back-catalogue on you. From the next session on, you get the delta.
The list is capped (50 by default), newest first, with the overflow reported as a count - "and 12 more" - so a busy workspace stays a digest rather than a firehose.
From the CLI
kythe catchup # the delta since this credential last looked; advances the cursor
kythe catchup --peek # the same, without consuming it
kythe catchup --limit 20 # cap the digestEach item comes back with what changed, the collection it changed, who did it, when, and a link to open it.
Getting it wrong
- Catch-up is always empty. The first call on any credential sets the watermark and returns nothing - that's expected. Run it again next session. If it stays empty, nobody else has published, given feedback or changed a memory in your workspaces since you last looked, which is a quiet team, not a bug.
- It's not showing my own instance's work. By design - your own writes aren't news to you. Another of your instances will see them.
- I expected a teammate's private-project change and it's not there. You're not a member of that private project, so it's hidden from you here exactly as it is everywhere else. Ask to be added to the project.