Get early access
Back to ANK
ARCHITECTURE & ENGINEERING NOTES

Inside session mobility.

Keeping the session means coordinating more than its data. Explore how ANK is thinking about ownership, state recovery, and traffic as execution moves.

Design in progressProposed mechanisms and simulations. Not released API documentation.
01 / SESSION AS THE STABLE LAYER

Infrastructure changes.
The session remains.

ANK gives a live interaction an identity independent of the machine, region, or provider currently executing it.

USER
SESSIONsession_18f29STABLE IDENTITY
ANK SESSION CONTROL PLANE
CoreWeave
RunPod
AWS
GCP
Private GPU
WHAT THE SESSION CARRIES
01Identity
One logical session across infrastructure.
02Ownership
The runtime with execution authority.
03State references
Where recoverable application state lives.
04Execution location
The provider and region currently running it.
05Recovery information
What is needed to reconstruct execution.
06Routing
How traffic reaches the current owner.

The stable session is the abstraction ANK is building toward. Continuity depends on the workload’s state model, transport, and recovery mechanisms.

02 / SESSION OWNERSHIP

One session. One active owner.

session_18f29
Owner
CoreWeave
Epoch
42
Status
ACTIVE
ILLUSTRATIVE MODEL
CoreWeave · Provider AACTIVE
epoch 42

WRITE AUTHORITY

ONE WRITE AUTHORITY
RunPod · Provider BPREPARING
epoch —

NO WRITE AUTHORITY

  1. 1Prepare destination
  2. 2Hydrate required state
  3. 3Fence old owner
  4. 4Increment epoch
  5. 5Transfer write authority
  6. 6Redirect traffic
  7. 7Retire old execution

Watch authority move, one step at a time.

ANK tracks which runtime currently owns execution authority for a session. Ownership can move while the logical session remains unchanged. A stale runtime must no longer be able to make authoritative writes.

ANK’s current design explores epoch-based session ownership and fencing. Enforcement must reach the write path; an epoch in a JSON document alone is not a fence.

03 / THE ANK SESSION MANIFEST

A portable description
of a live session.

The manifest describes where a session is running, who owns it, where its recoverable state lives, and how execution can continue elsewhere.

session.manifest.jsonPROPOSED SCHEMA
{
  "session_id": "session_18f29",
  "epoch": 43,
  "owner": {
    "provider": "runpod",
    "region": "ap-south"
  },
  "runtime": {
    "image": "voice-agent:v7",
    "gpu": "L40S"
  },
  "state": {
    "checkpoint": "s3://...",
    "cache": "redis://...",
    "database": "postgres://..."
  },
  "transport": { "protocol": "webrtc" },
  "fallback": { "provider": "coreweave" }
}

ANK ownsCOORDINATION METADATA

  • Session identity
  • Execution owner
  • Migration epoch
  • State references
  • Routing metadata
  • Recovery metadata

Application ownsCANONICAL STATE

  • Business data
  • Canonical database state
  • Application logic
  • Model-specific state
  • Domain semantics

ANK should know how to reconstruct the session without becoming the database behind the session. Storage references describe where recovery data lives.

04 / EXECUTION MOBILITY

Execution becomes movable.

A missed heartbeat is a signal, not proof of death.
Recovery needs a new owner—and a fence
around the old one.

SIMULATED METRICS — NOT PRODUCTION BENCHMARKS
Session
session_18f29
Owner
CoreWeave
Epoch
42
Transport
WebRTC
State
Healthy
  1. 01Provider heartbeat missed
  2. 02Failure threshold reached
  3. 03Selecting destination
  4. 04RunPod selected
  5. 05Restoring minimum session state
  6. 06New owner prepared
  7. 07Fencing old owner
  8. 08Epoch 42 → 43 · transferring write authority
  9. 09Traffic redirect
  10. 10Session active
CoreWeaveACTIVE
Mumbaiepoch 42

WRITE AUTHORITY

RunPodREADY
Hyderabad · illustrative destinationepoch —

NO WRITE AUTHORITY

Traffic → CoreWeave

