Utopia: A Bitemporal Knowledge Graph That Treats Time as a First-Class Citizen

What Utopia Actually Solves

Most knowledge graphs and vector stores capture a snapshot of the present. Utopia starts from a different premise: an enterprise needs to know not only what is true, but when it became true, when the system learned it, and how that understanding changed over time. The README calls this a bitemporal knowledge graph, and it is the project's core differentiator. When a decision is reviewed later, the system can show the full course of reasoning and the grounds it rested on. That matters for regulated industries, internal audits, and any agent whose decisions must be explainable after the fact. Utopia is not a library or a plugin; it is a complete application with a web UI, an ontology workbench, and a graph browser. The intended user is an enterprise that wants a self-hosted knowledge foundation on hardware it controls, not a developer looking for a component to embed.

The Bitemporal Mechanism

Utopia's design centers on two timelines. The first records when a fact was true in the world. The second records when the system came to believe it. The README explains that correcting a fact closes the old version and links the new one to it rather than overwriting. This is the opposite of the typical update-in-place approach in relational or graph databases. Every fact carries a validity interval and a provenance source. The consequence is that the graph never forgets a previous belief, which is exactly what you want for auditing an AI's decision trail. The ontology is not an afterthought; it sits in the base layer. Conflict detection, reasoning and decision making all run against that ontology.

Architecture: One Binary, One Postgres

The deployment model is deliberately minimal. One Rust binary and one Postgres instance. Full-text search is embedded in the binary via Tantivy, vectors go into pgvector, and the job queue is a regular database table. There is no separate search engine, vector database, or message broker to operate. That is a strong operational advantage for a self-hosted system. The data flow starts with ingestion: files like PDF, DOCX, PPTX, XLSX, CSV, Markdown, and HTML are uploaded, with legacy encodings detected on the way in. Web pages, RSS, GitHub, Jira, Notion, WebDAV, and S3-compatible buckets sync on a schedule. Everything else comes through the API. Extraction then turns documents into entities and facts, guided by an ontology you can edit. The system console, graph browser, and ontology workbench live in one web UI, so an administrator can manage the whole pipeline without leaving the browser.

Getting It Running: Commands and Config

The system is distributed as a container image on GHCR, and the repository's docker-compose.yml pins ghcr.io/deeplethe/utopia:0.1.0-rc9 by default next to a pgvector/pgvector:pg16 database. A full deployment is `docker compose --profile app up -d`; local development starts only the database and runs the app with cargo run. The project is built with Rust and uses Postgres as its only external dependency. You will need a Postgres instance with pgvector enabled, since vectors are stored there. The web UI is served by the binary itself, so after starting the container and pointing it at a database, you access the console through a browser. The README mentions that any OpenAI-compatible endpoint works for chat and reasoning, including DeepSeek, Qwen, GLM, Ollama, and vLLM. That means you can configure an endpoint URL and API key, and the system will use it for search, chat and the built-in agent. The entire system can run air-gapped if you point it at a local model server like Ollama or vLLM.

Ontology Packs and Cold Start

Utopia puts ontology in the base layer: the knowledge system evolves as material arrives, and conflict detection, reasoning and decision making all run against that ontology. Curating it happens in the ontology workbench that ships in the same web UI as the system console and graph browser. Treat ontology design as real work: if your domain is niche, expect to spend time shaping the ontology yourself.

Entity Resolution and Review Queue

Utopia does not claim full automation. The README says each use case leaves the doubtful cases to a person in Review, and anything an agent connected over MCP wants to record goes to a person first as a proposal. A human must periodically work through that queue to keep the graph clean. This is a genuine operational cost: for an enterprise with high document volume, the queue could become a bottleneck.

Limitations and Failure Modes

Utopia is at version 0.1.0-rc9, which means it is pre-release software. If your ontology is poorly designed, the bitemporal graph will faithfully record your mistakes. Another limitation is the dependency on a model for extraction and entity resolution. While the system can run with local models, the quality of the knowledge graph depends heavily on the model's performance. The README points to a temporal QA bench and a contracts corpus under scripts/bench, but you should still test how well it extracts facts from your own documents.

Alternatives and the Palantir Comparison

The README explicitly asks not to frame Utopia as an open-source Palantir, yet the comparison is inevitable. Palantir's Foundry is a closed-source platform that also handles ontology, knowledge graphs, and decision support. The key difference is that Utopia is open source under Apache-2.0 and deploys entirely on your own hardware, whereas Foundry is a commercial SaaS or on-prem product with a different licensing and cost model. Another alternative is a combination of a vector database like pgvector with a graph database like Neo4j, plus a standard RAG pipeline. That approach gives you flexibility but requires you to build the bitemporal layer yourself. Utopia's advantage is that bitemporality is baked into the storage and query layer, not added as an afterthought. A third alternative is using a time-series database for temporal facts, but that would not give you the ontology or the entity resolution. For teams that only need semantic search over documents, a plain vector store is simpler and cheaper; Utopia's complexity is only justified if you need the full temporal and ontological model.

Maintenance, License, and Upgrade Cost

The project is licensed under Apache-2.0, which is permissive for commercial use and modification. The repository is not archived, and the last push was on 2026-11-02, with release candidates rc7, rc8 and rc9 published between 2026-09-25 and 2026-10-11. That cadence suggests active development, but it also means the API and data model may change between release candidates. Upgrading between release candidates might require manual steps; docker-compose.yml refers to upgrade notes in the README, for example for creating the restricted database role on an existing deployment. The project is written in Rust, which has a steep learning curve if you need to modify the source. The operational cost is low because there is only one binary and one Postgres, but you must maintain the database schema and run the review queue. Beyond the README, there is a walkthrough in docs/, an MCP guide, and a GitHub Discussions link for questions. The official site utopia.bi may contain more, but it is not linked in the repository metadata. For a production deployment, you should plan for a learning period and budget time for contributing fixes upstream if you hit bugs.

Editorial conclusion

Adopt Utopia if your organization needs a self-hosted, ontology-driven knowledge base that can reconstruct the history of its own beliefs for audit or compliance, and if you can tolerate early-release roughness. Do not adopt it if you need a mature, battle-tested platform or if your team lacks Rust and Postgres expertise. Before committing, verify the current state of the review queue, how well the ontology fits your domain, and whether the bitemporal model meets your specific audit requirements. The project's last push and release cadence show active development, but v0.1.0-rc9 is not a final release; treat it as a prototype with a promising core.

Frequently asked questions

Official sources

1. deeplethe/utopia on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases