Rift

One memory layer. Every agent.

Git tracks code.Rift tracks the AI work behind it.

The system of record for AI-assisted engineering. Trace captured changes, verify their history, and reduce repeated context — with memory that stays with your code.

See how Rift works
An ASCII agent cloud contributes a new code hunk to a curved chain of transparent blocks.

A shared memory, taking shape

Recall. Change. Remember.

What one agent learns, the next can build on.

One memory. Every model.

  • OpenAI
  • Anthropic
  • Google
  • DeepSeek
  • Mistral
  • xAI
  • Meta
  • GitHub Copilot

01 / Provenance

The code is only half the story.

Rift connects captured AI sessions to the code they changed. Give reviewers the prompts, edits, model, and context behind a commit — while that knowledge is still useful.

Review with context
Follow a checkpoint back to the work that produced it.
Keep knowledge with the code
A git-native record survives the end of the chat.
A chain of tinted code dominoes rotates to reveal one highlighted session and its provenance.

09:41:08 / session 024

A change, remembered.

Author
Maya Chen
Model
Fable 5.1
Changes
8 hunks · 3 files
Context
12.4k tokens

6 turns / session activity

From “who changed this?” to a record your team can inspect.

Illustrative session · sample data

02 / Verifiable history

Trust the work. Verify the record.

Captured history is append-only and cryptographically linked. Verify checkpoint contents and their order against the record in git, with findings that expose changes to recorded history.

Tamper-evident by design
Hashes bind the contents; the chain preserves their order.
Corrections leave a trail
New records supersede old ones. History stays inspectable.
A verification pulse follows a chain of linked checkpoints, illuminating their hashes.

Checkpoint verification

A history you can check.

contents → hashMATCH
hash → checkpointMATCH
checkpoint → chainMATCH

A changed byte or broken link becomes a finding. Verify from git; rebuild the local view from the same record.

$ rift verify

Tamper-evident: detects changes to the recorded history.

Evidence for an engineering review, incident investigation, or internal audit.

Illustrative session · sample data

03 / Context efficiency

Stop paying for the same context.

Recall tracks what an agent has already received and what changed. On supported paths, bounded changes and reusable context reduce repeated reading — leaving more room for useful work.

Understand the opportunity
Measure repeated repository context before optimising it.
Keep the numbers honest
Inspect usage and estimated avoidance separately.
Known context dims while the changed dominoes remain bright beside a smaller context comparison.

Recall what matters.

Full context12.4k
Only the change1.8k

Illustrative context comparison

The opportunity is less repeated context, not a blanket savings percentage. Results depend on the workload and agent integration.

Estimated token avoidance is reported separately from provider usage and priced cost estimates.

Make context efficiency a measurable engineering decision.

Illustrative session · sample data

04 / Local data control

Keep knowledge. Protect secrets.

Captured content passes through redaction before it becomes a durable checkpoint. Capture runs locally, with repository policy and custom redaction rules under your control.

Local capture
No network calls on the capture path.
Policy in your repository
Add rules for your organisation’s credential formats.
A local chain of checkpoints passes through a redaction boundary before entering the durable record.

Before the checkpoint

A deliberate boundary.

01 / CAPTURE LOCALLY

prompt · tool output · edit

02 / APPLY REDACTION

api_key = [REDACTED]

03 / WRITE CHECKPOINT

redacted content + report

Keep a report of what the redaction rules removed, without keeping those detected secrets in the durable record.

Build a useful engineering memory with deliberate control over what is kept.

Illustrative session · sample data

05 / Connected workflows

Two products. One memory.

An engineer writes the change. A teammate works with its context. Our product vision brings Rift Code and Rift Desktop around the same record, so the work can carry forward.

A foundation already in git
Rift Code brings linked worktrees into one repository family.
Rift Code and Rift Desktop contributors connect through a shared domino chain.

● ONLINE / MAYA CHEN

Rift Code ↗

Writing the next change.

● ONLINE / ARI PATEL

Rift Desktop ↗

Building on the same context.

Product vision · connected contributors shown for illustration.

Illustrative session · sample data

06 / Engineering visibility

See where your AI effort goes.

Bring sessions, touched files, context usage, and model costs into view. Canopy gives your team a local dashboard; the read-only viewer lets you inspect the evidence behind a checkpoint.

Understand the spend
Separate input, output, cache reads, and cache writes.
Go from overview to evidence
Inspect recorded sessions and verification details.
Highlighted sessions in the code chain connect to a compact activity and model-usage view.

CANOPY / SESSION OVERVIEW

One session. A useful view.

09:41 / prompted
Maya · Fable 5.1
09:43 / refined
Ari · GPT-6 Astra
09:46 / reviewed
Lena · 8 hunks checked
Explore the record

A clearer view of AI-assisted work, from a single session to a repository.

Illustrative session · sample data

Make AI work
an asset your team keeps.

Start with a repository. See the provenance, inspect the record, and measure the opportunity in your own workflow.