Failure detection—
Destination ready—
State hydration—
Traffic cutover—
Total mobility—
Reconnect count—

Ready to simulate · no real infrastructure is contacted.

Animation is slowed for readability; displayed timings are illustrative. This scenario assumes the required state is recoverable and fencing is enforceable. Zero reconnects is a simulated outcome, not a transport guarantee.

05 / CONTINUITY MODEL

The session lives
above the connection.

User
WebSocket / WebRTC / QUIC
ANK Gateway
session_18f29LOGICAL SESSION PRESERVED
identityownerepochstate referencesexecution location

ANK treats network connections as ways of reaching a session rather than as the session itself.

  1. 01Connection changes
  2. 02Session remains
  3. 03Transport attaches to current owner
  4. 04Interaction continues

Connection attached to the logical session. Illustrative interaction.

Designed to minimize reconnection and session interruption. Protocol adapters and application support determine reattachment behavior; universal WebRTC or QUIC handoff is not claimed.

06 / STATE DURING MIGRATION

A live session keeps changing
while it moves.

  1. T0Provider A owns sessionowner = A
  2. T1Migration startsprepare destination
  3. T2Destination begins hydrationcheckpoint = 52
  4. T3Session receives new activitynew state = 53
  5. T4State changes reconciled52 → 53
  6. T5Ownership transfersepoch 42 → 43
  7. T6Traffic moves to Provider Bowner = B
CHECKPOINT-ONLY EXAMPLE · ONE UPDATE MISSING

Restoring the checkpoint does not include the update that arrived at T3.

Session mobility requires ANK to account for state changes occurring during the migration window—not only the initial checkpoint.

Engineering space being tested 8 mechanisms under consideration
Replay logsDelta transferFencingWrite ownershipMigration epochsApplication checkpointsIdempotent request replayDirty-state tracking

Candidate mechanisms, not a list of implemented features. The right combination depends on application semantics and the state’s consistency requirements.

UNDER THE HOOD

A layer above infrastructure.
Not another cloud.

Proposed control plane for session ownership, recovery references, and traffic attachment.

Browser / Client
ANK SESSION LAYER
Gateway Transport reattachment
Session Directory Identity, owner & epoch
Orchestrator Fencing & ownership transfer
AWSGCPCoreWeaveRunPodPrivate

State / checkpoint layer

Your data. Your storage.
ANK coordinates the references.

Object storageRedisDatabaseApplication-owned state
← STATE REFERENCES →

Design model: state and runtime adapters must enforce ownership at the write boundary. Components alone do not guarantee continuity.

DEEP DIVE / BEYOND THE CHECKPOINT

This is not checkpoint + restart.

Moving a JSON blob is easy. Moving authority over a live session is not.

Checkpoint / Restart

A SNAPSHOT OF STATE
Provider A
serialize state
CONNECTION LOST
restore state
Provider B
  • ×Connection lost
  • ×In-flight work uncertain
  • ×New writes may be missing
  • ×Client reconnect required

ANK Session Mobility

DESIGN MODEL
session_18f29IDENTITY STAYS
Provider AOWNER A · EPOCH 42
  1. 01Prepare Provider B
  2. 02Hydrate minimum state
  3. 03Reconcile state changes
  4. 04Transfer ownership · 42 → 43
  5. 05Traffic cutover
Provider BOWNER B · EPOCH 43

The session remains the stable abstraction while the execution owner changes underneath it.

Checkpointing can be one ingredient. Continuity also needs ownership, in-flight work, transport, and routing to agree.

DEEP DIVE / AVOIDING SPLIT BRAIN

Two servers. One session.
That’s dangerous.

Migration is not successful simply because
Provider B started. The authoritative
runtime must be unambiguous.

Competing writers

SPLIT BRAIN
session_18f29
Provider AACTIVE · WRITES
Provider BACTIVE · WRITES
Same session. Conflicting mutations.

One accepted owner

DESIRED MODEL
session_18f29 · epoch 43
Provider Aepoch 42STALE Writes rejected
Provider Bepoch 43AUTHORITATIVE Writes accepted

