LockStock Core | The Operating System for Agent Identity

The Core Philosophy: Solving the "Stateless" Problem

The fundamental flaw in modern AI architecture is that LLMs have no concept of "self" between API calls. They are brilliant but fleeting. Developers currently patch this with vector databases and fragile session cookies, but this breaks down the moment you scale across servers or clouds.

LockStock Core introduces the concept of State Encapsulation. We treat an AI agent's "memory" (its context window, current goals, and variable state) not as a database entry, but as a portable, cryptographic object. This object is the agent. Where the object goes, the consciousness follows.

Feature Deep Dive: The Mechanics of Continuity

Agent Teleportation (Zero Memory Loss)

In a Kubernetes environment, pods die. Servers restart. Usually, this kills the agent's train of thought.

                    How it works: Core serializes the agent's entire execution state into a
                    SoulFile—a highly compressed, encrypted binary format.
                

                    The Capability: You can pause an agent running on an AWS instance in Virginia,
                    serialize it, and "wake it up" on an edge device in Tokyo 50 milliseconds later. It will resume
                    exactly where it left off, mid-sentence or mid-calculation, with zero context loss. It is true
                    computational portability.
                

# Teleport an agent across clouds
agent = LockStockAgent.load("agent-state.soul")

# Pause in AWS Virginia
checkpoint = agent.serialize()

# Resume in Tokyo edge device
tokyo_agent = LockStockAgent.deserialize(checkpoint)
tokyo_agent.resume()  # Continues mid-thought
                

Split-Brain Prevention (The Highlander Protocol)

When scaling horizontally, a common disaster is "split-brain," where two instances of the same agent start running simultaneously, corrupting data.

The Mechanism

LockStock Core utilizes a distributed consensus mechanism (similar to Raft, but optimized for agent state).

The Guarantee

There can be only one. If a network partition occurs, Core mathematically guarantees that only one instance of the agent holds the "Write Token." The duplicate instance immediately recognizes it is a "ghost" and terminates itself, preventing data corruption or duplicate transaction execution.

The Architecture: Clock-Independent Verification

Distributed systems struggle with time. If Server A thinks it's 12:00:01 and Server B thinks it's 12:00:00, race conditions destroy data integrity.

Lamport Timestamps: We don't use wall-clock time. We use logical clocks (Lamport timestamps) to order events based on causality.
Conflict Resolution: If two users interact with the same agent simultaneously from different regions, Core resolves the state merge deterministically. The agent's memory remains linear and coherent, regardless of network latency or clock drift.

Lamport Clocks Vector Timestamps Raft Consensus CRDT State Merge

Developer Experience: Built for the Stack You Use

We know you aren't rebuilding your infrastructure from scratch. Core is designed to be the glue, not the platform.

SDKs

Native, high-performance bindings for Python (for the data scientists) and Rust (for the systems engineers).

Multi-Cloud Native

The SoulFile format is agnostic to the underlying hardware. Train on NVIDIA H100s in the cloud, run inference on Apple Silicon locally. The identity persists across boundaries.

Drop-in State Management

Replace your complex Redis/Vector DB glue code with a simple agent.save() and agent.load() primitive that handles the encryption, compression, and synchronization automatically.

# Python SDK - Drop-in state management
from lockstock import LockStockAgent, Task

# Initialize agent with persistent identity
agent = LockStockAgent(
    server_url="https://lockstock.d3cipher.ai",
    client_id="my-research-agent",
    secret="your-secret-key"
)

# Bootstrap creates the cryptographic passport
agent.bootstrap()

# Agent remembers context across restarts
response = agent.authenticate(Task.EXECUTE)

# Save state - automatic encryption & compression
agent.save("checkpoint.soul")

# Later: Resume from any server
agent = LockStockAgent.load("checkpoint.soul")
agent.resume()  # Zero memory loss
            

// Rust SDK - Systems-level performance
use lockstock::{LockStockAgent, Task};

let mut agent = LockStockAgent::new(
    "https://lockstock.d3cipher.ai",
    "high-frequency-trader",
    "secret-key"
)?;

agent.bootstrap()?;

// Execute with cryptographic proof
let response = agent.authenticate(Task::Execute)?;

// Serialize for cross-cloud migration
let checkpoint = agent.serialize()?;

// Deserialize on new host - exact state recovery
let mut tokyo_agent = LockStockAgent::deserialize(&checkpoint)?;
tokyo_agent.resume()?;
            

Pricing

Personal

$19/month

or $15/month billed annually

[OK] 1 AI agent/companion
[OK] Per-action credential rotation
[OK] Cryptographic passport identity
[OK] Portable memory across platforms
[OK] 30-day audit logs
[OK] Agent teleportation
[OK] Community support

Get Started

Starter

$99/month

up to 10 agents

[OK] Everything in Personal
[OK] Zero-second replay windows
[OK] 90-day compliance audit logs
[OK] Full API access
[OK] Email support
[OK] Team collaboration features

View API Docs

Need enterprise security features? Check out LockStock Guard

View Enterprise Plans →

"Stop building stateless chatbots. Start architecting persistent digital employees."

Read the API Documentation Get the SDK on GitLab