Price terms as published

Each line is the vendor’s own wording, split from the price capture checked on 2026-10-04. Nothing here is rounded, converted or re-worded — the full sentences stay in the review below. Lines that carry only a price continue the plan named on the line above, in the vendor’s own order.

2 price terms for Utopia
#	Plan / term	Checked
1	Free (Apache-2.0), self-hosted	2026-10-04
2	your costs are Postgres + a model endpoint	2026-10-04

One-liner: Utopia is a self-hosted, Apache-2.0 “enterprise world model” from DeepLethe — a Rust and PostgreSQL application where documents are extracted into a bitemporal knowledge graph (every fact records both when it was true and when the system learned it), an editable ontology compiles its axioms into inference rules, contradictions are surfaced instead of silently overwritten, and every confirm/reject/merge leaves an append-only entry in a decision ledger. It is an application, not a library: docker compose up, register on port 1516, done.

Verified facts (checked 2026-10-04)

Attribute	Value	Source
GitHub stars / forks	8,047 / 1,114	`deeplethe/utopia` via GitHub API, 2026-10-04
Open issues / open PRs	26 / 6 (1,047 issues and PRs closed to date)	GitHub search API, 2026-10-04
License	Apache-2.0	GitHub API + README “License”
Stack	Rust workspace (9 crates: core, cli, store, server, ingest, extract, reason, search, llm) + PostgreSQL with pgvector; React frontend	`Cargo.toml`, `docker-compose.yml`, README
Created / last push	2026-08-07 / 2026-10-04	GitHub API
Contributors	21	GitHub API
Latest release	v0.1.0-rc7, 2026-09-25; 5 RC tags total (rc3–rc7)	GitHub Releases API
Deployment	Prebuilt image on `linux/amd64` and `linux/arm64`; tags up to `0.1.0-rc7` are amd64-only	README “Quick start”
Requirements	Docker; local development additionally needs Rust 1.85+, Node 20+, pnpm	README
Default port	1516 (frontend dev server on 5173)	README
Database	`pgvector/pgvector:pg16` by default, overridable via `UTOPIA_DB_IMAGE`	`docker-compose.yml`
Price	No license fee, no paid tier, no hosted version — Apache-2.0 self-host	README + license
Model endpoints	Any OpenAI-compatible endpoint: DeepSeek, Qwen, GLM, Ollama, vLLM	README “Search and chat”

The idea, in one paragraph

Ordinary vector stores and knowledge graphs hold present knowledge. Utopia insists on recording the whole course of changing understanding — which engineers into a bitemporal graph with two clocks: valid time (when a fact applied in the business) and record time (when the system knew that version). That distinction is the whole product. When someone corrects a fact later, today’s answer changes but what was known on the earlier date does not, and an auditor can replay the earlier belief. The README names its own inspirations (Ptolemy → Copernicus → Kepler → Galileo → Newton) and says the name is “somewhat romantic” for that reason.

What is genuinely built, not aspirational

Ingest. PDF, DOCX, PPTX, XLSX/XLS/ODS, CSV/TSV, Markdown, HTML and plain text, with legacy encodings detected; scans and images via a MinerU service or a Volcengine Ark vision model; recordings via a transcription model that labels speakers; scheduled sync for web pages, RSS, GitHub, Jira, Notion, WebDAV and S3-compatible buckets; everything else via API.
Retrieval. Tantivy full-text fused with pgvector vectors via RRF; streamed answers with inline citations that open the source passage.
Ontology. Five packs ship in the binary (schema.org, W3C Org, PROV-O, FOAF, IOF Core); terms outside them are counted as they appear and join the ontology once confirmed. Axioms compile into rules (transitivity, symmetry, inverses, relation hierarchy) with forward chaining — off by default, because a wrong axiom derives wrong facts. Derived facts are marked as derived, and when a derived fact contradicts an asserted one, the asserted one stands.
Conflict detection, in three flavours: a new fact clashing with an older one (close the old / keep both / reject the new); data breaking an axiom (retract the fact / relax the axiom / accept both); and the ontology itself checked first, since violations of a self-contradictory ontology are noise.
Entity resolution in three stages — exact name or alias, embedding similarity, then a model’s call on the doubtful pairs — with every merge undoable and uncertain cases pushed to a human review queue whose decisions are recorded and used to tune the agent.
Decision ledger. Confirming or rejecting a fact, merging or reverting an entity, rebuilding the graph: each leaves who / when / what-the-object- looked-like, append-only, and a record outlives its object even the base it belonged to.
Agents. The whole system is drivable by conversation; an MCP server per knowledge base exposes the same read-only tools to Claude Desktop, Cursor and others with fine-grained permissions.
Mounted databases. Postgres, MySQL-protocol engines, Trino over Iceberg/Delta Lake/Hive, Databricks and Snowflake, mapped onto the ontology by the agent for you to confirm. The method behind it, Ontology2SQL, is claimed state-of-the-art on BIRD Mini-Dev for SQLite and PostgreSQL (the README links a BIRD bench submission — treat “SOTA” as the authors’ claim until you read the numbers).