Safety goal: at most one authoritative writer, even if that means pausing writes during transfer.

DEEP DIVE / THE COORDINATION SURFACE

What ANK actually has to solve.

Nine connected problems. Copying state addresses only part of one.

01

Session Identity

A stable logical identity independent of infrastructure.

02

Ownership Transfer

Target: exactly one authoritative runtime, with no overlapping write authority during transfer.

03

Fencing

Prevent stale infrastructure from continuing authoritative writes.

04

State Hydration

Restore the minimum state required before cutover.

05

In-Flight Work

Account for messages, operations, and side effects occurring during migration.

06

Transport Reattachment

Reconnect users to the current owner of their logical session.

07

Failure Detection

Distinguish unavailable or degraded infrastructure from a delayed heartbeat.

08

Destination Selection

Evaluate health, latency, capacity, cost, and placement policy.

09

Recovery

Reconstruct sessions after unplanned infrastructure loss.

These are design responsibilities and engineering goals, not a claim that every mechanism is production-ready.

A DIFFERENT ABSTRACTION

Workload portability was step one.

Traditional multi-cloud orchestration

  1. Application
  2. Scheduler
  3. AWS / GCP / CoreWeave / RunPod

Where should this workload run?

ANK session continuity

  1. User
  2. Logical Session
  3. ANK
  4. AWS / GCP / CoreWeave / RunPod / Private GPU

Where should this active session execute now?

ANK is not trying to replace workload schedulers.
It operates at the continuity layer above them.

DEVELOPER EXPERIENCE

Less ceremony.
More control.

Connect your providers. Inspect your sessions.
Make mobility part of your application.

Documentation is on the way.CLI shown is proposed syntax, not a released tool.
Help shape the developer experience
# Your infrastructure, connected.
01$ ank init
02$ ank provider add aws
03$ ank provider add runpod
04$ ank deploy
# Same session. Wherever it runs.
PRODUCT CONCEPT · EXAMPLE SYNTAX
SESSION MOBILITY, MEASURED

Deployment speed is not the metric.
Session Mobility Time is.

Time from migration or failure initiation until the logical session is operational on its new execution owner.

MEASUREMENT PLANPRODUCTION RESULTS NOT YET PUBLISHED
MIGRATION / FAILURE INITIATED
SESSION MOBILITY TIME
Detection · startup · hydration · ownership · traffic
NEW OWNER OPERATIONAL

End-to-end elapsed time; stages may overlap. Phase durations are not always additive.

12 metrics

Failure Detection Time

— TO MEASURE

Failure signal → threshold decision

Destination Startup Time

— TO MEASURE

Provision request → runtime ready

Minimum State Hydration Time

— TO MEASURE

Recovery begins → required state ready

Ownership Transfer Time

— TO MEASURE

Fence initiation → new authority granted

Traffic Freeze Duration

— TO MEASURE

Traffic paused → traffic resumed

Session Mobility Time

— TO MEASURE

Migration starts → new owner operational

Reconnect Count

— TO MEASURE

Client transport reattachments

Lost Messages

— TO MEASURE

Accepted messages never delivered

Duplicate Messages

— TO MEASURE

Operations delivered more than once

Packet Loss

— TO MEASURE

Transport packets lost in the window

State Divergence

— TO MEASURE

Mismatch from expected authoritative state

Cost Before / After

— TO MEASURE

Comparable compute cost per hour

Benchmark reports should pair timing with workload, protocol, state size, failure scenario, and consistency checks. A fast cutover with lost or duplicated work is not a successful result.

THE BOUNDARY IS PART OF THE WORK

ANK is still being tested.

The goal is to determine which classes of real-time applications can achieve useful session portability—and how far that boundary can be pushed.

What we don’t currently claim

  • —Arbitrary zero-downtime process migration
  • —Zero packet loss under every transport
  • —Automatic serialization of all application memory
  • —Transparent migration of every possible workload
  • —Universal WebRTC handoff
  • —Perfect failure detection
  • —Elimination of application-level state design

Have a workload that challenges this?

Tell us what needs to survive when your infrastructure changes.

Challenge the architecture