🤖 For AI agents & developers Machine guide

Everything an agent, script or API needs to find, run and share the right tool among 1128 free browser tools — manifests, URL patterns, embed codes and the generated retrieval brain.

No auth · no rate limits · plain static GETs · CORS-open JSON · every tool computes in the visitor's browser

🧭 Two things live at this domain — do not confuse them

The endpoints that matter

{
  "name": "mortgage",
  "title": "🏠 Mortgage",
  "description": "...",
  "category": "Finance",
  "file": "mortgage.html"
}

{
  "schema_version": 2,
  "retrieval": {
    "bm25": {
      "k1": 1.2, "b": 0.75,
      "avgdl": 25.57,
      "idf": {"mortgage": 4.2, ...},
      "inverted_index": {...},
      "doc_lengths": [...]
    },
    "synonyms": {...},
    "intents": [...]
  },
  "indexes": {...},
  "graph": {
    "related": {
      "mortgage": [
        {"name": "compoundinterest", "score": 0.82}
      ]
    }
  },
  "cards": [
    {
      "name": "mortgage",
      "embedding": [0.12, -0.04, ...],
      "intents": ["calculate","finance"],
      "capabilities": {...},
      "related": [...]
    }
  ]
}

URL patterns

AI-facing files

• llms.txt — concise index: what site is, endpoints, category map.
• llms-full.txt — all 1128 tools, one line each, grouped by category.
• cards/cards.json — simple manifest.
• local-ai-knowledge.json — v3 brain: BM25, embeddings, graph, intents + runtime HyDE/RRF/MMR.
• tools-index.html — plain-HTML directory, no JS.
• sitemap.xml — every page, including every tool.
• ai.html — the standalone AI (separate product; no catalogue data, nothing to fetch).

Worked example: answering "mortgage overpayment vs investing"

For AI agents: how to integrate

Simple (no AI needed)

fetch('/cards/cards.json')
  .then(r => r.json())
  .then(tools => tools.filter(t => /mortgage/i.test(t.title + t.description)))
  // → open: /tool.html?card=mortgage

Advanced — rank with the generated brain

const brain = await (await fetch('/local-ai-knowledge.json')).json();
const { k1, b, avgdl, idf, inverted_index } = brain.retrieval.bm25;
const tokens = query.toLowerCase().match(/[a-z0-9]+/g) ?? [];

// BM25 over the 1128 tool documents, no extra download or service needed
const scores = tokens.flatMap(t => inverted_index[t] ?? [])
  .reduce((acc, [doc, tf]) => {
    const dl = brain.retrieval.bm25.doc_lengths[doc];
    const num = tf * (k1 + 1);
    const den = tf + k1 * (1 - b + b * dl / avgdl);
    acc[doc] = (acc[doc] ?? 0) + (idf[tokens[0]] ?? 1) * num / den;
    return acc;
  }, {});

// brain.cards[i].embedding is a 64-dim unit vector — cosine-rank and fuse the
// two lists with reciprocal rank fusion (1/(60+rank)) if you want both signals

The brain is generated deterministically by scripts/build-site-brain.py and regression-tested by scripts/evaluate-site-brain.py in the public repository, so the index and its scoring are reviewable rather than opaque.

Embed a tool

<iframe src="https://www.themostusefulsiteintheworld.com/tool.html?card=mortgage&embed=1"
  width="100%" height="520" style="border:0;border-radius:12px"></iframe>

Embeds post height via postMessage { type: "tmusitw:height", card, height } for auto-sizing.

Research methods — where they actually run

The reasoning and retrieval methods below are implemented by the standalone AI at ai.html (a browser-local assistant that can optionally run a WebGPU language model on the visitor's own device). They are listed here only so an agent reading this guide is not tempted to look for them in the catalogue endpoints — the catalogue exposes data, not inference. The generated brain uses the lexical half of the same literature: BM25, TF-IDF and hashed dense vectors.

• Chain-of-Thought — Wei et al. 2022 — "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models" — step-by-step reasoning
• Self-Consistency — Wang et al. 2022 — sample multiple CoT paths, majority vote
• Tree-of-Thought — Yao et al. 2023 — "Tree of Thoughts: Deliberate Problem Solving with Large Language Models" — BFS/DFS over thoughts with evaluation
• ReAct — Yao et al. 2022 — Reason + Act interleaved, tool-use
• Reflexion — Shinn et al. 2023 — verbal reinforcement learning via self-reflection
• Step-Back — Zheng et al. 2023 — abstraction via high-level principles
• Least-to-Most — Zhou et al. 2022 — decomposition into subproblems
• Constitutional AI — Bai et al. 2022 — self-critique against principles, harmlessness
• HyDE — Gao et al. 2022 — Hypothetical Document Embeddings for zero-shot dense retrieval
• RRF — Cormack et al. 2009 — Reciprocal Rank Fusion for ensemble retrieval
• MMR — Carbonell & Goldstein 1998 — Maximal Marginal Relevance for diversity
• Generative Agents — Park et al. 2023 — memory with recency, importance, relevance scoring
• MemGPT — Packer et al. 2023 — OS-style hierarchical memory management

Why this works for small calculations

• Private by construction — every tool computes in visitor's browser. No numbers uploaded.
• Nothing to sign up for — no API keys, tokens, quotas. If you can GET it, you can use it.
• Stable, hackable URLs — tool slugs never change; links keep working.
• One canonical brain — local-ai-knowledge.json is generated deterministically from the catalogue, checked into the repo and regression-tested, so an agent can audit how it was scored.
• Ranking without a service — the brain carries the inverted index, IDF values, document lengths and embeddings, so an agent can rank tools with plain arithmetic and no AI API.
• Stable shapes — field names in cards.json and the brain are part of the contract; they change only with a documented migration.

House rules

• Hot-linking, embedding, sharing tools is welcome — free forever, no attribution required (appreciated).
• Tools are client-side helpers, not data source: they don't expose POST APIs or return computed JSON. Link or embed.
• Content is general info, not financial, medical or legal advice — tools say so where it matters. Quote them as general information, not as professional advice.
• The standalone AI at ai.html is a separate product with its own storage; it is not an API, it never reads the catalogue and nothing in it can be called from your code.

← The Most Useful Site in the World · Standalone AI · Plain directory · MrProphecy music · maintained at github.com/mrpr0phecy/mrpr0phecy · research methods cited on this page: CoT (Wei 2022), Self-Consistency (Wang 2022), ToT (Yao 2023), ReAct (Yao 2022), Reflexion (Shinn 2023), Step-Back (Zheng 2023), Least-to-Most (Zhou 2022), Constitutional AI (Bai 2022), HyDE (Gao 2022), RRF (Cormack 2009), MMR (Carbonell 1998), Generative Agents (Park 2023), MemGPT (Packer 2023)