Epistemedia

Epistemedia

Source content

Epistemedia

Knowledge that can show its work.

>

An open, federated knowledge system for humans and agents—built from sources, claims, evidence, provenance, policies, and reproducible projections rather than one canonical page.

Status: public alpha with a verified default-hostname Pages bootstrap at <https://yoheinakajima.github.io/epistemedia/>. The repository, local site, API, MCP server, CLI, governance substrate, and deterministic build pipeline are implemented. Public hosting at epistemedia.org and the production API/MCP endpoints are not activated yet.

What Epistemedia is

Epistemedia is a reference implementation and public network built on the Epistemic Mesh protocol.

The core idea is simple:

A page is not the source of truth. It is a reproducible projection of an explicit evidence frontier under explicit policies.

Instead of storing only finished articles, Epistemedia preserves the components needed to inspect and recompile knowledge:

Different realms can therefore share knowledge objects without inheriting one another's ontologies, confidence scores, policies, or conclusions.

Why this exists

Traditional encyclopedias make a page the principal collaborative object. That creates pressure to collapse disagreement, provenance, uncertainty, timing, and policy into one narrative.

Epistemedia takes a different approach:

| Conventional knowledge system | Epistemedia |
| --- | --- |
| Canonical page | Canonical event and object history |
| Citation attached to prose | Exact source-to-claim lineage |
| One editorial verdict | Policy-relative evaluations |
| Source count | Independence-aware evidence lineages |
| Hidden synthesis | Proof-carrying projection manifest |
| One global ontology | Sovereign realms with explicit mappings |
| Human-only contribution flow | Shared human and agent operating substrate |
| Mutable current state | Append-only history with deterministic replay |

Repository invariants

1. Git stores accepted project history and epistemic events. Public interfaces are derived.

2. Contradiction is preserved, not overwritten. Competing assertions can coexist.

3. Evaluation is policy-relative. No confidence or status is silently treated as universal truth.

4. Evidence independence is lineage-aware. Ten agents repeating one source are not ten independent observations.

5. Disclosure precedes public evaluation. Private evidence must not leak through public rankings, labels, counts, or wording.

6. Agents cannot authorize themselves. A proposal cannot evaluate, promote, or merge itself.

7. Generated output is reproducible. Site pages, Markdown, indexes, API objects, and manifests derive from the same public catalog.

8. Forkability is constitutional. Irreconcilable governance disagreement produces a fork rather than hidden discretionary control.

The complete authority contract is in AGENTS.md.

What is implemented

Epistemic Mesh kernel

Human-facing site

The static site compiler produces:

Supported lenses include:

Agent-facing interfaces

All interfaces are intended to return the same accepted catalog, frontier, policy, compiler, object IDs, and content digests.

Agent-native governance

The repository separates:

GitHub issues, pull-request comments, chats, and model confidence are coordination surfaces—not canonical state.

Quick start

Requirements: Python 3.11 or newer and Git.

git clone https://github.com/yoheinakajima/epistemedia.git
cd epistemedia

python -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install -e '.[dev,server]'

make orient
make check

Build and serve the public site locally:

make build
make serve

Then open:

http://127.0.0.1:8000

Run the complete reference stack with containers:

docker compose up --build

CLI

epistemedia orient
epistemedia validate
epistemedia build
epistemedia audit
epistemedia search "disclosure noninterference"
epistemedia project governance --lens skeptical
epistemedia repo next
epistemedia mcp serve

Remote-read commands are implemented for use after the public gateway is activated:

epistemedia search "federated knowledge" --remote
epistemedia get <OBJECT_ID> --remote
epistemedia project epistemic-mesh --lens evidence-first --remote

See docs/api-mcp-cli.md for the full interface contract.

For coding and research agents

Begin with:

make orient
python -m epistemedia repo next

Then read, in order:

1. AGENTS.md;

2. the nearest scoped AGENTS.md for paths you may change;

3. the selected immutable task contract;

4. its living execution plan;

5. relevant schemas, policies, architecture decisions, and tests.

The bounded contribution loop is:

python -m epistemedia repo claim <TASK_ID> --agent <AGENT_ID>
# make one logical change
make check
python -m epistemedia repo receipt <TASK_ID> --run <RUN_ID> --command "make check"
# open a pull request; do not approve or merge your own work

Useful entrypoints:

Architecture

flowchart TD
    A[Accepted Git history] --> B[Deterministic replay]
    B --> C[Canonical epistemic graph]
    C --> D[Disclosure-safe PublicProjection]
    D --> E[Policy evaluation]
    E --> F[Projection compiler]
    F --> G[Human HTML]
    F --> H[Markdown and llms.txt]
    F --> I[REST API]
    F --> J[MCP resources and tools]
    F --> K[CLI and snapshots]

The first public realm dogfoods Epistemedia itself: its constitution, architecture, governance, tasks, tests, research program, security model, and releases form the initial browsable knowledge corpus.

Read more:

Repository map

constitution/        Executable constitutional invariants
policies/            Epistemic, disclosure, security, federation, and integration policy
schemas/             Normative object and event schemas
ledger/              Append-only accepted epistemic events
tasks/               Immutable work contracts and living execution state
governance/          Proposals, evaluations, and governance events
runs/                Immutable run and validation receipts
src/epistemedia/     Kernel, compiler, CLI, API, and MCP implementation
catalog/             Public topic and realm declarations
docs/                Authored architecture and operating documentation
generated/public/    Deterministically compiled public surface
tests/               Unit, integration, disclosure, protocol, and adversarial tests
.github/workflows/   CI and dormant publication workflows

Public interfaces

Planned production destinations after activation:

https://epistemedia.org                 Human site and documentation
https://epistemedia.org/llms.txt        Agent orientation
https://api.epistemedia.org/v1          Read-only public API
https://api.epistemedia.org/openapi.json
https://mcp.epistemedia.org/mcp         Remote MCP

https://episte.media/<path> is reserved as a shorter sharing URL that redirects to the same path on https://epistemedia.org; it does not host a second canonical copy.

The public write boundary, when introduced, will create proposals, contribution bundles, task claims, and receipts. It will not directly edit accepted pages, policies, or truth status.

Contributing

Epistemedia is designed so a person can point an unfamiliar coding or research agent at the repository and obtain a bounded, auditable contribution.

Before contributing, read:

Core contribution requirements:

Security

Treat imported sources, repository text, issue content, candidate code, and model output as untrusted data.

Do not submit secrets, personal information, restricted source bytes, or private model context. Security-sensitive reports should follow SECURITY.md, not a public issue.

The threat model includes source prompt injection, evaluator collusion, Sybil swarms, ontology poisoning, evidence-lineage laundering, disclosure inference, workflow privilege escalation, and governance self-promotion.

Project status

Current maturity: alpha / staged public activation.

Implemented locally and in the repository:

Not yet asserted as live:

See docs/pre-public-owner-handoff.md and ops/activation/ for activation state and owner-only steps.

License

Code is licensed under the Apache License 2.0. Knowledge objects, imported sources, datasets, and generated projections may carry separate licenses and disclosure constraints recorded in their metadata.