continuity and cross-model handoff

AI work that survives resets, model swaps, and handoffs.

Remaind turns context and memory into a local handoff layer: decisions, scope, progress, blockers, evidence, and the next safe step move across sessions, models, agents, and tools.

Start the next model from current truth, not old chat archaeology.

Capture decisions, blockers, files, evidence, and next steps at the end of work.

Move work between local models, API models, coding agents, and closed chats.

Cross-LLM

portable handoff packets

Continuity

work survives resets

Governed

source-linked decisions

Local-first

owned .context memory

Why now

AI work needs continuity, not a bigger prompt.

Models are powerful, whether they run locally or through an API. The missing piece is continuity: knowing what applies, why it applies, where it came from, and what should happen next every time the user returns.

Context windows are not continuity

Even the strongest models only know what the app gives them right now. Real work needs a portable state and handoff layer around the model.

Every model should inherit the work

A fresh session, model swap, or agent handoff should not mean a cold start. Remaind keeps the next brief ready to load.

Continuity should be governed

Useful context separates current truth from stale noise, tracks provenance, and fails closed when reviewed state does not safely apply.

Product

One continuity and handoff layer for any model, task, or agent.

Remaind is not another model and not generic recall. It turns durable, source-linked memory into focused working context and portable handoff packets for whichever model, agent, or workflow you choose.

What enters the next context

A focused operating brief, not a transcript dump.

Remaind keeps the durable truth separate from live chat noise, then assembles the pieces a fresh model needs to continue.

Current goal

what the work is trying to finish

Decisions

what has already been chosen

Constraints

what must not be violated

Progress

what changed since the last session

Evidence

files, outputs, artifacts, reviewed decisions

Next safe step

where the next model should begin

Ask from current state

Ask what changed, what is blocked, and where the next model should start.

Handoff across models

Move work from one model, agent, or chat surface to another with a readable packet.

Carry reviewed decisions

Bring plans, policy exceptions, decisions, and evidence forward.

Control the memory

Keep operating memory local-first, source-linked, and portable across tools.

Start with handoff

Proof

Run the proof path from a clean install.

The fastest way to trust Remaind is to run it. This creates a local workspace, verifies the offline plan boundary, runs the governed finance handoff demo, then runs executable continuity, speed, context-engine, agent-hook, and handoff checks.

5/5

Packet Recall

0/5

False Application

5/5

Honor Rate

5/5

Decision Retention

Copy-paste terminal path

One command block, full local proof.

python3 -m pip install --upgrade remaind

remaind plan
remaind init
remaind doctor
remaind demo finance-handoff \
  --force
remaind proof

What the proof checks

The proof creates real local state and reports explicit PASS/FAIL checks.

No hosted Remaind account required.

Plan boundary proves Basic stays offline and user-owned.

Creates and reads a real local .context workspace.

Prints PASS/FAIL output instead of relying on marketing claims.

Exercises ordinary continuity, governed memory, and universal handoff export.

Install

Fetches the published Remaind package.

Plan

Confirms Basic is offline and not tied to billing or accounts.

Initialize

Creates a local .context workspace.

Doctor

Checks the ledger, state, and runtime readiness.

Finance demo

Runs the governed policy-exception handoff proof.

Proof

Runs continuity, handoff, speed, context-engine, matrix, and agent-hook checks locally.

Real local-model proof

Model-to-model handoff, with Remaind as the continuity layer.

The optional agent-continuity demo can use any configured local or private OpenAI-compatible model after the deterministic proof path. It checks whether the receiving model can continue from the Remaind packet and cite source evidence.

export REMAIND_OPENAI_BASE_URL="<your-openai-compatible-model-url>"
export REMAIND_OPENAI_MODEL="<your-model-id>"
export REMAIND_OPENAI_API_KEY="<optional-local-or-private-key>"
export REMAIND_OPENAI_API=auto

remaind demo agent-continuity --force

PASS

A real local-model run recovered the software task, decision, constraint, blocker, next step, and source event evidence from a Remaind packet.

Source model state

software task, decision, blocker, constraint, and next step captured

Remaind packet

fresh-context brief assembled from local source-linked memory

Receiving model

continued from the packet and cited source event IDs

Capture loop

receiver output can be saved back into the same .context ledger

Early access

Build AI work that carries forward.

Join the early group shaping continuity and cross-model handoff for serious builders, regulated AI teams, local-model users, and agent workflows.

Email and password only.

Works with local-first and API-backed workflows.

Finance policy-exception handoff is the first proof path.

Early access is for product access and onboarding. Your operating memory stays under your control.