An honest, end-to-end measurement of the Hypha-Mesh platform as deployed: the real shipped client over WebSockets and the artifact HTTP plane, against a dedicated Cloudflare deployment with real Durable Objects and R2 — so every latency folds in the true edge-to-DO round-trip and the real durable-commit cost. No mocks; bad numbers reported too. Each number below is paired with what it means for what you can build.
Real Cloudflare deployment (§2.2 of the report) — p50 unless noted, from one host over one ISP uplink to a Cloudflare-assigned DO region. Each card: the measured number, and what it lets you build.
A repeatable, bounded, self-cleaning harness — production-representative, zero risk to live users.
The harness drives the shipped client-ts over WebSockets (JSON mode) plus the artifact HTTP plane. Every number is an end-to-end client → edge → DO (→ R2) round-trip — no mocks.
A dedicated hypha-mesh-bench worker with its own DOs, R2 bucket and throwaway JWT secret — same code, classes and migrations as prod. Each run uses a disposable workspace + short-TTL token, then deletes every artifact and revokes the token. Real workspaces are never touched.
A local workerd floor (loopback, no network) runs alongside, so each latency decomposes into network round-trip + server work. Percentiles by nearest-rank; failures excluded from the distribution but counted.
Real Cloudflare (§2.2). All latencies in milliseconds.
| scenario | n | p50 | p95 | p99 | throughput |
|---|---|---|---|---|---|
| call noop (serial) | 300 | 12.5 | 21.1 | 38.5 | 73 calls/s |
| call echo-1KB (serial) | 300 | 12.9 | 20.5 | 32.2 | 71 calls/s |
| call noop (concurrent, 32 in-flight) | 2000 | 31.9 | 46.3 | 63.1 | 980 calls/s |
What it means: a routed call is ≈ one network round-trip, so interactive agent/UI calls feel instant; one consumer socket sustains ~980 calls/s and more sockets add more.
| scenario | n | p50 | p95 | p99 | throughput |
|---|---|---|---|---|---|
| append (serial) | 300 | 36.1 | 41.1 | 52.7 | 27 appends/s |
| append (concurrent, 32) | 2000 | 37.8 | 84.4 | 311 | 605 appends/s |
| read pagination (100/page, 1000) | 10 pages | 91.2 | 235 | 235 | 809 entries/s |
| subscribe replay (recent 200) | 200 | 26.3 ms total | 7,593 entries/s | ||
| live-tail delivery (append→deliver) | 100 | 36.2 | 44.4 | 59.9 | — |
What it means: ~605 durable appends/s per log carries a busy chat or event stream; subscribe-replay re-sends a recent window in 26 ms so a reconnecting client catches up gap-free — durable, disconnect-survivable streams.
| scenario | commits | p50 | p95 | throughput | integrity |
|---|---|---|---|---|---|
| CAS serial (uncontended conditional write) | 300 | 34.9 | 40.1 | 28 commits/s | — |
| atomic incr (16 conns racing on one counter) | 800 | 37.3 | — | 386 commits/s | 0% conflicts · final exact (800) |
What it means: the single-writer DO never loses an update; a server-side atomic incr commits a counter/ledger in one round-trip with no retry storm — so cheap, exact counters and balances whose cost scales with useful commits, not with contention.
| metric | p50 | p95 | p99 / max | note |
|---|---|---|---|---|
| WS connect (warm DO, n=100) | 71.2 | 102 | 124 | peak 200 concurrent, 0 failures |
| Presence propagate → 3 subs (n=100) | 42.7 | 61.2 | 75.9 | ≈ one round-trip — no server-side fan-out cost at this scale |
| Cold Log DO (first-ever dial) | 730 | 918 | 918 | instantiation + schema init + handshake |
| Cold workspace DO (fresh ws) | 747 | 836 | 836 | cold delta ≈ +660 ms over a warm connect |
What it means: ≥200 clients hold one object with zero failures, and presence propagates in ≈one round-trip — many live clients per object. The only tax is a ~660 ms one-time wake on a sleeping object; warm hops are ~71 ms.
| path | result | note |
|---|---|---|
| direct-to-R2 multipart (64 MB, 8×8 MB) | completes · ✓ byte-verified | ≈13.4 MB/s aggregate · 0 errors · 0 dangling MPUs |
| binding plane (8 MB, through the Worker) | ≈9.7 MB/s from one host | client-uplink-bound; fine for small/medium blobs |
What it means: large files upload direct edge↔R2 (bytes never touch billable DO time) and round-trip byte-for-byte; small/medium blobs stream simply through the Worker.
What the numbers say about the architecture (§3).
Each workspace, Log and Doc is its own single-threaded DO — nothing is shared (no global bus, no shared SQL). The numbers are per-shard; capacity ≈ per-shard × objects, scaling ~linearly. Adding tenants adds shards. The one risk is a single hot object.
Control + small ordered data live in co-located hot DO-SQLite (a durable commit is ~23 ms beyond the bare round-trip). Bulk bytes go to R2 — through the Worker for small blobs, or direct-to-R2 multipart to keep bytes off billable DO time.
The single-writer DO never loses an update, and a server-side atomic incr commits a hot counter in one round-trip — 0% conflicts. Contention becomes cost that scales with useful commits, never a latency cliff or a lost write.
Presence and subscribe-streams are served from the owning DO's SQLite + connection set and pushed to subscribers — no Redis, no fan-out tier. The whole class of shared-bus incidents is gone by construction.
| operation | local floor (server-only) | real CF | ⇒ the gap is… |
|---|---|---|---|
| RPC call (route, no durable write) | 0.27 ms | 12.5 ms | ≈ one client↔edge↔DO round-trip |
| Log append / Doc write (durable write) | 0.24 / 0.26 ms | 36 / 35 ms | ~12 ms RTT + ~23 ms durable-commit |
| WS connect (warm DO) | 1.4 ms | 71 ms | TCP+TLS+WS upgrade + auth on the wire |
| cold DO first touch | 2.5 ms | 730 ms | ~660 ms cold DO instantiation |
Cloudflare bills DOs on requests + active duration, and R2 on class-A/B ops + storage (§5).
Each call/append/commit ≈ one DO request; concurrency doesn't reduce the count. Atomic ops keep a contended counter at one request per commit (no retry storm), so the bill tracks useful work, not contention.
Streaming and through-Worker artifact bytes accrue billable wall-time; the direct-to-R2 path keeps bytes off the DO. Idle DOs hibernate to ~0 — cold wake costs ~660 ms once, not standing cost.
Cold workspaces/logs/docs left behind hibernate to ~zero — per-object sharding is also per-object cost isolation, with no shared always-on infrastructure to pay for.
Numbers from docs/benchmark-report.md (§2.2 headline figures) — captured from one host over one ISP uplink; a multi-region client matrix is future work. The full methodology, raw per-op samples and limitations are in the complete report.
Read the full report