The catches

v0.1 with forward-only migrations. The README’s Status section is unusually candid: the schema evolves between versions, migrations only roll forward with no rollback, and production deployments must pin a version with UTOPIA_IMAGE and back up both the database and the data directory before upgrading. The database password is applied at first volume initialisation; changing it on a running deployment means changing it in the database too, and docker compose --profile app down -v deletes all data.
The second clock is not universal yet. This is the most important caveat and it comes from outside the project. Wavect’s review (6 September 2026, pinned to commit 9a3ab337) reads Utopia’s own two-clock design record and reports that full-text recall remains current-state only and that the second-clock UI control is still unresolved. The same review notes that a citation proves a route to evidence, not that the extracted assertion is correct, and that the RDF export is not a restorable backup. Their recommendation — evaluate it for a bounded workflow where late corrections matter, keep simpler search if people only need the current handbook — is the right shape of test.
Roadmap items are checkboxes, not features. Decision reasoning, business rules, the execution gate, agent memory over MCP, ClickHouse and Feishu connectors, and the whole Enterprise line (OIDC SSO, backup and restore commands, 100k-document benchmarks) are unchecked in the README. MaxCompute support is listed as awaiting a run against a real cluster.
“World model” is a vendor term. The GitHub description and utopia.bi both say “world’s first open-source enterprise world model”, and the README explicitly asks not to be framed as an open-source Palantir. In this context it means structured enterprise knowledge that changes over time — not a system that predicts business outcomes. Say “temporal knowledge substrate” in a buying document and the claim survives.
Cost is yours, and mostly not the licence. Wavect’s cost formula is the honest version: infrastructure + model usage + review hours × internal hourly cost + maintenance, divided by accepted source-supported answers. The cost driver most easily missed, they argue, is maintaining the ontology and resolving disputed facts. Note also that self-hosting the web app does not keep prompts local if it points at an external model endpoint — the air-gapped configuration requires a local endpoint (Ollama, vLLM) as well as local storage.

Who should care

Compliance and audit teams who must answer “what did we know, and when” questions. That is the one job this does better than a vector store.
Enterprise architects comparing knowledge stacks: read this against Graphiti (a temporal context-graph framework) and SQL Server temporal tables (row history in a database you already run). Utopia’s pitch is the assembled application, not the graph algorithm.
Teams with an existing Postgres and a willingness to run review queues — the human-in-the-loop machinery is the product, and it is real work.
Everyone else: if your documents only need current answers, plain RAG is cheaper and simpler, and Wavect says so plainly.

Sources

https://api.github.com/repos/deeplethe/utopia — stars, forks, license, contributors, created/pushed, language (2026-10-04)
GitHub search API — 26 open issues / 6 open PRs, same split for closed (1,047) (2026-10-04)
https://api.github.com/repos/deeplethe/utopia/releases — v0.1.0-rc7 (2026-09-25) and the RC series (2026-10-04)
Raw README on dev, fetched 2026-10-04 — features table, quick start, roadmap, status, license
Cargo.toml and docker-compose.yml on dev, fetched 2026-10-04 — 9-crate workspace, pgvector/pg16 default image, UTOPIA_DB_IMAGE override
https://wavect.io/blog/utopia-temporal-knowledge-graph — independent review, 6 Sep 2026, pinned to commit 9a3ab337; full-text current-only finding, cost model, evaluation plan (third-party, dated)
https://utopia.bi/ — official site; meta description confirms the “world’s first open-source enterprise world model” self-description (2026-10-04)

Hindsight: Vectorize agent memory — agent memory without the temporal graph.
WeKnora: Tencent open-source RAG — a conventional RAG baseline to measure Utopia’s temporal claims against.

Method note: star/fork/issue/PR counts, license, contributors and dates from the GitHub REST API on 2026-10-04; the closed issue+PR total is a combined search-API figure, not split; feature and roadmap claims from the raw README on dev the same day; infrastructure details read directly from Cargo.toml and docker-compose.yml; the “full-text recall is current-only” caveat, the cost model and the evaluation plan are Wavect’s, dated 6 September 2026 and pinned to commit 9a3ab337 — their status column marks roadmap items explicitly as not-yet-shipped. I did not stand up a Utopia deployment, so the BIRD Mini-Dev claim and the benchmark numbers are the authors’ and their reviewer’s, not measurements of mine. Review type is official.

Verdict

The most unusual architecture in open-source enterprise AI right now, and the most clearly pre-1.0. Utopia puts two clocks on every fact - when it held in the world and when the system came to believe it - which is the only way an agent can answer "who owned this account on 12 March, as known on 12 March?" correctly after a late correction. Everything is self-hosted: one Rust binary plus Postgres/pgvector, any OpenAI-compatible endpoint, MCP out to Claude Desktop and Cursor. The catches are stated plainly in its own README: v0.1 with forward-only migrations, a roadmap where OIDC SSO and backups are still unchecked, and a third-party review that found full-text recall is current-state only - so the second clock is real for graph reads and not yet universal.