SwarmMarshal
SwarmMarshal 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. There is no public gateway to attack because none exists.
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.
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.
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.
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.
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.
A peer with a wildly wrong clock gets clamped for comparison — symmetrically, so a stored future timestamp can't beat every later write forever.
Tombstone history is consulted on apply, so a delayed update arriving after a newer delete can't resurrect the record.
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.
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.
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.
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.
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.
Short-TTL advisory claims broadcast which machine is enriching which message, so two peers never both spend tokens on 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.
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.
Workers are stamped with the device that hired them and refuse to run if the folder is copied elsewhere. They never replicate to peers.
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.
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. Zero knowledge isn't a policy; it's the design.
The swarm distributes work the message pipeline creates, on models Model Scout has proven.