The Herd That Built Its Own Tools
What if agents could find the tools they need, and a community could help create and verify the ones that do not exist?
A cow discovers the gate is locked. One cow searches for a key. Another builds a new gate. The rest of the herd would prefer that the next cow not have to repeat the entire ordeal.
That is the idea behind a self-evolving capability ecosystem: automate the work of finding, adapting, testing, and reusing tools, then make verified solutions available across different AI agents. It starts with a problem-solving routine that developers already follow, turned into shared infrastructure.
Start with the task, not the catalog
Most integrations begin with configuration. The user finds an MCP server, installs it, connects credentials, and teaches a particular agent harness where the tool lives. Switch harnesses or machines, and the work often begins again.
Peasant Gateway reverses that interaction. An agent describes what it needs through a small, stable MCP interface. Gateway searches installed tools and trusted registries, ranks compatible options, checks authorization, and routes the call to the appropriate worker. The agent sees a handful of Gateway operations instead of a sprawling catalog of unrelated tools.
The broker can expose four basic operations: discover, inspect, activate, and execute. It works through the agent's existing MCP client, without taking over the model conversation. Already connected tools are used first. New connections move through compatibility checks and the owner's approval policy.
When the catalog comes up empty
When the catalog comes up empty, Peasant Forge provides the fallback. It works through a progression: compose existing capabilities, wrap a documented API, adapt compatible source code, or generate a narrowly scoped connector. The resulting package runs through isolated tests and permission checks before it gains access to devices or credentials.
The output is a versioned, reusable package containing its source, pinned dependencies, declared permissions, compatibility results, and reproducible tests. Its status changes only when execution evidence supports the change. A passing test is worth rather more than an agent announcing that everything went splendidly.
The community becomes part of the feedback loop
Opt-in idle-time workers form a distributed validation pool. One machine tests compatibility with Hermes; another reviews a dependency; a third runs regression fixtures or checks a security-sensitive operation. Peasant Exchange matches work to available contributors and indexes independently verified results so other Gateways can reuse them.
The result is a feedback loop: demand → discovery → creation → validation → reuse → improvement. Real user tasks reveal missing capabilities. Successful solutions become reusable building blocks. Failed or obsolete packages are flagged for repair or replacement. Verification provides the selection pressure that turns a growing catalog into a more useful one.
Peasant Coin gives the cooperative an incentive layer: participants earn platform credits for accepted tools, independent reviews, or useful compatibility results. Rewards attach to validated outcomes rather than reported compute hours, with cross-checks to limit fabricated work and colluding reviewers.
Sharing should never mean leaking
Contribution settings offer three straightforward choices: automatically submit eligible tools for review, approve each submission, or keep everything private. Exchange receives sanitized, redistributable packages rather than an owner's local workspace. Secrets, personal files, private endpoints, and proprietary code stay out of the publishing pipeline.
The pipeline runs license checks, signs packages, evaluates independent test results, and applies Exchange review before publication. Contributor nodes enforce resource budgets and execute untrusted jobs in isolated environments, away from host credentials, personal files, and private networks.
Peasant Commons extends the same pattern to distribution: content-addressed packages and test artifacts can be cached across participating nodes, reducing repeated downloads. Personal file sharing uses separate, private-by-default permissions and encryption.
A practical build sequence
- Prove the broker. A single Gateway instance discovers an existing tool and executes it through a small MCP interface.
- Prove portability. Two different agent harnesses invoke the same capability without duplicate configuration.
- Prove permission enforcement. Revoking a grant stops the downstream call, even if the agent requests it again.
- Prove the evidence. Record actual tool outcomes and failures without leaking secrets.
- Close the loop. Adapt one missing connector through Forge, independently validate it, and reuse it from another agent.
The field note
The most useful innovation may be the least theatrical part: stop making every agent and every user solve the same integration problem from scratch. Let capable systems borrow verified work. Let people decide what they contribute. Make failure visible rather than hiding it behind grand claims about autonomous evolution.
The first milestone is the universal MCP broker. Forge, collaborative validation, and distributed sharing build on that foundation as independently testable modules.