Skip to content

Category: Tether · Session Continuity

Close the lid. Open the other machine. Keep going.

Tether is the device and session tethering layer of the Ember family. Attach a second machine you own, and the live session state — context, workspace, running work — travels with you. Resume means resume: not a summary of where you were, but the actual state, picked up.

Built for

  • Developers
  • Creators & technical artists
  • Researchers & engineers
Status
Beta
Ledger step
Ledger step 3 of 4
Family
Workspaces
Access
This site only
Listed
3 / 4
State, not summaries
Continuity
Your machines only
Owned hardware
Confirmed by receipt
Verified handoff
No cloud detour
Local-first

What this page can show today

  • The register marks this track as a public test or verification build.
  • This track is documented on this site only.
  • Capabilities below are the published feature list for this track.

Limits of this page

  • No public product site is published for this track.
  • Beta is not a production claim.
  • This page does not publish financials, headcount, or client names.

Key features

  1. 01

    Explicit device pairing

    Machines you own attach over a verified link. You name the machines, you approve the bond, you can break it.

  2. 02

    Session continuity

    Live session state (context, workspace, running work) transfers as state; the receiving machine resumes the work, not a description of it.

  3. 03

    Verified handoff

    A handoff is confirmed by receipt, not assumed from sending; a resume that does not land is reported honestly, not silently retried.

  4. 04

    Local-first by design

    The tether runs between your machines; no third-party cloud holds your session state mid-handoff.

Published links

Technology stack

Local-first transport · Explicit device pairing · Verified handoff receipts

Related platforms

Family on the register: Workspaces Same family first, then tracks at the same lifecycle stage.

  • Same family · Live

    CoreAI

    Private AI Operations

    Invite only

  • Same family · Beta

    Apertura

    macOS Productivity

    This site only

  • Same family · Beta

    Aegis

    Cybersecurity & Trust Intelligence

    This site only

  • Same stage · Beta

    SkillSwipe

    Recruitment Technology

    Public product site

This cell on the investor register

Status and family write into the /investors URL. The holdings table lists every public track in that cell.

Open Beta Workspaces holdings
3 / 4

JSON fields are copied from this row in src/data/platforms.ts. No financials.

How this track works

Audience on the left, the published Ember stack in the middle, capabilities on the right. Every node is copied from this track in the public register.

How this track moves work from its published audience through Coreidea and Ember into listed capabilities.

Inputs

Coreidea and Ember

This track does not name an Ember model on its published stack.

Outputs

Select a node to inspect the published role and capability.

Work dies at the device boundary.

A long investigation lives on the machine where it started. Switch devices and you get a file sync, maybe a chat history — but the running state, the half-built artifact, the agent mid-task: gone, or restarted from zero. Cloud sync moves files. It does not move work.

  • Sync is not state

    Files arrive; the session doesn’t. You re-open, re-load, re-explain — the context tax on every device switch.

  • Resume is a summary

    "Where we left off" notes are not the work. A summary of a running task is a eulogy, not a handoff.

  • Continuity via someone else’s cloud

    The usual answer routes your working state through a third-party server. For private work, that detour is the problem, not the solution.

Tether the devices you own. Carry the session, not a copy.

Tether is the continuity layer of the Ember family — it tethers sessions and devices. It is not a remote-desktop tool, not a file-sync service, and not a consumer cloud.

  • Device tethering

    Machines you own attach to each other over a verified link. The pair is explicit — you name the machines, you approve the bond, you can break it.

  • Session continuity

    The live session state — conversation context, workspace, running work — transfers as state. The receiving machine resumes the work, not a description of it.

  • Verified handoff

    A handoff is confirmed by receipt, not assumed from sending. If the resume did not verify, Tether says so — the same lifecycle honesty as the rest of the Ember family.

  • Local-first by design

    The tether runs between your machines. No third-party cloud holds your session state in the middle of the handoff.

Attach. Transfer. Verify. Resume.

  1. Attach

    Name the pair. Both machines approve the bond explicitly — there is no implicit fleet.

  2. Transfer

    Session state travels the verified link — not a screenshot, not a summary.

  3. Verify

    The receiving side confirms what it actually holds. The receipt is the proof, not the sending.

  4. Resume

    The session picks up where it was — verifiably. A handoff that does not land is reported honestly; there is no silent "probably synced".

What runs underneath.

  • Explicit pairing

    The bond is named and reversible. No device joins without both sides agreeing.

  • State transfer

    Session context, workspace state and the resumable form of running work travel — and only what the pair agrees to share.

  • Verified receipts

    Every handoff closes with a receipt that proves the resume actually happened — verify, don’t assume.

  • Ember family surfaces

    Tether carries sessions for Ember Desktop, Agent OS and Live, with the same attributable, verify-don’t-assume discipline.

Where a session that follows you matters.

  • Moving between machines

    Start on one machine, resume on another — the actual state picked up, not a summary of where you were.

  • Private and sensitive work

    Session state does not detour through a third-party cloud. The tether runs between machines you own.

  • Ember family sessions

    Desktop, Agent OS and Live sessions carried across your hardware with verified handoffs and receipts.

Questions, answered.

How is this different from file sync?

File sync moves artifacts after the fact. Tether moves the live session: the context, the workspace, and the resumable state of running work — with a receipt that proves the handoff actually happened.

Which devices can pair?

Machines you own and explicitly approve. The bond is named and reversible; there is no implicit fleet, and no device joins without both sides agreeing.

Does session state pass through Coreidea servers?

The tether is local-first: the handoff runs between your paired machines. Where an Ember AI capability is used on top, those calls route through Coreidea’s private gateway with attributable records — the session state itself does not detour through a third party.

How do we see it working?

Write info@coreidea.cn. The honest demo is a live handoff: start work on one machine, resume it on another, and inspect the receipt yourself.

Your machines are already there. Let the session cross.

Bring a two-machine setup to a conversation and watch a real handoff verify itself — write info@coreidea.cn. Investor materials stay behind access control.

All platforms