tRPC-Agent-Go

The deciding trait is who is behind it. A framework maintained by a large company's platform group has a different failure mode from a personal project: it may go stale, it may take a direction you dislike, but it rarely disappears on a weekend. For a service you expect to still be running in three years, that difference is most of the decision.

The cost is weight, because you inherit a large surface whether or not you use it. Pick it for something long-lived. Pick a small library if the agent is a feature rather than a product.

Breadth on this scale is a promise about maintenance nobody can keep uniformly. Some of these subsystems are load-bearing in production and some exist because the list looked incomplete without them, and the documentation gives a reader no way to tell which is which. The failure that follows is specific: you adopt the framework for the mature part and build on the one that was written last.

What it does right is name the protocols it speaks rather than inventing private equivalents.

1. Shipping evaluation tooling and publishing no evaluations is a peculiar combination, because the tooling exists precisely to answer the question the documentation leaves open. A reader is told the framework can be measured and given no measurement of it. 2. That is a weaker position than publishing nothing, since it demonstrates the capacity and withholds the result.

2. The self-evolution claim carries the same problem in a stronger form: an assertion about behaviour improving over time is meaningless without a metric that was watched improving.

Corporate open source is the most stable arrangement here and it is stable for reasons that have nothing to do with this product. It exists because a large engineering organisation needed it internally and decided publishing was cheaper than maintaining privately, which means funding is secure while that internal need persists and evaporates the moment it does not.

Moat: the publisher's own engineering scale, which is real and not directed at you. Likely path: steady releases tracking internal requirements. Position: adopt it, and watch commit activity rather than announcements for the signal that matters.

Observability as a first-class concern is the feature that decides whether something is operable. Services built on this emit into the monitoring my platform group already runs, which means an agent failing at three in the morning reaches the same rota through the same alerts as everything else, rather than through a developer noticing something odd the next day.

There is nothing to install on desks and no console, because it is a library. The real cost is engineering time in one language plus the model spend those services incur. Approved with conditions: platform-operated services only, with spend attributed per service.

Targeting a compatible interface rather than enumerating providers is the difference between a library I can point at anything and one I have to wait for. Whatever I am serving answers the same shape of request, so the decision about what runs behind the agent stays mine and does not require anybody to add support for it.

Tool servers attach over the protocol and agent-to-agent communication has its own, so the pieces I run separately can talk without a bespoke bridge. Permissive licence, so a fork is legal and vendoring it is cheap.