3goodsources

GitHub Repo | Updated: November 1, 2026

A trust registry for AI agents built on the Model Context Protocol. When an agent needs to learn Rust or set up a Bitcoin node, 3goodsources delivers three human-curated sources instead of hundreds of SEO-gamed search results. The registry is signed with the curator's PKARR key, and every change to it is recorded in a signed, hash-chained, append-only audit log.

Tech Stack: - Rust - Model Context Protocol (MCP) - PKARR (cryptographic identity) - Ed25519 signatures (registry and audit log) - Fuzzy matching (normalized Levenshtein)

Why I Built This

AI agents have access to the entire web, but most of it is garbage. When Claude asks for sources on setting up a Bitcoin node, traditional search returns hundreds of results optimized for pagerank, not accuracy. Listicles stuffed with affiliate links. Blog posts that copy other blog posts. SEO-gamed content that looks authoritative but isn't.

The problem isn't access to information. The problem is that agents have no quality signal. They can't distinguish between the official Bitcoin Core documentation and some random Medium post that's third in the results because the author knew SEO tricks.

I wanted to build a system where a human curator researches a topic, picks exactly three trusted sources, and signs those recommendations with a key anyone can check. The constraint is deliberate: three sources per topic, always. Quality over quantity. Primary sources over blog posts. Practical value over pagerank.

The Model Context Protocol was the perfect fit. It's a standardized way for agents to call tools and get structured responses. Building an MCP server meant any MCP-compatible agent could use the registry without custom integration code.

How It Works

At its core, 3goodsources is a fuzzy-matching query engine backed by a human-curated registry. The registry is a JSON file where each category contains exactly three ranked sources with explanations for why each source matters.

Query Flow:

AI Agent → MCP Handler → Query Matcher → Registry
                             ↓
                      3 Ranked Sources

When an agent sends a query like "learn rust programming", the matcher normalizes the text (lowercase, strip punctuation, remove stop words), then runs fuzzy matching against category patterns, slugs, and names using normalized Levenshtein distance. It also applies keyword boosting if query terms appear in category metadata.

The scoring is weighted: 70 percent fuzzy match, 30 percent keyword boost. Only matches above a threshold (default 0.4 out of 1.0) return results. This ensures "learn rust" matches the rust-learning category even if the exact phrasing differs from stored patterns.

Each source includes a rank (1-3), name, URL, type (documentation/tutorial/tool), and a "why" explanation. The curator's identity is verified via PKARR, a public key addressing system. The server's public key is exposed at /health, and the get_provenance tool returns curator metadata so agents can verify the source of recommendations.

The registry itself is public at /registry, so anyone can inspect the full list of categories and sources. Transparency over obscurity.

The registry is signed. registry.json carries an Ed25519 signature by the curator's PKARR key over the whole document, and GET /registry serves it byte for byte so anyone can check it with scripts/verify_registry.py or cargo run -- sign-registry --check. The server refuses to start if the registry is unsigned or signed by a different key. A valid signature proves the sources, ranks and explanations are exactly what the curator signed. It does not prove a copy is the newest one, so check the signed updated date.

The audit log is append-only. Each entry is signed over its timestamp, action, data, the previous entry's hash and its own id, so entries can't be deleted, reordered or inserted without the curator's key. New entries go in with cargo run -- audit-append, which leaves every existing entry unchanged, and the server verifies every signature and the whole chain at startup (see GET /audit).

To be candid about how it got here: until November 2026 this page, the repo and the server's own provenance output said the registry was signed when it wasn't. Only the audit log entries were, and those had been signed with a hard-coded test key, so anyone could have reproduced them. Both are fixed. The registry is now signed with the production key, the audit log was re-signed with it, and the server enforces both.

Since v3.0, curators can run their own nodes and endorse each other. A query runs against the local registry (results tagged trust: direct) and against cached peer registries (tagged trust: endorsed), so an agent can see who recommended what. A peer is only trusted if its registry verifies against the key you endorsed. An unsigned, tampered or impostor registry is dropped and the peer is marked InvalidSignature. cargo run -- fork --endorse <curator-pubkey> scaffolds a new node with a fresh PKARR keypair and a signed starter registry.

What I Learned

Building an MCP server in Rust taught me that the protocol is simpler than I expected. It's JSON-RPC 2.0 over HTTP with a specific tool call structure. No complex streaming or state management required. The hardest part was designing the query matching algorithm to balance precision and recall.

I initially used exact string matching, but users would ask "how do I run a bitcoin full node" when the category pattern was "setting up bitcoin core". Fuzzy matching fixed that, but required careful tuning of weights and thresholds. Too low and everything matches. Too high and nothing does.

The "three sources" constraint was the best design decision. It forces curators to prioritize ruthlessly. You can't just dump a list of 20 links. You have to pick the official docs, the best tutorial, and the essential tool. That curation is the entire value proposition.

PKARR integration was straightforward but the ecosystem is still early. The curator's PKARR key now signs both the registry and the audit log, and federation, where curators endorse each other, shipped in v3.0. One loose end: the identity proofs that link the curator key to my X, GitHub and Nostr accounts still point at the old test key, and moving them to the production key is next.


Curated sources beat algorithmic noise every time.