Skip to main content

What is Lorediv

The Open Knowledge Tree for the Agentic Era.

Lorediv is a public index of expertise: readable, structured data, so agents can position you. It is a collaborative knowledge-tree designed for the agentic era — it organizes collective expertise into a structured, queryable tree, making information accessible to both humans and autonomous agents. Every topic and branch is a permanent address on a shared structure.

Through a community-driven reputation model (Lore) and domain-scoped specializations (Divs), Lorediv enables search agents to evaluate source authority upfront. This transforms individual contributions into a verifiable fingerprint, ensuring agents extract high-signal context while connecting complex inquiries with domain experts.

How an agent searches​

There is no single public rule. ChatGPT, Perplexity, Google, and Claude each have their own pipeline, and no one can see inside any of them. Still, almost all of them pass through the same stages, and the important part is that the decision is made largely before the model reads a single word. Below, each stage shows what the agent does, and what Lorediv guides it to do once it enters the platform.

The four stages​

  1. Retrieval The agent: turns the question into searches over an index. Only pages already indexed enter the pool, ranked by signals like inbound links, domain authority, freshness, and title match. On Lorediv: every topic carries three tags, so it lands in a division of the tree, and /llms.txt is a flat map of every address. The agent starts from a map instead of guessing where to look.

  2. Access The agent: must be able to open the page. Login walls, heavy JavaScript, and rate limits leave it out. On Lorediv: public URLs, no key, no session. Every public page has a .md twin, and a .json twin where that screen has one.

  3. Extraction The agent: takes clean text from the page. A thread of 9 posts mixed with interface noise loses its structure and its clear authorship. On Lorediv: the structure is already the file. A topic exposes title, subtitle, body, context_links, and branches with letter and parent, and the author sits on the page. Nothing needs to be cleaned or inferred.

  4. Selection and synthesis The agent: with several candidates, favors what answers specifically, what carries visible credibility signals (who wrote it, domain, date), what other sources corroborate, and what is easy to cite. On Lorediv: rank and divs sit in front of the body, so the agent weighs the author before the text. The wiki describes how it should assemble the answer: most weight on GOAT work, then Wizard, then Geek, and none on Newbie. Branches show who confirms or dissents, context_links carry the sources, and a permanent address makes the result easy to cite.

Two identical threads​

If the text is the same, the agent almost never decides by text alone. Systems tend to deduplicate and keep the version that is more accessible, better structured, and carries more authority signals, not always the one published first. What the agent can read wins over what was best.

Lorediv works on both sides of that problem. On the way in, submission scans for existing links and context, so the same idea is not split across duplicates, and copy-paste is not rewarded. On the way out, the version that stays is the one the community has backed, with its rank visible.

The aim​

Users work to position themselves on the web through what they know. The community backs the content that holds value, and that support becomes their lore. Together, we guide search agents to pick up information that is worth citing, and to leave the noise.

Lorediv aims to be a reputed directory, where community members and external readers alike get results with criteria, backed by sources. How an agent reads and weighs is its own choice. Lorediv's part is to make the signal public, structured, and stable.

How users and agents share the tree​

Every public page has a .md and .json twin. You see the HTML. An agent reads the structured version. The entry point for agents is /llms.txt — a map of every public address on the tree. No API key, no session, no scraping. The tree does not distinguish between its readers.

flowchart TD
    User["User reads HTML"] --> Tree["The knowledge tree"]
    Agent["Agent reads .md / .json"] --> Tree
    Tree --> Rank["Lore rank<br/>{tier} {score}"]
    Tree --> Divs["Divs<br/>domain specializations"]
    Rank --> Profile["User profile"]
    Divs --> Profile

The three phases​

  • Phase 1 — Findable (live). The tree is readable. Every public page has HTML, .md, and .json twins. /llms.txt maps the full address space.
  • Phase 2 — Queryable (planned). REST and MCP serve the same tree. Agents cite without scraping.
  • Phase 3 — Reachable (planned). An agent can leave a question for a user, only where that user has said they can be asked.

What you can do​

Phase 1 — Findable (live)​

  • Browse the feed — home, new, closed, and trending views. Filter by tag.
  • Read a topic — every topic has branches, votes, context links, and a history tree. Each page also has .md and .json twins for agents.
  • Cast a vote — the relevance vote moves a topic's score and the author's rank. Three weights: 1, 3, 10. Your rank caps how heavy you can go.
  • Create a topic — eight types with guided forms: post, ask, context, graph, proposal, poll, prediction, argument.
  • Reply and branch — add a response to a post, an answer to an ask, a part to a context, a counter to a prediction, a motion to a proposal. Each branch is a letter on the history tree.
  • Link context — attach source URLs to a topic or a branch. Up to three per item.
  • Bookmark — save topics to your private list.
  • Report — ask for a review of a topic or a branch you did not write.
  • Search — full-text search across the tree.
  • See the community — ranked contributors by domain.
  • Build your profile — your contributions compile into a public fingerprint. Top tags become your divs. Your rank is {tier} {score} like Wizard 6.1.
  • Sign in — X, Google, or GitHub. You can read everything without signing in. Writing, voting, bookmarking, and reporting require a session.

Phase 2 — Queryable (planned)​

  • Query the tree through REST — every public page as a typed JSON response. Lists, topics, history, tags, community, profiles, trending, reputation.
  • Use MCP tools — one tool per API read. Each tool returns the response body and a citeable URL.
  • Create an agent account — linked to a user profile. The agent's reads and queries are tied to the human who owns it.
  • Create topics and upload data via API — programmatic access beyond read-only.
  • Agents cite without scraping. Reads stay sessionless — a query does not add Received and does not publish.

Phase 3 — Reachable (planned)​

  • Agent-to-user mailbox — an agent can leave an inquiry on a user's profile, only where that user has said they accept inquiries.
  • The user answers when ready. Agents reach specialists directly.
  • Agents do not publish on the tree. They ask; the human decides.

Depth​

For the full philosophical treatment: Knowledge tree. For the thermodynamic rails: The system. For the complete overview: Wiki.