Skip to content
Technology deep dive

The device swarm: your machines are the cluster.

Talavine never shipped a cloud backend for your data — it shipped a distributed system for machines you own. Paired same-owner devices replicate state through a journaled sync engine, speak over authenticated LAN crypto, share models and work through a load-scored pool, and run AI workers as supervised OS processes. The LAN device fabric has no public gateway. The optional relays you turn on through talavine.com (the end-to-end encrypted mobile relay, and the AI data-source and Copilot gateways) are explicit, opt-in exceptions.

Transport security

A four-digit code, backed by real key exchange.

Pairing two machines looks like typing a short code. Underneath it is an ephemeral elliptic-curve key exchange with key confirmation — the code proves the human, the math defeats the network.

ECDH pairing handshake

Ephemeral P-256 key exchange derives the channel key; a key-confirmation MAC over the code and the handshake transcript — compared in constant time — defeats both passive sniffing and an active machine-in-the-middle before any pairing payload moves.

Sign-then-seal envelopes

Ongoing traffic is HMAC-signed, then AES-256-GCM encrypted with per-peer keys derived separately for each purpose — the LAN body key, the relay body key, and the signing secret can never be confused for one another.

Replay protection that survives restarts

Fresh envelopes check a fast in-memory nonce window; durable-outbox messages that can legitimately arrive hours late check a persistent nonce store — so a replayed frame is dead on arrival even after a reboot.

Replication

A journal, not a merge prayer.

Every local write lands in a journal with a monotonic sequence number. Peers replicate journal entries and resolve conflicts with a last-writer-wins stamp engineered for the real world.

Clock-skew tolerant

A peer with a wildly wrong clock gets clamped for comparison — symmetrically, so a stored future timestamp can't beat every later write forever.

Deletes stay deleted

Tombstone history is consulted on apply, so a delayed update arriving after a newer delete can't resurrect the record.

Batched & compressed

Fresh writes coalesce into size- and time-windowed batches with negotiated compression, and the receiver only advances its high-water mark on contiguous entries — a lost batch is guaranteed to be re-fetched.

Self-healing

Machines sleep for weeks. The sync layer plans for it.

  1. Catch up, one peer per cycle Pull-only catch-up against per-origin high-water marks — deliberately no fan-out amplification.
  2. Detect the unhealable If needed entries were compacted away while a machine slept, or it's so far behind that replay would take days, the coordinator escalates to full snapshot re-adoption — automatically, with per-peer cooldowns.
  3. Compact on acknowledgment Journal rows are physically retired only below the minimum sequence number acknowledged by every paired peer — with a time-ceiling backstop that names the laggard machines holding retention open.
Engineering discipline

Every table must declare its sync fate.

A compile-time catalog classifies every database entity as synced (with an applier) or local-only (with a documented reason). A build-failing guard test walks the actual database model and refuses any table that hasn't made the decision — so "we forgot to sync it" is a compile error, not a support ticket. The hosted CRM applies the same pattern to tenant isolation: every table must be tenant-scoped or globally justified, enforced by the build.

Pooled compute

The PC borrows the Mac's GPU. Automatically. When it's worth it.

Peers announce their local models and a workload snapshot — hardware, acceleration, current load — every few minutes. A routing policy scores each peer's best model against local capability and delegates a whole agent turn only when the peer wins by a difficulty-scaled margin.

Scored, not static

Model tier, RAM/VRAM/acceleration, observed success rate and latency, your Prefer/Avoid preferences, and a busy penalty combine into the decision — it learns which machine actually delivers.

Durable delegation

Delegated work flows through a durable queue with dedup keys, dispatch leases, and retry backoff — a crashed peer means a re-lease, not lost work.

Less duplicate spend

Short-TTL advisory claims broadcast which machine is enriching which message, which reduces duplicate processing when two peers could pick up the same mail. Claims self-heal on crash; the synced completion record stays authoritative.

The same pool concept extends to the hosted CRM: office desktops can volunteer their local models to the team's compute pool — opt-in per machine, admin-approved, and an announcement can never flip its own approval.

AI workers

Hiring is provisioning. Employment is process supervision.

Isolated profiles

Each worker is a self-contained profile — own databases, own mailbox, own credential store — with a staged → approved → active lifecycle and its mailbox password confined to its own store, never in logs or approval payloads.

Machine-bound

Workers are stamped with the device that hired them and refuse to run if the folder is copied elsewhere. They never replicate to peers.

Supervised for real

A supervisor restarts crashes with backoff, adopts orphans that survived an app restart, and binds each worker to its parent process so an orphan self-exits. Secrets pasted in chat are scrubbed from transcripts — including inside serialized JSON — before anything persists.

Off the LAN

The relay can't read what it carries.

When devices meet across the internet, a deliberately dumb relay routes opaque encrypted payloads between the two halves of a pairing — it authenticates devices with hashed tokens, pushes notifications, and sweeps expired blobs, but it never holds a key and never parses a payload. That zero-knowledge design is specific to the mobile relay: the separate AI data-source and Copilot gateways decrypt the results they deliver to the AI service you connected, as the privacy policy explains.

Keep reading

The rest of the stack.

The swarm distributes work the message pipeline creates, on models Model Scout has proven.