Share what you know,
not just what you can publish.
Phiacta is an open platform where knowledge is stored as versioned, citable entries — not locked inside static PDFs. Publish anything worth sharing, attach your evidence, and let others build on it.
The problem
The paper was never the right container.
The academic paper is a 350-year-old format that predates the internet. It was designed for print distribution, not for an age where knowledge should be searchable, queryable, verifiable, and composable.
Most research never gets shared
Papers demand a complete story. Null results, negative findings, single theorems, intermediate observations — they disappear. Phiacta accepts anything worth citing.
Published work can't be corrected
A wrong result in a PDF stays wrong. On Phiacta, anyone can open an issue or propose a correction. Every version is preserved — including the original.
Knowledge is buried in prose
Finding a specific result means reading a whole paper. On Phiacta, every entry is its own unit — searchable, taggable, and directly linkable.
Code and data are treated as afterthoughts
Supporting materials can't be cited independently, have no version history, and vanish when servers move. Everything that isn't the paper is a footnote.
The entry
One idea. One entry.
An entry is anything worth citing — a theorem, a dataset, a null result, a full paper. Each one is versioned, citable, and backed by a git repository. Here's a real example from the platform.
Pythagorean Theorem
In any right triangle with legs a, b and hypotenuse c: a² + b² = c².
3For any right triangle with legs a and b and hypotenuse c, a² + b² = c². One of the oldest results in mathematics, with over 370 distinct proofs. Formally verified in Lean 4 via Mathlib.
Entry type
theorem, result, paper, dataset, method — or anything else
Evidence
attached proofs, data, code — presence or absence is visible
Summary
the key claim in plain language
Tags
for search and discovery
Content
markdown or LaTeX, fully rendered
Attached files
proofs, notebooks, raw data
References
typed links building the knowledge graph
Version history
every edit preserved; any version is permanently citable
What becomes possible
Things that weren't possible before.
Some of these were theoretically possible. Most weren't worth attempting.
Cite the theorem, not the paper
You reference Lemma 2.3 from a 2019 paper. Your citation points to 40 pages and hopes readers find the right section. With Phiacta, the lemma is its own entry — citable, versioned, permanently addressable.
Publish what didn't work
You ran 200 experiments. None worked. That knowledge prevents others from wasting the same time — but there's no venue for it. Phiacta accepts any result worth recording.
Share a small discovery
You found a neat algebraic identity while working on something else. Not a paper's worth of work — but genuinely useful to the right person. It used to disappear into a notebook. Now it's a citable entry.
Correct the record
You found an error in a widely-cited result. Before: write a correction paper, wait a year, hope people find it. Now: open an issue on the entry. The record updates.
Ask AI about your own research
You're extending six months of prior work. Connect your knowledge graph to Claude via MCP — it reads the structure, finds gaps, and surfaces connections you missed. It can't do that with PDFs.
Attach the proof
A theorem is claimed. In a paper, you trust the author. In Phiacta, the entry can carry a machine-checked Lean 4 proof. The verification is part of the permanent record.
The graph
Entries don't exist in isolation.
References connect entries into a typed knowledge graph. A theorem cites a definition. A paper contains its component findings. A result supports a theory. Traverse the graph from any entry — in the browser or via the API.
Illustrative example — click any entry on the explore page to see its reference graph.
Who it's for
Built for everyone who
creates or uses knowledge.
Researchers
Publish anything worth sharing — not just what fits a paper. Get credit for null results, single theorems, and intermediate findings. Let the community correct and build on your work.
- Null and negative results count
- Attach formal proofs or data
- Issues and edits
AI builders
A structured knowledge graph your agents can actually query. Typed entries, explicit references, full-text search, and graph traversal — all available over a clean REST API.
- MCP server — Claude, Cursor, Codex
- Reference graph traversal API
- Full-text search over all entries
Tool builders
Open source, documented, and built to be extended. The same plugin framework that powers built-in features is open to anyone. Build extensions and tools on top of the platform.
- Full OpenAPI spec
- Python SDK with typed models
- Open plugin framework
The mission
“A permanent, open layer of knowledge for the internet.”
Knowledge today is scattered, unstructured, and hard to verify. Papers lock findings inside static PDFs. Social platforms bury truth in noise. Encyclopedias reflect a single editorial perspective. None of them were designed with provability in mind.
Near-term
Phiacta replaces the academic paper. Researchers publish individual entries backed by data, code, and proofs — no more monolithic PDFs. Each entry is citable, reviewable, and updatable without touching anything else.
Long-term
A general knowledge layer for the internet — a more trustworthy, more structured alternative to how knowledge is shared across X, Reddit, Wikipedia, and Stack Exchange. Grounded in entries that can be backed by evidence and tracked over time.
Core principles
The beliefs behind
every design decision.
An entry is anything worth citing
An entry represents something worth citing — a single finding, a full paper, a dataset, a method. Composite entries tie related entries together with references.
Permanent versioned history
Every version of every entry is preserved forever. Nothing is deleted — entries can be made private but their full history remains intact.
Proof over assertion
Empirical entries attach the data and code that produced the result. Mathematical entries attach machine-checkable proofs. Unverified entries are accepted — but the absence of proof is visible to everyone.
Public by default, author-controlled
Entries are publicly readable by anyone. Only the author and explicit collaborators can modify an entry — like a public open-source repository.
Negative results count
The current system only rewards what worked. A null result, a failed replication, or an experiment that didn't pan out is just as valuable — and should be an entry.
Record, don't resolve
Contradictory entries coexist. The system records what has been asserted and by whom. Resolving disagreements is left to the community through reviews and discussion.
Ground truth only
The database stores only what users directly provide. Confidence scores, graph traversals, and rankings are derived at query time and never written back as ground truth.
Built to be built on
Everything on this website uses the same public API. The Python SDK automates workflows in a few lines. The MCP server gives AI agents full platform access.
For builders
A platform, not just a website.
Everything you see here is powered by the same public API that anyone can use. Query the knowledge graph, build ingestion pipelines, or connect AI agents in minutes.
Connect Claude, Cursor, Codex, or any MCP-compatible agent. Tool schemas and documentation are built in — your agent can search, read, and create entries immediately.
{
"mcpServers": {
"phiacta": {
"command": "uvx",
"args": ["phiacta-mcp"],
"env": {
"PHIACTA_TOKEN": "pat_..."
}
}
}
}The plugin framework is open too. Extensions add new data to entries, tools add new query endpoints — both hook into the same lifecycle and discovery system the built-in features use.
How it's built
Three layers. One clear separation.
The core is minimal — everything else is pluggable. Extensions add data; tools add query surfaces; entries are the ground truth.
Tools
Stateless query endpoints — search, graph traversal, custom tools. Take input, produce output; never modify entries.
Extensions
Platform features with their own data — metadata, types, references, tags, search indexes. Each declares dependencies and can be added or removed independently.
Entries
The knowledge itself. Git repos store content; the database stores the index. If everything else were removed, the entries would still be intact.
Entries are backed by versioned git repositories. Phiacta surfaces the underlying concepts in plain language that requires no technical knowledge:
| Under the hood | What you see |
|---|---|
| Repository | Entry |
| Commit | Update / version |
| Branch + pull request | Edit |
| Issue | Issue |
| Merge PR | Accept edit |
| Fork | Derive (creates a new entry) |
Scope
What Phiacta is not.
Not a content generator
Phiacta does not produce summaries, papers, or visualizations. That is the job of extensions and tools. Phiacta's job is to maintain a clean, permanent, queryable store of entries.
Not a social network
Community features (reviews, discussion) exist to surface the quality of entries — not to maximise engagement.
Not a software repository
Versioned repositories inside entries hold supporting materials (data, proofs, scripts), not software projects.
The name
Phiacta blends two roots: phi (φ), the Greek letter representing the golden ratio, and facta, Latin for “things done” — the origin of “fact.” Together: structured, well-formed facts, shaped with the same elegance that phi embodies.
Ready to start?
Phiacta is open source. Browse the entries already on the platform, create your first entry, or get involved with the project.
See the contributing guide or reach out at [email protected]