A conversation interrupted.
The customer has already explained what they need. A compute failure can make them start over.
CUSTOMER EXPERIENCE In development Seeking early testers Keep the session.
Keep the session.
Change the infrastructure.
Unlock lower-cost GPU capacity for real-time AI. ANK coordinates session state, execution ownership, and traffic routing so a provider change doesn’t mean starting the conversation over.
Session identity stays. Execution ownership moves.
Your customerA live interaction
CONNECTED
ank ACTIVE
Session Layer session_18f29
Same identity. Recoverable context.
⠿CoreWeaveACTIVE
RunPodREADY
awsAWSREADY
Private GPUREADY
Change the compute. Keep the logical session.
Follow a session through a provider switch. Explore the technical model
TARGET ENVIRONMENTS
AWS (EC2 / EKS)⠿ CoreWeave runpod Bare-metal Linux
THE CUSTOMER PROBLEM
A compute problem shouldn’t
become a customer problem.
Moving a workload is only part of recovery.
The live interaction needs to come with it.
Progress lost in a restart.
Moving a running application can leave its active users, context, and unfinished work behind.
RECOVERY & LOST WORKRecovery built from scratch.
Teams must connect failover, application state, and user reconnection—and keep those pieces in agreement.
ENGINEERING EFFORTA CONCRETE STARTING POINT
The conversation
shouldn’t start over.
Consider a team running live AI voice agents. A customer is mid-conversation when the provider loses capacity.
Starting another agent is not enough. It needs the conversation context, the work already done, and a way to reconnect the customer.
ANK’s continuity layer pairs recoverable session state with transport routing, so execution can move while the conversation keeps its identity.
Building real-time AI? Test with usThe context already exists.
Customer identity · order details · conversation history
Provider ACapacity unavailable
Provider BAlternative execution
One logical session.Recover the context. Continue the interaction.
Scope: state-checkpointed runtimes with WebRTC / WebSocket transport. Raw GPU memory migration is out of scope.
The same continuity contract extends to AI avatars, interactive GPU workspaces, and long-running agents.
HOW ANK FITS
Three integration points.
One continuous session.
Integration architecture in development: a gateway at the edge, an agent on the worker, and a contract in your code.
01
Transport gateway
A headless WebRTC / WebSocket proxy between your client and GPU workers. Its role: keep the client-facing connection open while the backend changes.
AT YOUR TRAFFIC EDGE02
ANK host agent
The ank-agent binary runs alongside GPU workloads. Planned Docker / Helm deployment reports jitter, VRAM pressure, and spot preemption signals to the control plane.
ON YOUR GPU WORKERS03
Continuity contract
Your application defines recoverable state and drain hooks. ANK coordinates checkpoints, ownership, and buffered traffic before directing work to the replacement runtime.
IN YOUR APPLICATIONCONTINUITY CONTRACT · PROPOSED PYTHON API
Make recovery part of the application.
Bind the transport, checkpoint application state, and prepare a warm handoff when a worker drains. The application supplies the stream and handshake callback in this example.
from ank_sdk import ank, SessionContext
@ank.orchestrate(checkpoint_interval_ms=250)
def handle_voice_session(session: SessionContext):
session.bind_transport(client_webrtc_stream)
session.on_drain(execute_warm_handshake)SIMPLE TO EXPLAIN. HARD TO COORDINATE.
Explore the architecture The hard part is making state, ownership, and in-flight work agree while execution moves. Copying a snapshot alone doesn’t solve that.
THE COMPUTE COST OPPORTUNITY
Run real-time AI on
spot & neocloud GPUs.
Lower compute rates only help if your live sessions survive a capacity change. ANK targets the continuity problem that keeps teams tied to expensive, always-on capacity.
ILLUSTRATIVE MONTHLY COMPUTE BUDGET$50,000 $30,000
40% reduction scenario
Assumes 50% of GPU hours move to capacity priced 80% lower, with equal throughput. That frees $20,000/month before gateway, warm standby, transfer, and ANK costs. Example inputs, not provider quotes or measured savings.
Fewer interrupted interactions
Recover the session’s context instead of treating every compute change as a new customer interaction.
More freedom to choose compute
Respond to capacity, reliability, or cost changes without tying every live session to its original provider.
Less custom recovery plumbing
Give teams a common layer for session ownership, recovery references, and traffic coordination.
Your cloud provides the compute. Your scheduler places the workload.
ANK is building the layer that coordinates continuity for the live session.
WHERE WE ARE
Built around live workloads.
Measured against real failures.
ANK is in development. Early access focuses on real-time voice teams evaluating spot and alternative GPU capacity. Bring your workload; measure continuity and total compute cost with us.
Bring your workloadInspect the architecture
Follow the gateway, ownership transfer, and recovery sequence. Inspect the session contract and failure simulations.
Read the engineering modelPerformance target: sub-500ms handoff
Benchmark roadmap: handoff latency across heterogeneous GPU clusters, interruption time, and lost or duplicated work. The sub-500ms goal assumes a warm destination and recoverable state; it is a target, not a measured result.
See the measurement planValidate the economics
Compare your current compute bill with alternative capacity, including warm standby, recovery, and transport overhead.
BUILD WITH US
Bring us a session
worth keeping.
Building something that cannot simply restart when compute changes? Tell us what your users stand to lose.
We’re inviting early collaborators to test ANK’s approach against real workloads and help shape the product.
Under active development. Open to hard questions.