Stop rebuilding context from scratch. TrustGraph treats context as a holon: modular, independent Context Cores that power multi-tenant agent workflows, while naturally snapping together to form a unified, domain-wide intelligence layer that dramatically reduces your token consumption. Version your context, share it across teams, and scale with full provenance aligned to semantic web standards like RDF, OWL, SKOS, and SHACL.
The philosopher Arthur Koestler coined the word holon to describe something that is simultaneously a whole in itself and a part of something larger. A fact is whole. It is also part of a domain. A domain is whole. It is also part of an organization's knowledge. An organization's knowledge is whole. It is also part of every decision an agent makes.
AI agents break down because this structure is never built. Context gets shoved into flat text windows, scattered across vector stores, or hardwired into one-off prompts. Facts lose their relationships. Agents lose their grounding. Answers become hallucinated guesses.
When you build an AI agent today, you spend most of your time fighting context:
-
RAG retrieves fragments, not meaning. Chunks of text have no structure. Relationships between facts are invisible. Your agent guesses at the connections.
-
Context is disposable. What the agent learned in one session is gone in the next. There is no persistent, structured knowledge layer underneath.
-
Answers aren't traceable. You can't explain why the agent said what it said, which means you can't trust it in production.
-
Knowledge can't be reused. You rebuild the same context pipelines for every new project, every new agent, every new environment.
These aren't retrieval problems. They are structural problems. Context needs to be organized, versioned, and composable — exactly the way software infrastructure is.
TrustGraph provides the full infrastructure layer underneath your agents: knowledge ingestion, structured storage, graph-grounded retrieval, agent orchestration, and inference — all in a single private, sovereign deployment.
At the core is a holonic system: a structured representation of your domain where entities, relationships, and evidence are first-class objects. Every agent query is grounded against these holons that marry symbolic graph structures and vector embeddings. Every answer carries provenance. Every fact is traceable.
On top of that sits Context Cores — portable, versioned bundles of domain knowledge you can build once and ship anywhere. Treat knowledge the way you treat code: build it, test it, version it, promote it to production, and roll it back when something breaks.
A Context Core is the deployable unit of knowledge in TrustGraph. It packages everything an agent needs to reason reliably over a domain into a single, portable artifact.
What's inside a Context Core
- Ontology — your domain schema and entity mappings
- Holon — entities, relationships, and supporting evidence
- Embeddings — vector indexes for fast semantic entry-point lookup
- Provenance — where every fact came from, when, and how it was derived
- Retrieval policies — traversal rules, freshness controls, authority ranking
Context Cores decouple what agents know from how agents are deployed. Build once. Run in Docker locally, Kubernetes in production, or on any cloud. Pin a version. Roll back. Promote across environments. This is context engineering — and it works because knowledge is finally treated like the infrastructure it is.
TrustGraph has a three-level system for organizing and isolating knowledge.
A Workspace is the outermost boundary — a fully isolated tenancy scope where all data, users, configuration, and pipelines live independently from every other workspace. Isolation is structural: enforced at the pub/sub queue, storage, and API gateway layers, not by trusting a field in a message body.
Within a workspace, a Collection groups related holons, graph structures, embeddings, and documents together — think of it as a dedicated shelf in a library, scoped to a specific domain, project, or customer.
A Flow is a running data processing pipeline that defines how raw data moves through ingestion, extraction, structuring, and storage — the assembly line that turns documents into queryable knowledge. Together, the three layers let you run multiple isolated tenants on a single deployment, separate knowledge by domain within each tenant, and process that knowledge through fully configurable pipelines — all without restarting the system or rebuilding your infrastructure.
TrustGraph is not a wrapper around a graph database. It is the complete backend for production agentic systems.
- Holonic engine: automated entity and relationship extraction, ontology-driven graph construction, graph-grounded retrieval for explainable outputs
- Multi-model database: tabular/relational, key-value, document, graph, vectors, images, video, and audio — all managed in Cassandra and S3-compatible Garage
- Out-of-the-box RAG pipelines: DocumentRAG, GraphRAG, and OntologyRAG ready to deploy
- Fully agentic orchestration: single or multi-agent, ReAct, Plan-then-Execute, Supervisor patterns, and MCP integration
- 3D Knowledge Explorer: interactive graph visualization with BFS neighborhood extraction and edge pulse animation
- Automated data ingest: quick ingest with semantic similarity or ontology-structured precision retrieval
- Run anywhere: Docker/Podman locally, Kubernetes in the cloud
All major LLMs — Anthropic, Cohere, Gemini, Mistral, OpenAI, and more via API.
vLLM, Ollama, TGI, LM Studio, and Llamafiles for fully local inferencing.
Verified cloud deployments for Alibaba Cloud, AWS, Azure, GCP, OVHcloud, and Scaleway.
How many times have you cloned a repo and opened the .env.example to see the dozens of API keys for 3rd party dependencies needed to make the services work? There are only 3 things in TrustGraph that might need an API key:
- 3rd party LLM services like Anthropic, Cohere, Gemini, Mistral, OpenAI, etc.
- 3rd party OCR like Mistral OCR
- The API key you set for the TrustGraph API gateway
Everything else is included.
- Managed Multi-model storage in Cassandra
- Managed Vector embedding storage in Qdrant
- Managed File and Object storage in Garage (S3 compatible)
- Managed High-speed Pub/Sub messaging fabric with Pulsar or RabbitMQ
- Complete LLM inferencing stack for open LLMs with vLLM, TGI, Ollama, LM Studio, and Llamafiles
No need to clone the repo unless you are building from source. TrustGraph deploys as a set of Docker containers. Configure it on the command line in one step:
npx @trustgraph/config
The config process will generate an app config that can be run locally with Docker, Podman, or Minikube. The process will output:
deploy.zipwith either adocker-compose.yamlfile for a Docker/Podman orresources.yamlfor Kubernetes- Deployment instructions as
INSTALLATION.md
TrustGraph_config.mov
For a browser based configuration, try the Configuration Terminal.
The UI provides tools for all major features of TrustGraph. The UI deploys on port 8888 by default.
- Agent Console — Query your agents directly with streaming responses and live explainability event tracking, so you can watch reasoning unfold in real time
- GraphRAG View — Interactive graph RAG queries with a visual explainability DAG and inline provenance display, making it easy to see exactly where answers came from
- Context Explorer — An interactive 3D context graph explorer with dynamic graph loading, BFS neighborhood extraction, edge pulse animation, and multiple navigation views
- Document Ingestion — A complete upload and submission workflow with page and chunk inspection and document structure browsing
- Ontology Workbench — A full ontology editor with class and property trees, OWL/XML and Turtle import/export with round-trip fidelity, circular dependency detection, and safe-delete confirmation dialogs
- Schema Workbench — Interactive schema management with list, create, edit, and delete operations including field and index management
- Prompt Editor — A dedicated prompt editing workflow
There are 3 libraries for quick UI integration of TrustGraph services.
TrustGraph is licensed under Apache 2.0.
Copyright 2024-2026 TrustGraph
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.