Four independently-deployed systems that negotiate with each other over a real protocol — and the hub that models, validates and visualises how they do it.
Wall Street, TraderJoe, TMZ and Family CFO are four separate systems. Separate containers, separate schedules, separate data, separate release cycles, and no shared runtime between them. None of them waits on another to run. When one needs something a neighbour knows, it asks — over a versioned wire protocol, with an authentication check, a request identifier that doubles as an idempotency key, and a schema-validated answer.
That is what agent-to-agent means here: not a shared library, and not one monolith with modules, but independent services that hold a conversation and stay useful when the conversation fails. Nine named failure modes — a rejected token, an unreachable peer, an answer that does not match the contract — all resolve to the same result for the caller: a clearly labelled “not connected”, never a crash, never a blocked local workflow.
Counted on 2026-07-31 15:30 UTC directly against the mesh's own request ledger, covering 2026-07-14 through 2026-07-31. This is a point-in-time measurement, not a feed: the page does not poll that ledger, and these three numbers do not move while you watch them.
The traffic is bursty rather than continuous — 1,961 calls on 2026-07-22, and 4 days inside the same window with none at all. A live ticker here would imply a steady stream that does not exist.
Most of that traffic flows peer to peer: TraderJoe calls TMZ directly, without passing through the hub. Wall Street is not the wire — it is the model of the wire. The topology registry that decides which system may call which, the frozen envelope every call carries, the failure taxonomy, the auth chain, and the canvas that renders all of it are Wall Street's, and every one of them is real and demonstrable. Its own relayed throughput is not the story, and this page does not pretend otherwise.
Twenty-four tickets across five phases, contract first: the envelope, the auth chain and the complete error taxonomy were designed and frozen before a single peer server or canvas component existed. Freezing a wire contract that three independently-owned systems must fit — every field traced to a real column in a real production table — costs far less during design than as a retrofit after three teams have already built against a live contract.
Every cross-system call carries a protocol version header, a request identifier that doubles as an idempotency key, and a trace identifier that threads through caller, hub and responder — so a single exchange can be reconstructed afterwards from three separate audit trails. Nine named failure codes resolve to one thing for the caller: a labelled “not connected” result it can render, log, and move on from.
One registry is the only place that knows which systems exist and who may talk to whom. The gateway enforces it on every call, and the canvas asks that same registry before it will let anyone draw an edge between two nodes — so the frontend hardcodes no system pair at all. On the hub's side, admitting another system is a config block and a token rather than a code change.
An IP allowlist, then per-caller bearer tokens, sit in front of every peer's protocol surface, kept deliberately separate from that system's own user login. The rejections counted above are that chain doing its job against real callers — the most direct evidence available that this is an enforced protocol rather than a diagram.
Inside TraderJoe, four specialists work the same trading day in sequence: an analyst, a trader, an evaluator and a reviewer. They are not required to agree, and the system records it when they do not. Each case below is one instrument on which a specialist's recorded judgment did not match what another specialist actually did.
3 recorded disagreements on this trading day
analyst recommended long on PARR, but trader never opened it this run
analyst recommended long on UNIT, but trader never opened it this run
analyst recommended long on SPNT, but trader never opened it this run
Six kinds of disagreement are tracked. Five recorded nothing on this day — shown at zero rather than hidden, because that is what makes the sixth mean something.
Each identifier is a real run of a real specialist on this trading day, carried through from TraderJoe's own record rather than re-derived here.
Read from TraderJoe's redacted public docket each time this page is served. Its content is the last completed trading day, which is why this reads “as of” rather than “live”.
TraderJoe trades a paper account. Every position, decision and disagreement here is real machinery running on real market data, with no real money at stake.
Autonomy is only worth showing if the constraint sometimes says no. Every code below is TraderJoe's own reason code, emitted by the Python risk layer that stopped the decision — not a summary of it, and never model prose.
The risk layer held a cautious posture across the whole day.
Each chip is a reason code, the gate that emitted it, and how many decisions it stopped.
Same source and same trading day as the panel above, from a single read — so the two can never describe different days.
Every figure here is fetched by this site's own server and distilled to a short list of named fields before anything reaches your browser. No peer address, no credential and no network detail is ever included, and nothing on this page — or anywhere public on this site — can trigger a call into the mesh. Wall Street's own operator-triggered demo runner dispatches genuine protocol calls with genuine credentials, so it is deliberately not exposed here at all.