SAN FRANCISCO, CA — December 4, 2025 — TrustGraph, the open-source agentic AI platform built for enterprises, today announces the release of version 1.6, introducing comprehensive streaming support that transforms real-time interactions with large language models, knowledge retrieval systems, and multi-step AI agents.

Streaming as a First-Class Capability
Version 1.6 marks a significant milestone in TrustGraph's evolution: streaming is now a native, production-ready feature across the entire platform. This release addresses a critical gap in enterprise AI infrastructure—the ability to deliver real-time, token-by-token responses that reduce latency, improve user experience, and enable truly interactive agentic workflows.

Full Streaming Support Across All LLM Providers
The release introduces comprehensive streaming infrastructure integrated with every major LLM provider, including Azure, Claude, Cohere, Google AI Studio, Mistral, OpenAI, Vertex AI, and private model services like Ollama, LM Studio, Llamafile, and TensorFlow Text Generation Inference (TGI).

Developers can now configure streaming at the schema level and invoke it seamlessly across TrustGraph's full API surface—REST, WebSocket, Python client, and CLI tools. Critically, all streaming implementations are fully backward compatible with existing non-streaming clients, ensuring a smooth transition for production deployments.

Extended Streaming to GraphRAG and Document Retrieval
TrustGraph 1.6 extends streaming beyond raw LLM completions to knowledge-driven retrieval systems. GraphRAG, driven by ontologies, and DocumentRAG services now stream token-by-token responses, delivering insights from knowledge graphs and document stores in real-time. Queries that previously waited for complete batch processing now return results incrementally, enabling enterprises to surface knowledge faster and improve responsiveness in mission-critical applications.

The implementation maintains consistency across all TrustGraph services—developers experience a unified streaming UX whether querying an LLM directly, retrieving from a knowledge graph, or invoking a multi-step agent workflow.

Real-Time Agent Interactions and Streaming Thought Process
Enhanced streaming support for agentic workflows represents a watershed moment for transparent, observable AI reasoning.

• Observe reasoning in flight — Watch agents think through problems step by step

• Deliver incremental results — Surface intermediate conclusions as agents work through multi-step workflows

• Build transparent interfaces — Create user-facing applications that show AI reasoning progressively, building trust through explainability

• Reduce apparent latency — Deliver immediate feedback during long-running agent operations

The release includes a robust streaming parser for agent responses, with comprehensive error handling and automatic recovery mechanisms designed for production reliability.

Gateway API and WebSocket Support
The API Gateway now natively supports WebSocket streaming, enabling real-time client applications to receive token-by-token responses without polling or long-polling inefficiencies. This architecture scales effortlessly across multiple concurrent connections, crucial for enterprise deployments serving thousands of users.

Enhanced Integration Testing
Comprehensive integration tests validate streaming functionality across LLM providers, RAG systems, and agent workflows, ensuring consistency and reliability in production environments.

Critical Bug Fixes and Compatibility Improvements
AWS Bedrock Model Invocation — Resolved compatibility issues with newer Bedrock model invocation APIs, including full streaming support for the latest Bedrock models.

Minio Library Compatibility — Fixed incompatible library changes in the Minio client for blob storage operations, ensuring stable object storage interactions in deployments using S3-compatible backends.

Streaming Agent Race Conditions — Eliminated race conditions and message ordering issues in streaming agent responses, guaranteeing deterministic, auditable agent behavior—a critical requirement for enterprise compliance.

Developer Experience Enhancements
New CLI improvements expand TrustGraph's developer tooling. The tg-dump-queues utility now provides diagnostic insights into streaming queue states, enabling engineers to troubleshoot and optimize queue configurations in real-time.

Deployment Flexibility and Model Support
Version 1.6 includes updated templates for the latest Bedrock and Claude models, ensuring seamless integration with state-of-the-art LLMs. The platform continues to support deployment across cloud providers (AWS, Azure, Google Cloud, OVHcloud, Scaleway), private data centers, and bare-metal infrastructure.

Building Production-Grade Agentic AI
TrustGraph's philosophy remains unchanged: build infrastructure that enables enterprises to move from AI demos to durable, mission-critical systems. Streaming in 1.6 is not a bolt-on feature—it's architected into the core platform, designed for production use from day one.

The combination of Apache Pulsar's event-driven backbone, knowledge graph semantics, and now comprehensive streaming support creates an AI infrastructure stack uniquely suited to enterprises that refuse to compromise on data sovereignty, auditability, or reliability.

Availability
Version 1.6 is available immediately via GitHub at https://github.com/trustgraph-ai/trustgraph and through the Configuration Builder at https://config-ui.demo.trustgraph.ai/.

The release is fully open source under the Apache 2.0 license, enabling enterprises to deploy, modify, and operate the platform on their own infrastructure with complete transparency and control.

For more information:

• Documentation: https://docs.trustgraph.ai

• GitHub Repository: https://github.com/trustgraph-ai/trustgraph

• Discord Community: https://discord.gg/sQMwkRz5GX

• Website: https://trustgraph.ai

SAN FRANCISCO, CA – November 24, 2025 – TrustGraph announces the release of significant new capabilities and infrastructure improvements in release 1.5.8. The latest version introduces support for ontology-driven graph construction, dynamic embeddings model selection, MCP authentication support, and full Python 3.13 compatibility—alongside critical stability enhancements and workbench improvements.

Introducing Ontology-Driven Graph Construction
The centerpiece of this release is a new ontology-based extraction processor that fundamentally changes how organizations extract knowledge from unstructured data. Rather than relying on generic machine learning heuristics, TrustGraph can now leverage domain-specific ontology definitions to guide extraction logic, ensuring that the constructed knowledge graph aligns with business requirements and domain constraints.

"Most knowledge graph platforms ask what can we extract? TrustGraph now asks what should we extract?" said Mark Adams, Co-Founder of TrustGraph. "The ability to automatically build graphs with a specified ontology puts your data fully in control, dramatically reducing noise and ensuring consistency across distributed data exchange. This is what enterprise-grade knowledge graph infrastructure looks like - except TrustGraph builds it autonomously instead of needing a team of data engineers and 6 months."

Key benefits of Ontologies include:

• Precise Data Extraction: Define extraction rules once in your ontology configuration; apply them consistently across all extraction jobs

• Entity Context Preservation: Extract entity contexts alongside triple data for richer semantic understanding

• Workbench Integration: Seamlessly integrates with TrustGraph Workbench's ontology editor for visual rule definition

• Reduced Post-Processing: Dramatically cuts manual data cleaning and validation downstream

Enterprise-Ready Platform Updates
Beyond ontologies, TrustGraph's latest release brings several enterprise-critical improvements:

Infrastructure & Compatibility:

• Python 3.13 Support: Full compatibility with Python 3.13, including migration from cassandra-driver to scylla-driver for modern language support

• Vector Store Lifecycle Improvements: Fixed hard-coded vector size limitations; collections now initialize with proper support for variable embedding dimensions

• Dynamic Embeddings Model Selection: Users can now select embedding models dynamically, enabling optimization for specific use cases rather than one-size-fits-all approaches

Security & Integration:

• MCP Authentication: Added MCP (Model Context Protocol) authentication token header support, enabling secure integration with enterprise services and AI platforms

Stability & Reliability:

• Fixed batch deletion errors that occurred during large-scale collection operations

• Resolved agent step schema validation issues

• Improved OpenAI service compatibility for broader LLM integration

• Comprehensive test coverage for ontology extraction, dynamic embeddings, MCP authentication, and agent step parsing

Enhanced TrustGraph Workbench
The TrustGraph Workbench—the visual interface for designing, testing, and deploying knowledge graphs—also receives substantial improvements:

• LLM Model Selection UI: Users can now select from multiple LLM providers and models without leaving the workbench

• MCP Authentication Interface: Enterprise-grade authentication configuration now accessible through an intuitive UI

• Performance Optimization: System UI performance significantly improved across all workflows

• Multi-Ontology Support: Fixed critical issues with importing and managing multiple ontologies

• Crash Stability: Resolved flow class viewer crash that could interrupt design workflows

• Refactored Architecture: Library breakout and module reorganization improve maintainability and extensibility

Technical Excellence & Documentation
This release includes comprehensive technical specifications for ontologies and vector store lifecycle management, ensuring practitioners have the architectural context needed for production deployments. Full test coverage and updated documentation support enterprise adoption.

Availability
The latest version of TrustGraph is available immediately on GitHub. Comprehensive release notes, technical documentation, and migration guides are available here.

TrustGraph Community Resources

• Documentation: https://docs.trustgraph.ai/

• GitHub Repository: https://github.com/trustgraph-ai/trustgraph

• Configuration Builder: https://config-ui.demo.trustgraph.ai/

• Discord Community: https://discord.gg/sQMwkRz5GX

(original post courtesy of Qdrant here)

When teams first experiment with agentic AI, the journey often starts with a slick demo: a few APIs stitched together, a large language model answering questions, and just enough smoke and mirrors to impress stakeholders.

But as soon as those demos face enterprise requirements — constant data ingestion, compliance, thousands of users, and 24×7 uptime — the illusion breaks. Services stall at the first failure, query reliability plummets, and regulatory guardrails are nowhere to be found. What worked in a five-minute demo becomes impossible to maintain in production.

Failure mode map — “From POC to production.”

This is exactly the gap TrustGraph set out to close. From day one, they designed their platform for availability, determinism, and scale — with Qdrant as a core piece of the architecture.

Building for Production, Not Demos
TrustGraph’s architecture is fully containerized, modular, and deployable across cloud, virtualized, or bare-metal environments.

At its core are three pillars:

• A streaming spine with Apache Pulsar. Persistent queues, schema evolution, and replayability provide resilience. If a process fails, it automatically restarts and resumes without data loss.

• Graph-native semantics. Knowledge is modeled in Resource Description Framework (RDF), with SPARQL templates guiding retrieval. This reduces dependence on brittle, model-generated queries and ensures answers are precise and auditable.

• Qdrant vector search. Entities are embedded and stored in Qdrant, enabling fast, reliable similarity search that integrates into the graph-driven workflow.

Architecture overview

From Documents to Knowledge
Instead of breaking documents into chunks, TrustGraph extracts facts. An LLM identifies entities and relationships, assembling them into a knowledge graph. In parallel, embeddings of entities are stored in Qdrant.

This dual representation allows queries to ground themselves in both semantic similarity and graph structure. For example, asking “Tell me about Alice” retrieves the “Alice” entity via Qdrant and maps it to her connections in the graph, rather than just surfacing sentences that happen to contain her name.

Ingestion process

Retrieval That Goes Beyond RAG
When a query enters the system, it follows a deterministic path:

1. The query is embedded into vectors.

2. Qdrant retrieves the nearest entities.

3. Those entities expand into a subgraph of related facts.

4. The subgraph is passed to the LLM, which answers strictly from that curated context.

This approach surpasses traditional RAG, which stops at semantically similar chunks. Graph-anchored retrieval allows TrustGraph to surface causal or related knowledge. For example, “Why did the engine fail?” doesn’t just find mentions of “engine” and “failure” — it also uncovers related causes like metal fatigue or coolant leaks through graph connections.

Query process

Agentic AI at Scale
TrustGraph’s retrieval capabilities sit within a broader agentic AI framework. Developers can orchestrate pipelines that combine:

• GraphRAG for structured fact retrieval

• Template-driven queries for determinism

• MCP tool invocation for external actions

• NLPR - Natural Language Precision Retrieval (experimental), which uses ontologies to drive specialized extraction

This enables enterprises to build retrieval pipelines that integrate internal knowledge graphs with external data sources, while maintaining reliability and control.

Ingestion & querying process

Outcomes That Matter in Production
By combining a resilient streaming backbone, graph-native semantics, and Qdrant-powered retrieval, TrustGraph delivers production-grade architectural outcomes:

• Determinism — Template-driven SPARQL and Qdrant similarity search eliminate fragile query synthesis.

• Resilience — Pulsar pipelines replay and recover automatically, keeping systems responsive during failures or rolling updates.

• Scalability & Sovereignty — The platform runs on diverse hardware stacks, including non-NVIDIA GPUs, and supports strict European data sovereignty requirements.

• Developer Simplicity — Qdrant’s open-source, containerized design makes scaling straightforward and reduces operational friction.

“We haven’t had a reason to revisit alternatives. Qdrant checks the boxes for speed, reliability, and simplicity—and it keeps doing so.”
— Daniel Davis, Co-founder, TrustGraph

From Demos to Durable Infrastructure
TrustGraph shows how agentic AI can evolve from flashy demos into mission-critical enterprise software. By grounding retrieval in graph semantics and Qdrant’s vector engine, they push non-determinism to the edges while maintaining uptime, auditability, and sovereignty.

TrustGraph Community Resources

• Documentation: https://docs.trustgraph.ai/

• GitHub Repository: https://github.com/trustgraph-ai/trustgraph

• Configuration Builder: https://config-ui.demo.trustgraph.ai/

• Discord Community: https://discord.gg/sQMwkRz5GX

SAN FRANCISCO, CA – October 7, 2025 —TrustGraph, the pioneering open-source agentic AI platform built for enterprise demands, today announces the release of version 1.4.22, delivering groundbreaking advancements in flow configurability, structured data processing, and collection management. This major update empowers enterprises to achieve unprecedented flexibility and control over their AI workflows while maintaining the platform's hallmark transparency and scalability.

Transforming AI Workflow Management with Dynamic Flow Configuration
The centerpiece of version 1.4.22 introduces Flow Configurable Parameters, a revolutionary system that enables dynamic workflow configuration without requiring system rebuilds. This breakthrough allows enterprises to adapt their AI pipelines in real-time, adjusting Large Language Model (LLM) settings, temperature parameters, and processing configurations on-demand.

"Version 1.4.22 represents a fundamental shift toward truly dynamic AI infrastructure," said Daniel Davis, Co-Founder of TrustGraph. "Our new flow configuration system eliminates the traditional barriers between AI system design and operational deployment. Enterprises can now adapt their AI workflows as quickly as their business requirements change, without sacrificing the robust foundation they depend on for mission-critical operations."

The new flow parameter system introduces sophisticated Advanced Parameter Mode with controlled-by relationships, enabling complex interdependencies between workflow components. Organizations can now deploy LLM dynamic settings using llm-model and llm-rag-model parameters, while the new tg-show-parameter-types CLI tool provides comprehensive visibility into available configuration options.

Enhanced Intelligence Through Structured Data Diagnosis
Version 1.4.22 significantly expands TrustGraph's data processing capabilities with the introduction of the Structured Data Diagnosis Service. This powerful new component provides automatic detection and classification of XML, JSON, and CSV data formats, enabling TrustGraph's knowledge graph construction to work seamlessly across diverse enterprise data ecosystems.

The integrated Type Detector with schema selection capabilities ensures that structured data is properly understood and processed according to enterprise-specific requirements. This advancement bridges the gap between TrustGraph's renowned unstructured document processing and the structured data that forms the backbone of most enterprise operations.

Revolutionary Collection Management for Enterprise Scale
Addressing the complex requirements of large-scale enterprise deployments, version 1.4.22 introduces comprehensive Collection Management capabilities that provide granular control over data organization and access patterns. The enhanced system delivers Collection metadata management and deletion capabilities, integrated Librarian services, and sophisticated Collection tracking across all processors.

A critical advancement for enterprise security and compliance, the new User/Collection Isolation feature provides User/Collection Separation and User/Collection Processing, ensuring that sensitive data remains properly segregated across different organizational contexts and access levels.

Mark Adams, Co-Founder of TrustGraph, emphasized the significance of these enhancements: "Enterprise AI requires enterprise-grade data management. Our enhanced collection management system provides the governance and isolation capabilities that large organizations need while maintaining the flexibility that makes TrustGraph so powerful for innovation."

Performance Optimizations and Infrastructure Enhancements
Version 1.4.22 delivers substantial performance improvements across the platform's core infrastructure. The Cassandra Performance enhancements include a refactored knowledge graph implementation optimized for single-table operations, multi-table implementation for enhanced performance, and the addition of a dedicated Cassandra collection table.

GraphRAG Optimizations have been implemented throughout the system, providing faster query processing and more efficient relationship traversal. The Vector Store Enhancements now include automatic collection creation on query, streamlining deployment and reducing operational overhead.

The platform's robust Apache Pulsar foundation receives additional strengthening through Build System improvements that enable parallel container builds, significantly reducing deployment times for large-scale enterprise implementations.

About TrustGraph's Enterprise Mission
Since its release in 2024, TrustGraph has emerged as the definitive open-source platform for enterprise agentic AI, combining data streaming with knowledge graphs, structured data, VectorDBs, and MCP interoperability in a single containerized platform. TrustGraph’s mission centers on providing enterprises with reduced hallucinations and higher accuracy by grounding AI with contextually rich intelligence built from enterprise data.

TrustGraph's commitment to full stack sovereignty enables organizations to deploy the entire platform—including sensitive Knowledge Cores—wherever they choose: on-premises, private cloud, public cloud, or bare metal infrastructure. This approach ensures enterprises maintain ultimate control over their data and AI stack while escaping the "black box" limitations of proprietary systems.

Availability and Getting Started
TrustGraph version 1.4.22 is immediately available through the project's GitHub repository and comprehensive documentation portal. The platform's Configuration Builder provides guided setup for enterprise deployments, while the Workbench offers interactive development capabilities for AI engineers and data scientists.

Community Resources
- Documentation: https://docs.trustgraph.ai/
- GitHub Repository: https://github.com/trustgraph-ai/trustgraph
- Configuration Builder: https://config-ui.demo.trustgraph.ai/
- Discord Community: https://discord.gg/sQMwkRz5GX

SAN FRANCISCO, CA – September 23, 2025 — TrustGraph today announces the release of version 1.3.20, a significant update that revolutionizes how users interact with structured data through natural language processing capabilities. This release marks a major milestone in making complex database operations accessible through conversational interfaces.

Revolutionary Natural Language Database Querying

The standout feature of TrustGraph 1.3.20 is its breakthrough NLP query to GraphQL service, enabling users to query databases using natural language instead of complex query syntax. This innovation democratizes data access by allowing technical and non-technical users alike to retrieve information through simple, conversational commands.

"This release represents a fundamental shift in how organizations can interact with their data," said Daniel Davis, the Co-Founder of TrustGraph. "By bridging the gap between human language and database queries, we're making structured data truly accessible to everyone."

Comprehensive Structured Data Enhancements

Version 1.3.20 introduces a complete overhaul of structured data handling capabilities:

• Structured Query Tool Integration: Seamlessly integrates with the agent platform for intelligent query processing

• Advanced Object Batching: Optimizes performance through enhanced batch processing capabilities

• Automated Data Loading: New CLI functionality with auto mode streamlines data import workflows

• Batch Import Operations: Efficiently handles large-scale object imports with intelligent batching

Intelligent Collection Management

The new release features sophisticated collection management that adapts to user behavior:

• Automatic Collection Creation: Stores dynamically create collections during query operations

• Extended User Integration: User and collection fields are now utilized consistently throughout the entire system

Enhanced Organization and Performance

TrustGraph 1.3.20 introduces tool grouping functionality, allowing users to organize and manage their tools more effectively. The release also includes substantial GraphQL enhancements, including expanded table query support and streamlined parameter handling.

Infrastructure and Reliability Improvements

This version delivers significant infrastructure improvements:

• Unified Configuration: Standardized Cassandra configuration across all utilities ensures consistent connectivity and authentication

• Enhanced Monitoring: Improved Prometheus metrics provide accurate system monitoring and performance insights

• Robust Vector Operations: Resolved Milvus vector store integration issues for improved reliability

• Streamlined API Operations: Enhanced API consistency eliminates confusion between chunks and documents

Availability and Compatibility

TrustGraph 1.3.20 is available immediately for download. The release maintains full backward compatibility while introducing powerful new capabilities that enhance both user experience and system performance.

About TrustGraph

TrustGraph is a leading platform for intelligent data management and querying, enabling organizations to unlock insights from their structured and unstructured data through advanced AI-powered tools and natural language interfaces.

• 🌟 TrustGraph on GitHub

• Join the TrustGraph Community on Discord

• Watch TrustGraph tutorials on YouTube

(Original Post courtesy of StreamNative)

‍Introduction: The Challenge of Building an AI Platform

Late one afternoon, a team of developers set out to build TrustGraph – an open-source AI product creation platform aimed at orchestrating sophisticated AI agents. They faced a familiar challenge: how to connect a constellation of microservices (knowledge extractors, vector indexers, agent runtimes, etc.) into one cohesive system that can scale and adapt dynamically. Traditional point-to-point integrations felt brittle and hard to scale. The team needed a nervous system for their platform – a messaging backbone that could seamlessly link all components in real-time. Enter Apache Pulsar, the technology that would become the high-performance core of TrustGraph’s event-driven architecture. Pulsar (with enterprise support from StreamNative) offered exactly what TrustGraph needed: a reliable publish/subscribe foundation with the flexibility to handle everything from real-time agent queries to large-scale data ingestion. What follows is the story of how Pulsar powers TrustGraph, enabling developers to build modular AI systems that are scalable, resilient, and a joy to work with.

Why TrustGraph Chose Pulsar as its Backbone

From the outset, the TrustGraph engineers recognized that building a scalable AI platform meant embracing event-driven design. They needed a messaging layer that could support diverse workloads – from synchronous API calls to asynchronous data pipelines – without becoming a bottleneck. Apache Pulsar stood out for several reasons:

• It “just works” for ops: Pulsar provides an operations-friendly way to connect complex processing elements. Its simplicity in managing communication patterns and scaling freed the team from writing custom pipeline glue code. Site reliability engineers could focus on deploying and monitoring AI capabilities rather than debugging message passing.

• Native Pub/Sub Model: Pulsar’s publish-subscribe architecture was a perfect fit for TrustGraph’s decoupled microservices. Components like the Knowledge Graph Builder, AI Agent Runtime, and data processors communicate by publishing events and subscribing to the topics they care about – no direct dependencies needed. This decoupling means each service can evolve or scale independently, a critical requirement for a modular AI platform.

• Persistent and Non-Persistent Topics: Pulsar uniquely lets you choose between persistent and non-persistent messaging. TrustGraph leverages this to balance reliability vs. latency. For critical data (e.g. ingesting documents into a knowledge base), TrustGraph uses persistent topics to guarantee delivery – ensuring no data is lost even if a service goes down. Conversely, for high-speed, ephemeral interactions (like an AI agent responding to a user query), TrustGraph uses non-persistent topics to minimize overhead and latency. This flexible messaging guarantees that each use-case gets the right trade-off between speed and safety.

• Multi-Tenancy and Isolation: Pulsar’s built-in multi-tenancy (via tenants and namespaces) proved invaluable for TrustGraph’s vision of dynamic “Flows.” A Flow in TrustGraph is essentially an isolated AI pipeline or workspace. Pulsar’s tenant/namespace model allows TrustGraph to create isolated channels for each Flow, ensuring that projects or tenants don’t interfere with each other’s data streams. This strong isolation was critical for enabling TrustGraph to support multiple concurrent AI agent workflows in one cluster, whether they belong to different teams, customers, or use cases.

In summary, Pulsar provided the scalability, flexibility, and reliability that TrustGraph needed in a messaging backbone. As Mark Adams, Co-founder of TrustGraph, put it, building on Pulsar gave them confidence that the communication layer would not be the limiting factor in scaling intelligent agents. It laid a rock-solid foundation on which to construct an AI platform ready for both rapid iteration and production-grade stability.

Architecting TrustGraph with Pulsar: Key Patterns

With Apache Pulsar at its core, TrustGraph’s architecture evolved a set of powerful patterns. These patterns illustrate how Pulsar’s features are used in practice to create an event-driven, modular AI system:

1. Dynamic and Scalable “Flows”: In TrustGraph, a Flow represents a configurable pipeline of AI tasks (for example, a data ingestion flow or an agent reasoning flow). Some services are global (shared across all Flows), while others are flow-specific. Pulsar enables this dynamic behavior through dynamic queue naming and creation.
   

   • Global Services (like configuration, knowledge base, and librarian APIs) listen on well-known, fixed Pulsar topics since they are always available and shared.

   • Flow-Hosted Services (like a GraphRAG processor, Agent runtime, or custom embeddings service) spin up when a new Flow is started. TrustGraph automatically generates unique Pulsar topics for that Flow’s services. For example, if a Flow is named research-flow, the GraphRAG service in that flow might publish/subscribe on topics named:
     

     • non-persistent://tg/request/graph-rag:research-flow

     • non-persistent://tg/response/graph-rag:research-flow
       Each new Flow gets its own set of topics, isolating its traffic. Multiple Flows can run concurrently without stepping on each other’s messages – a huge win for multi-project and multi-tenant deployments. When the Flow is stopped, its topics can be torn down just as easily. This dynamic provisioning of queues means the platform can scale out new pipelines on the fly with full isolation, all thanks to Pulsar’s flexible naming and multi-tenancy.

2. Diverse Communication Patterns (Pub/Sub Flexibility): TrustGraph doesn’t force a one-size-fits-all messaging style; instead, it uses Pulsar to support different interaction patterns within the platform:
   

   • Request/Response Messaging: For interactive services—such as an AI Agent API or the GraphRAG query service—TrustGraph sets up dedicated request and response topics. For example, when a user’s query hits the Agent service, it is published to a request topic, the agent processes it, and the answer comes back on a response topic tied to that user’s session or flow. This pub/sub request-response pattern feels like a direct call from the client’s perspective, but under the hood it’s decoupled and asynchronous. The client can await a response without knowing which specific service instance will handle it. This pattern gives synchronous behavior on top of asynchronous internals, combining interactivity with scalability.

   • Fire-and-Forget Ingestion: For one-way data pipelines like ingesting documents, TrustGraph uses a simpler fire-and-forget approach. A client (say, a data loader component or a user uploading a file) will publish data to an ingestion topic and immediately move on. Downstream processor services (e.g. a Text Load service or a Triples Store loader) are subscribed and will process the data in due course. Crucially, these ingestion topics are persistent in Pulsar. This guarantees that if a processor is slow or temporarily down, the data remains in the queue until processed, ensuring no loss. Developers benefit by not having to babysit the pipeline – they trust Pulsar to eventually deliver data when the consumers are ready, improving the system’s resilience to spikes or faults.

3. Centralized, Push-Based Configuration: Running a complex AI platform means lots of configuration: prompts for the LLM, tool definitions for agents, pipeline parameters, etc. TrustGraph chose to manage configuration changes through Pulsar as well, turning config into an event stream. There is a dedicated Pulsar topic (e.g. persistent://tg/config/config) that acts as a central config channel. Whenever an administrator or developer updates a configuration – for instance, adjusting a prompt template or adding a new tool plugin – that update is published as a message on the config topic. All services that care about config subscribe to this channel. TrustGraph’s services (built on common base classes FlowProcessor or AsyncProcessor) are designed to receive these config events and reconfigure themselves on the fly. The moment a new Flow is launched or a parameter changes, every component gets the memo via Pulsar and updates its behavior without needing a restart. This push-based config distribution makes the platform highly dynamic – developers can deploy new capabilities or tune the system in real-time, and Pulsar ensures a consistent configuration state across the distributed system.

These patterns highlight a theme: Pulsar decouples parts of the system while keeping them coordinated. Dynamic topic creation lets TrustGraph scale out new processing flows easily. Multiple messaging patterns let each service communicate in the style that fits its role. A config event stream keeps everything in sync. All of it is implemented on Pulsar’s robust pub/sub substrate, meaning it inherits Pulsar’s strengths like horizontal scalability, durability, and back-pressure handling.

Benefits to Developers and AI Teams

By weaving Pulsar so deeply into its design, TrustGraph reaps numerous benefits that directly address pain points developers often face in building AI systems:

• Easier Scaling: Need to handle more load? Simply add more consumers to a Pulsar topic to scale out a microservice – no complex rebalancing needed. Because each TrustGraph component processes messages from a queue, scaling is as straightforward as running another instance that subscribes to the same topic. For example, if the AI Agent requests spike, the team can spin up additional agent service containers; Pulsar will automatically distribute requests among them. This elasticity means the system can handle varying workloads on different parts of the AI pipeline without a hitch.

• Resilience and Fault Tolerance: Pulsar’s persistent messaging ensures critical data isn’t lost if something fails. Developers don’t have to write custom retry logic or worry about data gaps – if the Knowledge Graph builder goes down for a bit, all pending documents remain queued. When it comes back up, it picks up where it left off. Also, thanks to the decoupled design, a failure in one component (e.g., the vector embedding service) won’t crash the entire platform. Messages will queue up until that service recovers, while the rest of the system continues unaffected. This isolation containing failures makes the overall platform more robust in production.

• Flexibility for New Features: The dynamic Flow architecture allows teams to deploy new pipelines or custom components without modifying the core system. Because Pulsar handles the routing, a new service can be introduced by simply defining the topics it will use and plugging it in. This pluggable architecture means TrustGraph can evolve quickly. For instance, a developer could add a new “Sentiment Analysis” microservice into a Flow by having it subscribe to an intermediate topic – no need for a full redeploy or breaking existing flows. Pulsar’s multi-tenant setup means this can happen in an isolated way, so experimentation in one Flow won’t disrupt others.

• Better Observability: With Pulsar as the central hub for all messages, it provides a one-stop view into the system’s activity. TrustGraph takes advantage of Pulsar’s metrics – like message rates, consumer backlogs, throughput, and latency per topic – to give developers deep insight into how each part of the platform is performing. These metrics feed into Grafana dashboards where the team can see, for example, if the “ingestion queue” is backing up or if the “response times on the agent request topic” are rising. Such observability helps pinpoint bottlenecks quickly (maybe a vector DB is slow, causing a backlog) and aids in capacity planning. It essentially turns Pulsar into a stethoscope on the health of the AI platform.

• Faster Iteration: Perhaps most importantly, this Pulsar-driven architecture empowers faster development cycles. Because adding new flows or services is low-friction, developers can prototype new AI capabilities without weeks of pipeline engineering. The combination of fewer bottlenecks, auto-scaling behavior, safe fault handling, and real-time config updates means the team spends less time on infrastructure and more on innovating AI features. In practice, that could mean quickly trying a new large language model in the Agent service or connecting an experimental knowledge source – TrustGraph will handle the messaging and integration details, so the developer can focus on the AI logic.

All these benefits fundamentally spring from Pulsar’s role as a unified messaging layer. It abstracts away the hard parts of distributed communication (scaling, reliability, ordering, isolation), letting developers concentrate on building intelligent agents and knowledge pipelines.

Pulsar in Action: A Day in the Life with TrustGraph

To cement how Pulsar powers real-world usage of TrustGraph, let’s walk through a hypothetical scenario:

Meet Alice, an AI engineer at an enterprise, who is using TrustGraph to build a new AI-powered research assistant. She begins her day by defining a new processing Flow for the project, aptly named research-flow. When Alice starts this Flow via TrustGraph’s CLI, under the hood the platform spins up microservices for that Flow – an Agent service, a GraphRAG service, an Embeddings service, etc. – each with their own Pulsar topics. Alice doesn’t have to manually configure any queues; Pulsar automatically provisions topics like tg/request/graph-rag:research-flow and tg/response/graph-rag:research-flow for her new Flow. Immediately, her Flow’s services begin running in isolation. In fact, a colleague can launch a separate analysis-flow in parallel, and thanks to Pulsar, the two sets of services won’t conflict. This allows different teams to use TrustGraph on the same infrastructure, each with their own dedicated message streams.

Later that morning, Alice feeds a batch of documents (PDF reports) into TrustGraph for ingestion. As she uploads them via the Workbench UI, each document’s content is published as a message to the Text Load service’s Pulsar topic. The ingestion is designed as fire-and-forget – the upload request immediately returns, and Alice can go grab a coffee while TrustGraph pipelines the data. Pulsar’s persistent queue means even if the Text Load processor or downstream Knowledge Graph builder is busy, all documents will be queued reliably. After a brief break, Alice checks the dashboard: the documents are being processed one by one, and there are no errors. One of the processing containers did restart (maybe due to a transient error), but because of Pulsar, no data was lost and the pipeline resumed automatically once the service recovered. Alice silently thanks the decision to use Pulsar; in past projects with DIY messaging, a crash often meant writing custom retry logic or manual data cleanup, but not anymore.

In the afternoon, Alice decides to improve the AI agent’s behavior by tweaking its prompt and adding a new tool for it. She opens TrustGraph’s configuration UI and updates the prompt template and registers an external API as a new tool. The moment she hits “Save”, TrustGraph’s Config service publishes an update event to tg/config/config topic. All running services in research-flow receive this update within milliseconds, thanks to their Pulsar subscriptions. The Agent runtime immediately pulls in the new prompt and tool definitions – there’s no need to restart anything. Alice initiates a test query to her agent; it responds using the updated prompt format and can even call the new API tool as needed, all in real-time. This kind of live reconfiguration makes it incredibly easy for Alice to iterate on her AI agent’s capabilities. In traditional setups, such changes might require editing config files on multiple servers or restarting processes, disrupting the workflow. With Pulsar’s event-driven config, TrustGraph achieves seamless, centralized control.

Before wrapping up, Alice reviews the system’s performance. Using TrustGraph’s observability stack, she notices the message backlog on the research-flow ingestion topic grew slightly during peak load, but then drained as additional consumers auto-scaled. The Grafana metrics (sourced from Pulsar) show healthy throughput. One insight stands out: the response queue for the Agent service shows occasional latency spikes. Investigating further, Alice realizes that complex user questions trigger multiple knowledge searches, slowing responses. She decides to allocate another instance of the GraphRAG service to that Flow to handle these heavy queries. Thanks to Pulsar, scaling out is straightforward – the new instance will simply become another consumer on the relevant topics. Sure enough, once deployed, the next test query is handled faster, as the load is now balanced. The bottleneck was resolved by a one-line configuration change to scale the service, without any code changes or downtime. This agility in tuning performance is a direct consequence of the Pulsar-based design.

By the end of the day, Alice has not only built a functioning AI research assistant, but she’s also iterated on it multiple times – all without struggling with messaging middleware. TrustGraph, empowered by Pulsar, took care of the heavy lifting: routing messages, preserving data, triggering reconfigurations, and scaling services on demand. For Alice, the developer experience is night-and-day compared to earlier projects. She can focus on crafting AI logic, confident that the event-driven backbone (powered by Pulsar and StreamNative’s expertise) will handle the rest.

Conclusion: Pulsar as the Foundation for Event-Driven AI

The story of TrustGraph underscores a broader lesson for AI platform developers: a robust messaging backbone is the key to unlocking scalable, modular, event-driven systems. Apache Pulsar proved to be that backbone for TrustGraph – acting as the central nervous system that links independent AI modules into one intelligent whole. Its pub/sub model, dynamic queue management, multi-tenancy, and mix of persistent vs. transient messaging enabled TrustGraph to achieve a level of flexibility and resilience that would be hard to realize otherwise. By using Pulsar, the TrustGraph team and its users gained scalability, fault tolerance, and speed of iteration as first-class features of the architecture. Developers can add new capabilities without fear of breaking the system, ops engineers can sleep easier knowing spikes or failures won’t collapse the pipeline, and organizations can deploy multiple AI agent flows concurrently with confidence in their isolation and security.

In essence, Pulsar (with StreamNative’s enterprise support in the wings) serves as the foundation for TrustGraph’s vision of an AI platform. It demonstrates how an advanced event streaming technology can solve the pain points of building AI products: eliminating brittle point-to-point links, preventing data loss, simplifying scaling, and improving observability. For any team looking to build the next generation of AI systems – be it autonomous agents, real-time analytics, or context-driven LLM applications – the combination of TrustGraph’s modular framework and Pulsar’s event-driven backbone offers a compelling blueprint. Pulsar enabled TrustGraph to transform from an ambitious idea into a production-grade reality, reinforcing its role as a foundational enabler for event-driven AI platforms. The result is a story of technology empowering developers: with Apache Pulsar under the hood, TrustGraph can truly deliver on its promise of creating intelligent, context-aware AI agents at scale.

• 🌟 TrustGraph on GitHub

• Join the TrustGraph Community on Discord

• Watch TrustGraph tutorials on YouTube

• Learn more about Apache Pulsar

• Learn more about the creators of Pulsar - StreamNative

The cloud computing landscape has long been dominated by the "Big Three" hyperscalers—AWS, Microsoft Azure, and Google Cloud Platform. Their massive infrastructure investments and AI service portfolios have created seemingly insurmountable barriers for smaller cloud providers. But a new paradigm is emerging that could fundamentally reshape this dynamic, and it's powered by an unlikely catalyst: enterprise demand for AI sovereignty.

Enter TrustGraph, the open-source agentic AI platform that's opening unprecedented opportunities for NeoClouds—the emerging generation of specialized, agile cloud providers—to compete directly with hyperscale giants on AI capabilities while offering something the big players fundamentally cannot: true data sovereignty and freedom from vendor lock-in.

The Hyperscaler AI Trap

The current AI landscape presents enterprises with a troubling dilemma. While hyperscalers offer impressive AI services, they come with significant drawbacks that forward-thinking organizations are increasingly unwilling to accept:

Proprietary Black Boxes: Enterprise data flows into opaque systems where organizations lose visibility into how their information is processed, stored, and utilized. This lack of transparency creates compliance nightmares and erodes trust.

Vendor Lock-in: Once committed to a hyperscaler's AI ecosystem, organizations face astronomical switching costs and technical dependencies that make migration nearly impossible.

Data Sovereignty Concerns: In an era of increasing regulatory scrutiny and geopolitical tensions, many organizations cannot afford to have their most sensitive data processed on infrastructure they don't control.

One-Size-Fits-All Limitations: Hyperscaler AI services are designed for mass consumption, often lacking the customization and specialized industry knowledge that enterprises require.

The NeoCloud Opportunity

This is where NeoClouds—agile, specialized cloud providers focused on specific verticals, regions, or technical capabilities—see their opening. Unlike hyperscalers, NeoClouds can offer:

• Intimate Customer Relationships: Direct access to decision-makers and custom solutions

• Specialized Expertise: Deep domain knowledge in specific industries or technologies

• Regulatory Compliance: Local data residency and industry-specific compliance frameworks

• Flexible Pricing: Competitive, transparent pricing without complex enterprise licensing schemes

• Rapid Innovation: Ability to quickly adopt and integrate cutting-edge technologies

The challenge has always been matching the technical sophistication of hyperscaler AI services. Until now.

TrustGraph: The Great Equalizer

TrustGraph represents a paradigm shift that suddenly makes advanced AI capabilities accessible to any infrastructure provider, regardless of size. Here's how it transforms the competitive landscape:

Complete Technical Parity

TrustGraph delivers enterprise-grade AI capabilities that match or exceed what hyperscalers offer for enterprise AI transformation:

• Advanced Context Engineering: Sophisticated knowledge graph construction and agentic retrieval systems that often outperform hyperscaler RAG implementations

• Full LLM Control: Deploy and manage open LLMs where you have full control paying only for the compute and maintaining total data residency

• Production-Ready Orchestration: Full agent lifecycle management with observability and monitoring

• Scalable Architecture: Enterprise-grade performance across diverse computing environments

The Sovereignty Advantage

What makes TrustGraph revolutionary is that NeoClouds can now offer something hyperscalers fundamentally cannot:

Complete Data Sovereignty: Organizations maintain total control over their data, processing pipelines, and AI models. Every component runs on infrastructure they choose and control.

Open Source Transparency: Unlike hyperscaler black boxes, every aspect of the AI pipeline is visible, auditable, and modifiable. Organizations can see exactly how their data is processed and used.

Portable Knowledge Assets: TrustGraph's revolutionary "Knowledge Cores" create truly portable AI knowledge packages that prevent vendor lock-in while enabling rapid deployment across different environments.

Universal Deployment Flexibility: The same TrustGraph deployment works consistently across any infrastructure—from bare metal to public cloud to hybrid environments.

Economic Disruption

TrustGraph enables NeoClouds to compete on economics in ways previously impossible:

Transparent Cost Structure: Built-in economic observability provides real-time cost monitoring, eliminating the surprise billing that plagues hyperscaler relationships.

Efficient Resource Utilization: Local deployment and optimization capabilities often result in better price-performance ratios than hyperscaler services.

No AI Tax: Organizations avoid the premium pricing inherent in hyperscaler AI services, paying only for compute resources and platform licensing.

Strategic Implications for NeoClouds

The emergence of TrustGraph creates several strategic opportunities for NeoClouds:

1. Industry Vertical Specialization

NeoClouds can combine TrustGraph's technical capabilities with deep industry expertise to create compelling specialized offerings:

• Healthcare NeoClouds can offer HIPAA-compliant AI with medical knowledge graphs

• Financial Services providers can deliver regulatory-compliant AI with specialized financial reasoning

• Manufacturing specialists can integrate IoT data with AI for predictive maintenance and quality control

• Legal tech providers can offer secure document analysis with legal reasoning capabilities

2. Geographic and Regulatory Advantages

TrustGraph enables NeoClouds to compete on regulatory compliance and data residency:

• Regional providers can offer local data residency with global AI capabilities

• Compliance specialists can provide industry-specific regulatory frameworks

• Sovereign cloud providers can deliver national security-grade AI sovereignty

3. Custom AI Solutions

Unlike hyperscalers' standardized offerings, NeoClouds can provide deeply customized AI implementations:

• Bespoke Knowledge Graphs tailored to specific organizational structures

• Custom Agent Frameworks designed for unique business processes

• Specialized Model Integration including private, fine-tuned models

• Industry-Specific Tooling through MCP integration and custom agent tools

4. Innovation Velocity

TrustGraph's open architecture allows NeoClouds to innovate faster than hyperscalers:

• Rapid Feature Integration: Direct access to cutting-edge AI research and tools

• Customer-Driven Development: Ability to quickly implement customer-specific requirements

• Ecosystem Partnerships: Integration with specialized AI tools and services

The Competitive Response

This shift won't go unnoticed by hyperscalers, but their response options are limited:

They can't match sovereignty: Hyperscalers' business models fundamentally depend on data aggregation and vendor lock-in. Offering true sovereignty would cannibalize their core revenue streams.

They can't match agility: Large organizations inherently move slower than specialized NeoClouds in responding to customer needs and market changes.

They can't match specialization: Hyperscalers optimize for breadth and scale, not the depth of expertise that NeoClouds can provide in specific verticals.

The Path Forward

For NeoClouds ready to seize this opportunity, the path is clear:

1. Embrace TrustGraph Early: First-mover advantage in implementing and optimizing TrustGraph deployments

2. Develop Vertical Expertise: Combine TrustGraph's technical capabilities with deep industry knowledge

3. Build Compliance Frameworks: Develop regulatory and security frameworks that hyperscalers can't match

4. Invest in Customer Success: Leverage the intimate customer relationships that are NeoClouds' natural advantage

5. Create Knowledge Core Libraries: Build reusable, industry-specific Knowledge Cores that provide ongoing competitive advantages

Conclusion: A New Era of Competition

TrustGraph represents more than just another AI platform—it's a fundamental shift in how AI capabilities are delivered and controlled. By democratizing access to sophisticated AI technology while prioritizing sovereignty and transparency, TrustGraph enables NeoClouds to compete not just on price or service, but on the fundamental values that enterprises increasingly demand: control, transparency, and freedom.

The hyperscaler era was built on the assumption that only massive scale could deliver advanced capabilities. TrustGraph shatters that assumption, creating a new competitive landscape where agility, specialization, and customer intimacy matter more than raw scale.

For NeoClouds willing to embrace this opportunity, the message is clear: the AI playing field has been leveled. The question isn't whether you can compete with the hyperscalers—it's whether you're ready to surpass them.

The revolution in enterprise AI isn't just about better technology—it's about better business relationships, better economics, and better control. And for the first time in the cloud computing era, the advantage belongs to the agile, the specialized, and the customer-focused.

Welcome to the NeoCloud era. The giants should be worried.

We’re excited to share that TrustGraph is a Community Sponsor of the upcoming Data Streaming Summit San Francisco, taking place September 29–30, 2025 at the Grand Hyatt SFO!

Apache Pulsar is the backbone of TrustGraph, enabling enterprise ready AI solutions. Check out how TrustGraph leverages the power of Pulsar below. 👇️ 

This two-day event is the must-attend gathering for data streaming professionals — packed with hands-on technical training, a live hackathon, and a full day of inspiring talks from industry leaders.

📅 September 29 – Workshops and hands-on training.

📅 September 30 – Full-day summit with expert speakers

Don’t miss your chance to connect with engineers, architects, and innovators shaping the future of real-time data.

👉 Register Now for DSS San Francisco

Hope to see you there!

• 🌟 TrustGraph on GitHub

• Join the TrustGraph Community on Discord

• Watch TrustGraph tutorials on YouTube 

SAN FRANCISCO, CA – TrustGraph, the open-source scale platform for enterprise AI, today announced the release of version 1.1, a milestone update that significantly advances the capabilities of its AI agents. The new version introduces full support for the Model Context Protocol (MCP), an open standard that allows TrustGraph agents to connect with and utilize external tools, transforming them from passive knowledge retrievers into active, task-oriented systems.

This pivotal update enables AI agents built on TrustGraph to perform complex, multi-step workflows that combine deep contextual understanding from enterprise knowledge graphs with real-time data and actions from external services. With MCP, developers can easily extend their agents with custom tools, allowing them to perform tasks like fetching dynamic information or interacting with any external API.

“This isn't just an integration; it's a new architectural standard for enterprise AI. Our LLM-enhanced knowledge graphs act as the platform’s intelligent brain, and through MCP, we've given it hands to interact with the world. The crucial link is our rock-solid data engineering foundation built on Pulsar, which acts as the nervous system. With fully automated configuration and deployment, we can deliver this entire, cohesive capability seamlessly and at scale.” said Mark Adams, CoFounder of TrustGraph. 

TrustGraph’s core strength lies in its ability to build interconnected Knowledge Graphs from fragmented enterprise data, grounding AI responses and dramatically reducing hallucinations. With the integration of MCP, agents can now leverage this robust internal context to make more intelligent decisions when using external tools. For example, an agent can now answer a complex query like, "Given the surveillance capabilities described in our research documents and my current bank balance, what privacy measures could I afford?" by seamlessly querying both its internal knowledge graph and an external MCP tool for financial data.

Key features in TrustGraph v1.1 include:

• Full Model Context Protocol (MCP) Integration: Easily connect TrustGraph agents to any MCP-compliant tool or service, enabling interaction with external APIs, databases, and systems.

• Advanced Agentic Workflows: Build sophisticated agents that can analyze a user's request, select the appropriate combination of internal knowledge and external tools, and synthesize the information to provide a comprehensive answer or complete a task.

• Seamless Knowledge Graph and Tool Synergy: Agents can now fluidly combine facts and relationships from their internal knowledge graph with real-time data from external tools, leading to more accurate and contextually-aware outcomes.

• Open Standard for Custom Tools: Empower developers to create and integrate their own custom tools using the open MCP standard, ensuring flexibility and preventing vendor lock-in.

The new capabilities are available immediately and are detailed in the new MCP Integration guide in the TrustGraph documentation.

Availability
TrustGraph v1.1 is available now. Developers can access the code, deployment guides, and documentation on the official website and GitHub repository.

• Documentation: https://docs.trustgraph.ai/

• MCP Integration Guide: https://docs.trustgraph.ai/guides/mcp-integration/

• GitHub: https://github.com/trustgraph-ai/trustgraph

TrustGraph for Enterprise
For organizations moving AI from experiment to enterprise-wide adoption, TrustGraph will offer a suite of commercial solutions focused on advanced governance, security, and operational management. These offerings are designed to provide the robust controls and dedicated support that mission-critical, large-scale AI deployments demand. Contact sales@trustgraph.ai about our enterprise preview program.

About TrustGraph
TrustGraph is an Open Source Scale Platform for Enterprise AI that helps organizations build, deploy, and manage sophisticated AI agents with deep contextual understanding. By creating interconnected Knowledge Graphs from enterprise data, TrustGraph enables agents to understand relationships and context, significantly reducing AI hallucinations and providing radical transparency in how AI systems process information. With a commitment to open standards and modular architecture, TrustGraph empowers organizations to build trustworthy and powerful AI solutions.

Contact:
marketing@trustgraph.ai
https://trustgraph.ai
https://github.com/trustgraph-ai/trustgraph

San Francisco, CA – July 8, 2025 – TrustGraph, the open-source platform for sovereign AI, today announced the landmark release of TrustGraph Version 1.0. This release transforms the platform into a Sovereign Universal AI Adapter, empowering enterprises to adapt to the relentless pace of AI innovation while maintaining absolute control over their technology stack and proprietary knowledge. Version 1.0 delivers dynamic, enterprise-ready capabilities designed to eliminate AI vendor lock-in and provide a future-proof foundation for intelligent systems.

In today's chaotic AI landscape, businesses face a critical dilemma: risk falling behind or sacrifice control to opaque, third-party platforms. TrustGraph 1.0 solves this by providing a stable, sovereign core that intelligently interfaces with any AI technology, giving organizations the power to innovate without compromise.

"Our mission is to earn trust in AI through radical transparency, and Version 1.0 embodies that mission by giving enterprises true sovereignty over their AI destiny," said TrustGraph Co-Founder Daniel Davis. "We’ve designed TrustGraph to be the universal adapter that lets businesses plug into the latest AI advancements on their own terms. This release is about providing the dynamic agility needed to adapt, without sacrificing the foundational control required for secure, long-term enterprise value."

Key capabilities in TrustGraph Version 1.0 that deliver on the promise of a Sovereign Universal AI Adapter include:

• Dynamic Flows for Ultimate Modularity: A revolutionary approach to data processing. "Flows" enable the dynamic start and stop of logical data streams, allowing enterprises to easily plug in third-party processing elements and build custom, configurable workflows on the fly. This is core to the "adapter" concept, making the platform exceptionally extensible.

• Live, Dynamic Configuration: The platform can now be reconfigured in real-time without restarts. Enterprises can instantly adapt their AI's behavior by changing LLM prompts, swapping agent tools, and modifying configurations dynamically, ensuring their AI stack can evolve at the speed of their business needs.

• Portable Knowledge Packages for Sovereign IP: Knowledge Packages—TrustGraph's structured knowledge artifacts—are now fully portable. New workflows allow users to save a Knowledge Package, download it for secure offline storage or transfer, and upload it to any TrustGraph instance globally, and even remove it when not needed. This capability makes enterprise knowledge a truly sovereign, portable asset, free from platform or infrastructure lock-in.

• The Librarian & Workbench: A Control Plane for Your Knowledge: The new Librarian workflow provides granular control over knowledge ingestion, while the new Workbench UX serves as the central command center. This intuitive interface allows users to manage everything from dynamic Flows to the download/upload of sovereign Knowledge Packages, providing a comprehensive control plane for their entire AI ecosystem.

With TrustGraph 1.0, enterprises can confidently build their AI strategy on a sovereign foundation. The platform's deploy-anywhere architecture continues to support any infrastructure—from on-premises and bare-metal servers to any private or public cloud—providing Total Stack Sovereignty.

Availability
TrustGraph Version 1.0 is available immediately under the Apache 2.0 license. To get started, visit the official GitHub repository.

TrustGraph for Enterprise
For organizations moving AI from experiment to enterprise-wide adoption, TrustGraph will offer a suite of commercial solutions focused on advanced governance, security, and operational management. These offerings are designed to provide the robust controls and dedicated support that mission-critical, large-scale AI deployments demand. Contact sales@trustgraph.ai about our enterprise preview program.

About TrustGraph
TrustGraph is an open-source AI platform that functions as a Sovereign Universal AI Adapter. We empower enterprises to build, deploy, and manage trustworthy AI systems by providing a stable, transparent foundation that can adapt to any AI technology while ensuring complete control over data, deployments, and an organization's AI future.

Contact:
info@trustgraph.ai
https://trustgraph.ai
https://github.com/trustgraph-ai/trustgraph

At TrustGraph, we’ve been using VertexAI going all the way back to the PaLM2 days. Up until recently, VertexAI had been a high throughput API for using Google’s latest and greatest LLMs. But enter 429 errors. We assumed that we needed to increase our quotas or rate limits - that’s what you’d do for almost all other cloud services. We assumed wrong.

We recently discovered that Google is taking a different approach to how they serve VertexAI (although if you’ve been using AWS Bedrock for a while, you can probably guess what I’m about to say next). Demand for Gemini is now handled dynamically and globally. What does that mean? If one region is particularly busy, your request is likely to return 429 errors. If you can’t increase your quotas or rate limits, what can you do?

The first answer is to set your region to global. A global request is routed to whatever region has the most availability. You have no control over that routing. If all regions are busy, you could still get a 429 error. Making a global request does not guarantee a response.

Then what’s the real answer? Open up those wallets and buy provisioned throughput! Provisioned throughput is essentially a reservation for “units” of LLM service. Why did I say “units”? Well, let’s look at the parameters that factor into your provisioned throughput purchase for the latest version of Gemini 2.5 Pro:

• Percentage of queries using > 200K context window

• Estimated queries per second

• Input tokens per query

• Input image tokens per query

• Input video tokens per query

• Input audio tokens per query

• Output response text tokens per query

• Output reasoning text tokens per query  

And yes, changing all of these parameters affects the provisioned throughput pricing differently.

So, I thought, what’s a reasonable amount of throughput someone might need to reserve? Without knowing how many users would be connected or the use case, how do you come up with reasonable estimates? What did I do? I guessed. The lowest request per second you can set is 1. I then picked some very conservative token numbers: 3000 for input and 500 for output. This is certainly more tokens than would be used for a customer support chatbot, but considerably less than for agentic flows with RAG. With those conservative settings, how much provisioned throughput would I need to buy? $35,100/month. Yes, you read that right. And that doesn’t include any images, video, audio, thinking tokens, or long context requests. 

My intent is not to be critical of Google. I’m merely stating the facts. I’ve been saying for quite a while now, that we’ve yet to see real AI pricing. OpenAI, Anthropic, Google, et al. have been in a customer acquisition hypergrowth phase, selling AI services at a massive loss. However, now that we’re seeing a need to buy, upfront, $35k worth of provisioned throughput just to guarantee we won’t get 429 errors, now we’re beginning to see real AI pricing. Oh by the way, Google did suggest a third solution to Gemini 429 errors - fall back to using Claude. Seriously, they really suggested that.

We’ve recently been doing some very interesting work with Intel on supporting Intel CPUs, GPUs, and Gaudi for LLM inference in Intel Tiber Cloud with TrustGraph. We’ve been using TrustGraph to handle all of the LLM orchestration, deploying open models. The results have so far been fascinating. 

While TGI/vLLM support for Intel GPUs and Gaudi is not as mature as Nvidia support, we’re already seeing very reasonable token throughputs at more than reasonable prices. A real wildcard is using Llamafiles (llama.cpp) for deploying purely with Intel CPUs (their Granite Ridge bare metal instance of 128 cores of Xeon CPUs has deployed Llama 3.3 70B for us quite well). And the pricing? Well…

• Granite Ridge 128 core CPU instance: ~$3,300/month

• 8x GPU bare metal instance: ~$3,400/month

• 8x Gaudi2 instance: ~$7,500/month

We’ve also been doing some work lately deploying TrustGraph in Scaleway. For comparison, these are monthly prices for Nvidia GPUs in Scaleway:

• H100-1-80G: ~$2,300/month

• H100-SXM-8-80G: ~$19,200/month

At the moment, we don’t have a good feel for where the Intel services compare to Nvidia in terms of LLM performance. However, I’d feel comfortable saying Intel’s offerings are certainly in the ballpark with most of the H100 line, but perhaps not the newest ones.

But let’s not forget how we began this conversation - $35,100/month to guarantee a small amount of service for Gemini 2.5 Pro. Now begin the questions: what’s important to you? 

• How much are the latest and greatest Gemini models worth to you? Are you going to be able to run a model of Gemini’s capability with the above Intel/Nvidia options? No. But do you need it?

• Does data sovereignty matter? If you want control over the physical location of your data, the global option in VertexAI isn’t for you. Your only option is to buy provisioned throughput or deploy open models on Intel/Nvidia.

• Does cost predictability matter? If you think you can accurately forecast the 8 parameters needed to estimate provisioned throughput in VertexAI, please tell me how you’re doing it. I think the rest of us would immediately shrug our shoulders, close our eyes, move some sliders, and hope for the best. What strange times we live in where we find ourselves finding certainty in forecasting CPU/GPU costs.

Is there one right answer? No. Depending on how you answer the above questions (and others), a particular solution will emerge as being best for you. We designed TrustGraph with this flexibility in mind. TrustGraph supports all major LLM API services - including the cloud specific ones like AWS Bedrock, Azure, and VertexAI - in addition to LLM orchestration to deploy the entire TrustGraph knowledge automation platform along with open LLMs in any target environment. To learn more about how TrustGraph merges data silos into AI-optimized knowledge packages in a uniform agentic platform, check out the links below:

• 🌟 TrustGraph on GitHub 🧠 

• Join the Discord 👋 

We're in an AI gold rush. Every enterprise is scrambling to leverage it, hoping to unearth new efficiencies, personalize customer experiences, and gain an analytical edge. We diligently feed AI models our data, train them on our processes, and encourage them to learn from every interaction. The promise is tantalizing: an AI that intimately understands our business, ready to supercharge our operations.

But in this race for AI integration, a new, insidious threat is emerging – one that traditional cybersecurity isn't built to address. This threat doesn't just target our systems; it targets the very essence of our competitive advantage: our unique, accumulated knowledge.

Your Enterprise's Crown Jewels: More Than Just Data

Every successful enterprise possesses a rich tapestry of knowledge, woven over years, sometimes decades. This isn't just raw data in a database; it's the deeply embedded intelligence that truly differentiates you:

• Subject Matter Expertise (SME): The nuanced understanding held by your veteran engineers, your leading scientists, your shrewdest market analysts. The "how-to" and "why" that isn't written down in any manual but is evident in their work and decisions.

• Proprietary Processes: The unique workflows, manufacturing techniques, supply chain optimizations, and customer service protocols refined through countless iterations, which give you operational superiority.

• Customer Learnings: The deep insights into customer behavior, preferences, pain points, and feedback – gleaned from sales interactions, support tickets, and product usage – that allow you to tailor offerings and build loyalty.

• Strategic Roadmaps & Failed Experiments: Even your strategic plans, your product backlogs, and the "lessons learned" from projects that didn't pan out contain invaluable intelligence about your market perception and future direction.

This collective intelligence is your organizational DNA. It’s the reason you succeed, the foundation of your value chain, and the moat around your business.

The New Cyberattack: Knowledge Weaponized by AI

Imagine a scenario: a sophisticated actor gains access to this rich, internal knowledge base. In the past, exploiting this would have been a Herculean effort – requiring immense human capital to sift through, understand, and then attempt to replicate.

Enter modern AI.

Suddenly, an attacker armed with your internal knowledge and sophisticated AI tools can:

1. Replicate Your Success with Unprecedented Speed: AI can rapidly analyze your documented processes, design documents, and even derive undocumented SME knowledge by studying patterns in your operational data. It can then be used to blueprint a competitor's product or service that mirrors your strengths, effectively shortcutting years of R&D and market learning.

2. Identify and Exploit Your Hidden Weaknesses: More subtly, AI can scrutinize your entire value chain as revealed in your internal knowledge. It can find the inefficiencies in your processes that your own teams haven't spotted, identify subtle customer pain points that indicate market openings, or even model stress points in your operations, providing precise intelligence for exploitation or disruption.

3. Predict Your Next Move: By analyzing internal communications, strategic planning documents, and development roadmaps, AI can develop a startlingly accurate predictive model of your company's future actions, eroding any element of surprise.

The Asymmetric Threat: The Attacker with No Legacy

Crucially, this new breed of competitor doesn't need your infrastructure or your legacy systems. They can operate with zero tech debt, using the latest tools and infrastructure. Armed only with your meticulously cultivated internal knowledge, they can effectively build a leaner, faster, and potentially more targeted version of what took you years to establish. They are the AI usurpers, ready to undercut you in the market with a fresh approach powered by your own intelligence.

This isn't a traditional data breach anymore; it's an intellectual property heist of your entire operational brain, with AI acting as the super-efficient translation engine to convert that knowledge into a direct competitive threat.

Rethinking Defense: Beyond Firewalls and Antivirus

Our traditional cybersecurity measures – firewalls, endpoint detection, intrusion prevention – are designed to protect perimeters and known threats. They are less equipped to handle the insidious exploitation of intangible knowledge that may have been exfiltrated through subtle means, or even shared (perhaps unwisely) with AI systems whose governance is opaque.

The battleground is shifting. Protecting your enterprise now means protecting the sanctity and sovereignty of your unique knowledge. It means having granular control over where this knowledge resides, who (or what AI) has access to it, and how its derived insights are managed and deployed.

The ability to leverage AI on your own terms, within your own secure boundaries, using your knowledge exclusively for your benefit, is no longer just a good idea – it's becoming a fundamental imperative for survival in the AI-driven future. 

This is precisely the challenge TrustGraph is designed to address. By functioning as an AI Knowledge Platform that prioritizes knowledge sovereignty, TrustGraph enables your enterprise to harness the power of advanced AI while maintaining complete control over your proprietary knowledge. It allows you to deploy your entire AI stack—including sophisticated knowledge cores built by the TrustRAG engine from your internal data—within your secure, designated environments. This ensures your unique subject matter expertise, critical processes, and valuable customer learnings are used to generate insights exclusively for you, mitigating the risk of your knowledge being weaponized against you. With TrustGraph, you control where your knowledge resides, how it’s processed by AI, and who ultimately benefits from the intelligence it unlocks, turning your greatest asset back into your unassailable advantage.

Establish knowledge sovereignty with TrustGraph:

• 🌟 TrustGraph on GitHub 🧠 

• Join the Discord 👋 

For everyone who has been part of the TrustGraph journey, from our earliest releases to today, a heartfelt thank you! Your engagement, feedback, discussions about use cases, and enthusiasm for the future have been the bedrock of our development. It’s been an incredible adventure co-creating with this community, and we truly, truly appreciate every contribution.

As many of you have sensed, a pivotal moment for TrustGraph is just around the corner: Version 1.0 is imminent! 🥳 We genuinely couldn't be more excited about what this signifies and the capabilities it will unlock.

A Quick Note on Version 0.23: Our Bridge to Tomorrow

With the horizon of 1.0 so close, Version 0.23 holds a unique spot. Up until now, we’ve aimed for every iteration of TrustGraph to be production-worthy. Version 0.23, however, is a little different – think of it as a crucial bridge to the future, incorporating foundational work that sets the stage for the innovations in 1.0.

Because of this transitional nature, we can’t, with a clear conscience, label 0.23 as fully "production-grade." For those requiring absolute stability in their current deployments, we recommend sticking with Version 0.22 for the time being. But for the adventurous souls keen to glimpse the architectural shifts and willing to explore, 0.23 is there for you to spin up! For everyone else, the comprehensive, robust, and groundbreaking Version 1.0 is coming VERY SOON.

Embracing Openness: A Shift to Apache 2.0 Licensing

When we first launched TrustGraph, the licensing choice was a subject of much internal debate. We initially settled on AGPL-3.0, seeking a balance that included some protective measures. In retrospect, those measures were likely more complex than necessary.

Our vision for TrustGraph’s commercial value is clear, and it doesn’t revolve around gatekeeping through complicated licenses. We believe in the power of open collaboration and want to remove any barriers to adoption and contribution. That's why, effective immediately, TrustGraph is now licensed under Apache 2.0! This shift reflects our commitment to fostering an even more open and collaborative ecosystem.

The Dawn of 1.0: A Dynamic, Living Knowledge Platform

So, what does the future hold with TrustGraph 1.0 and beyond? We're set to break the mold for knowledge platforms. We’re moving beyond static pipelines or simple RAG add-ons to create a truly dynamic and living knowledge platform.

Imagine an AI Platform that not only deploys your LLMs and tools anywhere you need them but also enables:

• Actively Evolving Knowledge Cores: Systems that can learn, adapt, and have their structured understanding dynamically updated and refined.

• Deep Contextual Awareness: AI that operates with a rich, interconnected understanding of your domain, powered by truly intelligent knowledge graph capabilities.

• Unlocking Latent LLM Power: Providing LLMs with precisely the right and interconnected knowledge to perform at their peak, reliably and across any environment.

• Dynamic Intelligence: Adapt to loaded knowledge cores and generate custom code processing modules and even frontend apps that auto-deploy without any need for code development.

TrustGraph 1.0 is designed to be this platform – the system that provides the fertile ground for these intelligent, adaptable, and powerful AI solutions to flourish. It's about creating an environment where AI can truly know, learn, and reason based on a foundation of trust and integrated knowledge.

The future is incredibly bright for TrustGraph. We are on the cusp of delivering dynamic capabilities that will redefine how organizations deploy and leverage AI knowledge.

Stay Connected!

We're excited to share more details as we approach the 1.0 launch. If you have any questions, feedback, or simply want to chat about the future, please don’t hesitate to reach out.

• 🌟 TrustGraph on GitHub 🧠 

• Join the Discord 👋 

Thank you once again for being on this journey with us. The best is yet to come!

The transformative power of AI is undeniable. Yet, as organizations increasingly leverage AI, a critical question emerges: Who truly controls the invaluable knowledge these systems create? This isn't just about raw data; it's about the derived insights, the refined intelligence, and the structured knowledge cores that will define competitive advantage. This is the essence of Knowledge Sovereignty.

For enterprises, operating within complex regulatory landscapes that champions data privacy and digital autonomy, knowledge sovereignty is not a luxury—it's a mandate. It means having unequivocal control over where your intellectual property and strategic insights reside, how they are governed, and who can access them, especially when that knowledge is processed and refined by AI.

Many current AI platforms, often centralized and operating within specific cloud ecosystems, can inadvertently challenge an organization's ability to maintain full knowledge sovereignty. When AI tools process sensitive data and generate valuable knowledge graphs outside of your direct control or preferred jurisdictions, enterprises can face:

• Compliance Risks: Difficulty demonstrating adherence to stringent data protection and residency requirements.

• Loss of Control: Limited visibility or say over where refined knowledge assets are stored and processed.

• Vendor Lock-in: Dependency on specific provider ecosystems can make it challenging to repatriate or migrate valuable knowledge assets.

This is where TrustGraph, the Knowledge Provisioning Platform, fundamentally shifts the paradigm. We understand that for enterprises, the "where" and "how" of AI deployment are as crucial as the "what." TrustGraph is designed from the ground up to empower you with full control:

1. Deploy Anywhere, Retain Control: TrustGraph's core philosophy is universal deployability. As a fully containerized solution, it can be provisioned on your choice of infrastructure. This means you can deploy your entire AI stack – including models, tools, and the critical TrustRAG knowledge cores – within:

   • Your On-Premises Hardware: Ensuring data and knowledge never leave your physical control.

   • Private Cloud Environments: Leveraging cloud agility within your secure, dedicated infrastructure.

   • Specific Cloud Regions/Providers: Adhering to jurisdictional requirements and maintaining data residency for both raw data and derived knowledge.

2. Knowledge Cores Under Your Governance: With TrustGraph, the sophisticated Knowledge Graphs - semantic relationships mapped to vector embeddings - built by our TrustRAG engine are not black-box assets residing on a third-party platform. They are integral components of your TrustGraph deployment. This means:

   • You own and manage the derived knowledge: The insights, the structured understanding, the very "intelligence" in your data, remains under your stewardship.

   • You dictate access and policies: Applying your internal governance and compliance frameworks directly to these invaluable knowledge assets.

3. Transparent & Verifiable Operations: As an open-source platform, TrustGraph offers a level of transparency that builds confidence, allowing your teams to understand and verify how data is processed and knowledge is managed, ensuring alignment with values of data protection by design.

The TrustGraph Advantage: Enabling Innovation with Confidence

By choosing TrustGraph, enterprises no longer have to compromise between leveraging state-of-the-art AI and upholding the principles of knowledge sovereignty. You gain:

• Full Jurisdictional Control: Ensure your most valuable digital assets – including complex knowledge graphs – are managed within your desired legal and geographical boundaries.

• Enhanced Compliance & Trust: Confidently meet and exceed data protection regulations, building trust with your customers and partners.

• Unhindered Innovation: Leverage powerful AI capabilities, including advanced RAG with rich knowledge cores, without ceding control over the critical intelligence they generate.

Take Control of Your AI-Driven Future

In an era where knowledge is the new currency, maintaining sovereignty over it is paramount. TrustGraph provides enterprises with the platform and philosophy to confidently embrace AI, secure in the knowledge that their insights and intellectual property remain firmly under their control.

Ready to build your AI future on a foundation of sovereignty?

• Explore how TrustGraph's deploy-anywhere architecture works

• Discover how TrustRAG puts you in control of your AI's Knowledge Core

• Engage with our team to discuss your specific sovereignty needs

Empower your enterprise with AI, without sacrificing an ounce of control. Provision your path to Knowledge Sovereignty with TrustGraph.

In Parts 1 and 2, we exposed the dangerous flaw in most current AI "memory": like Leonard Shelby in Memento, our systems often operate on disconnected fragments, unable to form the interconnected knowledge needed for reliable reasoning. We saw how this reliance on context-stripped, relationship-blind, and provenance-oblivious data dooms AI to a cycle of confident errors and hallucinations, just as Leonard's fragmented note system led him down dangerous paths.

So, how do we break the loop? How do we give AI the ability to truly know, not just recall fragments? The answer isn't a slightly better system of Polaroids and notes. The answer is to build the integrated, structured understanding Leonard tragically lacked: a Knowledge Core.

This is precisely what TrustGraph, the AI Provisioning Platform, delivers through its advanced TrustRAG engine. It moves beyond the limitations of fragmented recall by architecting genuine knowledge:

1. Mapping the Connections (Solving Relationship Blindness): Unlike Leonard staring at isolated clues, TrustGraph automatically builds a Knowledge Graph (KG). It doesn't just store facts; it explicitly maps the relationships between them (e.g., "Person X works for Company Y," "Event A caused Event B"). This Knowledge Graph is the coherent narrative structure Leonard couldn't form – the understanding of how things connect.

2. Delivering Contextualized Scenes (Solving Context Stripping): Leonard reviewed one Polaroid at a time, losing the big picture. TrustRAG uses a hybrid retrieval process. Vector search identifies relevant starting points within the Knowledge Graph, but then TrustRAG traverses the graph connections, constructing a subgraph of related entities and relationships. Instead of isolated fragments, the LLM receives a connected scene – a relevant slice of the knowledge core with inherent local context.

3. Verifying the Clues (Addressing Provenance Oblivion): Leonard couldn't be sure when or why he wrote his notes. TrustGraph's Knowledge Graph architecture is designed to incorporate provenance metadata directly with the facts and relationships it stores (source, timestamp, reliability). TrustRAG can then leverage this, allowing the AI to weigh information based on its origins, escaping the trap of treating all retrieved fragments as equally trustworthy.

Escaping the Memento Loop: The Power of a Knowledge Core

By building and utilizing this structured Knowledge Core, TrustGraph fundamentally changes AI capabilities:

• Enables Reliable Reasoning: Provides the interconnected facts and explicit relationships needed for complex reasoning, synthesis, and understanding causality – tasks impossible for Leonard (and fragment-based AI).

• Dramatically Reduces Hallucinations: Grounding responses in a verifiable graph of knowledge, potentially weighted by provenance, significantly reduces the chance of fabricating connections or asserting baseless claims.

• Offers Explainable Insight: The retrieved subgraph itself acts as an explanation, showing how the AI arrived at its context based on the knowledge core's structure – unlike Leonard's often opaque leaps of faith.

Provisioning Reliable Knowledge, Not Just Infrastructure

TrustGraph isn't just a concept. It's an AI Provisioning Platform that containerizes the entire intelligent system – the LLMs, the necessary tools, and the essential TrustRAG Knowledge Cores – allowing you to reliably provision this complete, knowledgeable AI stack anywhere (Cloud, On-Prem, Edge). We're providing the robust, managed infrastructure for knowledge that Leonard's fragile system lacked.

Stop building AI condemned to relive Leonard Shelby's nightmare. Stop provisioning systems based on fragmented recall and start delivering applications grounded in genuine understanding.

Give your AI the gift of coherent memory. Build with a Knowledge Core.

• Explore TrustGraph on GitHub and see how we structure knowledge

• Read the TrustRAG documentation for technical details

• Join our community and discuss the future of AI knowledge

Provision AI that knows. Provision it with TrustGraph.

In Part 1, we likened today's typical AI "memory" to the plight of Leonard Shelby in Memento: brilliant at accessing isolated fragments (Polaroids, notes, tattoos) but unable to weave them into the coherent tapestry of true knowledge. He remembers that he has a note, but not necessarily the reliable why or the how it connects to everything else. Now, let's diagnose why popular RAG approaches, inherently create this dangerous, fragmented reality for our AI.

Imagine Leonard's investigation. His "database" consists of disconnected snapshots and cryptic assertions. When he tries to solve a problem ("Who is John G?"), he shuffles through these fragments, looking for clues that feel related. This is strikingly similar to how typical RAG approaches use “memory” :

1. The Polaroid Snapshot (Context Stripping): Just as Leonard's Polaroids capture only a single moment divorced from what came before or after, document chunking for vectorization strips vital context. A retrieved sentence saying "Project Titan deadline is critical" loses the surrounding discussion about why it's critical, who set it, or what happens if it's missed. The AI gets the snapshot, not the scene.

2. Cryptic Notes & Missing Links (Relationship Blindness): Leonard's notes might say "Meet Natalie" and "Don't believe Dodd's lies." Vector search can find documents mentioning "Natalie" and documents mentioning "Dodd," but like Leonard, it lacks the explicit map connecting them. Does Natalie know Dodd? Is she part of the lies? The relationships aren't inherently encoded in the vector similarity. Finding similar topics doesn't mean understanding their causal or structural connection, leaving the AI to guess these critical links.

3. Trusting Faded Ink (Provenance Oblivion): Leonard must trust his fragmented notes, even if they were written under duress, based on misinformation, or are simply outdated. Standard RAG often does the same, treating all retrieved text fragments as equally valid assertions. It frequently lacks a robust mechanism to track provenance – the source, timestamp, or reliability score of the information. An old, debunked "fact" retrieved via vector similarity looks just as convincing to the LLM as a fresh, verified one.

The Leonard Shelby Effect in AI:

When AI operates with only these disconnected, context-stripped, relationship-blind, and provenance-oblivious fragments, its reasoning becomes dangerously flawed:

• Hallucinating Connections: Like Leonard assuming connections between unrelated clues, the LLM invents relationships between text fragments simply because they were retrieved together.

• Contradictory Actions: Acting on conflicting "facts" because it can't verify which source or connection is trustworthy or current.

• Inability to Synthesize: Unable to build a larger picture or draw reliable conclusions because the foundational links between data points are missing or inferred incorrectly.

We are building AI systems trapped in a Memento loop: forever re-reading fragmented clues, capable of impressive recall but incapable of forming the durable, interconnected knowledge needed for reliable reasoning and true understanding. They are architecturally destined to make potentially disastrous mistakes based on an incomplete and untrustworthy view of their "world."

If we want AI to escape this loop, we need to fundamentally change how we provide information. We need to move beyond retrieving isolated Polaroids and start building systems that can understand the whole, interconnected story.

How do we provide that interconnected narrative? How do we build AI memory that understands relationships and provenance? Stay tuned for Part 3 where we reveal the architecture for true AI knowledge.

Have you seen an AI confidently stitch together unrelated facts like Leonard building a flawed theory? Let us know:

• 🌟 TrustGraph on GitHub 🚢 

• Join the Discord 👋 

We're drowning in takes about AI "memory." RAG is hailed as the silver bullet, promising intelligent systems that learn and retain information. But let's be brutally honest: most implementations are building agents that are drowning in data and suffocating from a lack of knowledge.

These systems excel at retrieving fragments – isolated data points plucked from documents and observations stripped of their origins. Ask it a question, and it surfaces a text snippet that looks relevant. This feels like memory - like recall.

But it isn't knowledge.

Real knowledge isn't just storing data points - it's understanding their context, their provenance (where did this information come from? is it reliable?), and their relationships with other data points. Human memory builds interconnected information networks while current AI "memory" approaches just hoard disconnected digital Post-it notes. We are mistaking the retrieval of isolated assertions for the synthesis of contextualized understanding.

Think of Leonard Shelby in Christopher Nolan's film Memento. Suffering from anterograde amnesia, Leonard can't form new memories. To function, he relies on a system of Polaroids, handwritten notes, and even tattoos – externalized fragments representing supposed facts about his world and his mission to find his wife's killer.

Today's RAG systems often operate eerily like Leonard. They receive a query and consult their "Polaroids" – the vector embeddings of text chunks. They retrieve the chunk that seems most relevant based on similarity, a fragment like "Don't believe his lies" or "Find John G." Unfortunately, like Leonard, these RAG systems lack the overarching context and the relationships between these fragments. It doesn't inherently know how the note about John G. relates to the warning about lies, or the sequence of events that led to these assertions being recorded.

And this fragmentation is where disaster strikes. Leonard, working only with disconnected clues, makes fatal misinterpretations. He trusts the wrong people, acts on incomplete information, and is manipulated because he cannot form a cohesive, interconnected understanding of his reality. His "memory," composed of isolated data points, leads him not to truth, but deeper into confusion, madness, and catastrophe.

An AI that can quote a source but doesn't inherently grasp how that source connects to related concepts or whether that source is trustworthy isn't remembering – it's echoing fragments, just like Leonard reading his own fragmented notes.

This fundamental flaw leads to confident hallucinations, an inability to reason deeply about causality, and systems that can misled. We're building articulate regurgitators, not truly knowledgeable thinkers.

We need to stop celebrating glorified search indices as "memory" and start demanding systems capable of building actual knowledge. Until then, we're just building better mimics, doomed to repeat the mistakes born from disconnected understanding.

Next time in Part 2: We dissect why this fragment-recall approach fundamentally breaks down when AI needs to reason, synthesize, or understand causality.

Does your AI feel like it knows things, or just recalls text like Leonard Shelby reading his notes? Reach out to us below:

• 🌟 TrustGraph on GitHub 🧠 

• Join the Discord 👋 

Beyond the Monolith: Why the Future of AI is a Symphony, Not a Soloist

For years, the science fiction dream and much of the AI hype cycle has revolved around a singular goal: building the one, giant Artificial General Intelligence (AGI). A single, monolithic model capable of learning, reasoning, and solving any problem like a human. It's a captivating vision, but is it the only path forward? Or even the right one for practical, powerful, and responsible AI?

It's not. The pursuit of a single, all-encompassing model overlooks the messy, beautiful complexity of intelligence itself and ignores the profound limitations inherent in monolithic approaches. The true future of advanced machine intelligence lies not in a singular soloist, but in a symphony of tightly interconnected, specialized software components working in harmony.

The Cracks in the Monolith

Trying to build a single AI model to "solve" human-level intelligence faces immense hurdles:

• Garbage In, Garbage Out: Training such models requires unfathomable amounts of data and human intervention to evaluate the quality of the inputs and outputs which is subject to individual biases.

• Brittleness & Lack of Nuance: A single model, can struggle with specialized tasks outside its core training distribution. It's the ultimate "jack of all trades, master of none," potentially failing when encountering edge cases.

• Operational Nightmares: Deploying, managing, updating, and securing a single, gigantic model across diverse environments (cloud, on-prem, edge) is incredibly complex and inefficient. How do you provide fine-grained updates or tailored capabilities?

• Explainability & Auditability Black Holes: Understanding why a monolithic model made a specific decision can be nearly impossible, hindering trust, debugging, and crucial safety checks.

• Concentration of Power & Risk: Placing all intelligent capabilities into a single entity creates immense concentrations of power and systemic risk.

The Rise of the System: Intelligence as an Interconnected Network

Nature offers a better blueprint. The human brain isn't a homogenous blob; it's a highly specialized, interconnected system of regions communicating dynamically. Complex tasks emerge from the coordinated activity of these specialized parts. Similarly, the future of advanced AI lies in building systems that mirror this principle.

Imagine an AI architecture that functions less like a single giant brain and more like a biological nervous system – what we might call a Synaptic Automation System. This system possesses key characteristics:

• Modular Expertise: Instead of one model knowing everything, the system leverages specialized "Intelligent Cores" – components encapsulating deep expertise, algorithms, or processing for specific domains. These cores are the seeds of adaptable skill.

• Dynamic Synthesis & Deployment: The system doesn't just run pre-built applications. Based on the available Cores and the task at hand, it dynamically generates and deploys the necessary processing modules on the fly. Think of it assembling a specialized task force exactly when needed.

• Emergent Learning & Adaptation: Faced with unique situations, the system doesn't just rely on past training. It can generate custom learning modules to analyze new data, identify patterns, and evolve its understanding over time through integrated feedback loops, constantly refining its capabilities.

• Inherent Connectivity & Communication: Like synapses firing, components constantly communicate, sharing context and triggering actions across the system. This allows for holistic reasoning and complex workflow execution far beyond simple pipelines.

• Transparency & Trust: Crucially, because the system generates plans and modules dynamically, it can also be designed to make these processes transparent. The 'reasoning' behind an automated workflow can be audited, allowing for verification, compliance, and crucial safety checks.

• Safety First: Built-in mechanisms constantly monitor the system's actions, detecting potential harms or deviations from desired boundaries, enabling adaptive responses to ensure responsible operation.

• Universal Presence: This entire intelligent system isn't locked to specific hardware. It's designed as a fabric that can be deployed consistently across any cloud, bare-metal servers, or edge devices, bringing intelligence wherever it's needed.

TrustGraph: Embodying the Synaptic Vision

This isn't just theory. Platforms like TrustGraph are pioneering this Synaptic Automation System approach. By focusing on dynamically connecting modular Intelligent Cores, synthesizing processes on demand, enabling continuous learning through feedback, ensuring auditability and safety, and running universally across infrastructures, TrustGraph demonstrates the power of this interconnected model over the monolithic dream.

The Symphony Takes the Stage

The future of impactful AI won't be a single, monolithic oracle attempting to know everything. It will be a dynamic, adaptable, and interconnected system – a symphony of specialized components working together seamlessly. This approach offers a path towards more scalable, resilient, trustworthy, and ultimately more powerful machine intelligence capable of tackling the world's complex challenges. It’s time to move beyond the monolith and embrace the power of the network.

• 🌟 TrustGraph on GitHub 🧠 

• Join the Discord 👋 

• Watch tutorials on YouTube 📺️ 

Beyond the Buzz: Why Autonomous Knowledge Operations Matters More Than Just AI Agents

The tech world has been ablaze with talk of AI agents. We see demos of agents booking flights, writing code snippets, or summarizing articles. It's exciting, capturing the imagination with glimpses of AI performing tasks previously requiring human operations. But as we move from demos to deployment, simply thinking in terms of "agents" falls short.

The real paradigm shift isn't just about creating smarter tools (agents); it's about building systems capable of continuous, reliable, and goal-directed operations that are powered by deep contextual understanding. This is the philosophy of TrustGraph’s Autonomous Knowledge Operations.

What's the Difference? Isn't an Agent Autonomous?

An AI Agent, in its common definition today, is often:

• Task-Oriented: Designed to perform a specific, often short-lived task (e.g., answer a question, draft an email).

• Reactive: Primarily responds to direct input or triggers.

• Component-Level: Can be thought of as a sophisticated function call or a smart script.

• Potentially Isolated & Knowledge-Poor: Might operate with limited context or struggle to access and reason over the complex web of information within an enterprise.

While powerful, these agents often lack the deep knowledge integration, robustness, persistence, and manageability needed for mission-critical business functions. Running a complex business process isn't like asking an agent to write a poem; it requires continuous awareness, adaptation, reliability, and critically, intelligent use of relevant knowledge.

Autonomous Knowledge Operations, is a broader, more systemic approach where autonomy is directly fueled by intelligent information:

• Goal-Oriented & Continuous: Focused on achieving and maintaining a desired state or objective over time. Action is driven by understanding the goal within its knowledge context.

• Proactive, Persistent & Knowledge-Driven: Actively monitors, plans, and acts by constantly interpreting its environment through a rich knowledge base. It runs continuously, learning and adapting.

• System-Level: Encompasses not just agents but the entire infrastructure, knowledge pipelines (RAG, KG, VectorDBs), integration points, and feedback loops required for sustained, intelligent operation.

• Fueled by Deep Knowledge & Context: Leverages rich, relevant, and timely information drawn from enterprise sources. This requires sophisticated RAG pipelines with both vector databases and knowledge graphs.

• Observable & Manageable: Designed with built-in monitoring, logging, tracing, and controls to ensure reliability, understand the knowledge-driven behavior, and allow for intervention or adjustments.

• Reliable & Scalable: Built on enterprise-grade infrastructure capable of handling failures, scaling resources, and meeting performance demands for both computation and knowledge processing.

Why This Shift in Thinking Matters

Focusing solely on "agents" leads to several potential pitfalls in enterprise adoption:

1. The "Demo-to-Production" Gap: Cool agent demos often bypass the hard parts: robust knowledge integration, error handling, scalability, security, and monitoring needed for real-world value.

2. Context Starvation: Agents without deep, structured context – the kind derived from integrated Knowledge Graphs combined with Vector DBs – struggle with complex reasoning and nuanced tasks common in business. This is a knowledge access problem.

3. Infrastructure Nightmare: Managing dozens of agents and their disparate, potentially inconsistent knowledge sources, ensuring reliability, and providing consistent data access is an operational burden.

4. Lack of Trust: How do you monitor, debug, or guarantee the performance of agents acting on potentially incomplete or misunderstood information? Observability into the knowledge retrieval and reasoning process is non-negotiable.

Building for Autonomous Knowledge Operations: The TrustGraph Philosophy

This is precisely the philosophy behind TrustGraph. We realized that the conversation needed to evolve beyond just the agent itself to encompass the entire knowledge-driven system. TrustGraph is an Autonomous Knowledge Operations Platform designed to provide the foundational elements missing from simple agent frameworks:

• Enterprise-Grade Infrastructure: It provides the scalable, reliable backend needed to run operations continuously, managing both computation and knowledge flows.

• Integrated RAG (KG + VectorDB): It automates the deployment of sophisticated RAG pipelines, acknowledging that deep context and reliable autonomy stem from leveraging both semantic similarity (vectors) and structured relationships (knowledge graphs).

• Unified LLM Access: It abstracts the complexity of dealing with multiple LLM providers, allowing the system to focus on applying the best reasoning to the available knowledge.

• Full Observability Stack: It builds in logging, metrics, and tracing from the ground up, including insights into the RAG process, because trusting autonomous systems requires understanding how they arrive at decisions based on knowledge.

By focusing on the knowledge-driven operation rather than just the agent, we can build systems that don't just perform tasks but achieve persistent business outcomes reliably, efficiently, and intelligently.

The Future is Systemic and Knowledge-Rich

AI agents are a vital component of the future. But the true transformation lies in weaving these components into robust, knowledge-aware, observable, and continuous Autonomous Knowledge Operations. This requires a shift in mindset and tooling – moving from building smart tools to engineering intelligent, self-managing systems powered by deep understanding. That's the future we're building towards with TrustGraph.

• 🌟 TrustGraph on GitHub 🚀 

• Join the Discord 👋 

• Watch tutorials on YouTube 📺️ 

Feel free to add a specific call to action, like linking to the TrustGraph GitHub repo or inviting discussion on specific points.

Once again, AI hype trains are full steam ahead as people overload DeepSeek to try out DeepSeek-R1. In fact, DeepSeek-R1 has generated so much hype that Nvidia’s stock shed nearly 17% of its value. No matter how impressive DeekSeek-R1 is, yes, you still need RAG.

No, I’m not going to tell you why you still need RAG. I’m going to show you. What’s a good use case for this experiment? We need a highly complex document that describes a topic that requires substantial human effort to understand and is publicly available.

MIL-HDBK-516C to the rescue! Never thought I’d say that. MIL-HDBK-516C is a guide for satisfying airworthiness requirements for military aircraft. It is highly complex, people (like myself in a past life) spend months if not years working with it, and it is publicly available. Check. ✅ 

Some quick stats on the doc:

• Pages: 527

• Tokens: ~550k

• Complexity: Very High

• Format: PDF

While there are nearly endless questions we could ask about this document, let’s choose one that has a concrete expected response.

Q: How does speech intelligibility impact airworthiness?

The first issue is that if I ask DeepSeek-R1 the test question, the model talks about airworthiness in a broader sense. To help narrow the model’s focus, I appended the questions with “per MIL-HDBK-516C”.

DeepSeek-R1 response:

If you’ve never worked with MIL-HDBK-516C, you might be shocked at the progress of AI. Unfortunately, this response that looks very good, actually has major problems. Some of the problems:

• The section numbers referenced don’t actually exist.

• Nowhere does MIL-HDBK-516C require testing under “worst-case operational conditions” including “combat”. Not only is this statement false, it is dangerously misleading. The airworthiness process exists to fully test an aircraft system prior to engaging in worst-case operational conditions.

• At no point does MIL-HDBK-516C reference “evacuation commands”. 

• At no point, anywhere, in MIL-HDBK-516C are “NATO allies” referenced.

• At no point is speech intelligibility referenced as a “critical safety factor”. In fact, speech intelligibility is merely one of hundreds of criteria necessary to establish airworthiness.

• The most important part of the speech intelligibility criteria, the Modified Rhyme Test is totally omitted from the response. The Modified Rhyme Test, MRT, is the primary testing method for demonstrating speech intelligibility compliance.

Are we surprised the response is so poor? No. Although the degree of hallucination is a bit concerning. What happens when we try to upload the entire document to DeepSeek-R1?

Well that’s a problem.

Given the large number of tokens, what happens if we dump the entire document on a model like Gemini-2.0-Flash-Exp with it’s 1M token limits? 

Not surprisingly, this response features far fewer misleading hallucinations since the full text was able to be provided to the model. However, the section on “Intelligibility as a Parameter” is at best confusing and somewhat inaccurate. The statement, “Speech intelligibility is explicitly mentioned as a parameter” is factually false since nowhere in the source is speech intelligibility called a parameter. Instead, testing methods are discussed for verifying the quality of communications systems that satisfy the testing requirements. 

While this response features fewer inaccuracies, it still lacks the necessary conceptual depth to address the question. Just like DeepSeek-R1, Gemini omitted the most important information regarding speech intelligibility - the Modified Rhyme Test. The Modified Rhyme Test, MRT, is the most important information related to speech intelligibility and any response must discuss it to be complete.

How does Agentic Graph RAG compare? Using TrustGraph configured to use Gemini-2.0-Flash-Exp on an extracted cognitive core of MIL-HDBK-516C, the response is:

Our first impression is that this response is, by far, the shortest response. However, it also, by far, has the highest information density. The response is the most complete response capturing all of the testing methodologies including the most important, the MRT. In fact, this response also catches the scoring criteria for the MRT, “a score of 80% (91% for Army)”. 

But don’t take my word for it, here’s the source text’s excerpt on speech intelligibility:

Now that we see the source text, it becomes even more obvious how far DeepSeek-R1 diverged from the ground truth and how accurate the Agentic Graph RAG response with TrustGraph is. But should we be surprised that DeepSeek-R1 can’t answer this obscure question? No, it’s absolutely an obscure question, but that’s the point. Obscure topics where people don’t know the answer are exactly the use cases where you would want to use AI. Perhaps Gemini’s response with the full source text is a bit surprising. On the other hand, our testing has - time and time again - pointed to less than 10% of the advertised context window being reliably usable.

But this question was only for one document. MIL-HDBK-516C references hundreds of other documents needed to fully understand airworthiness compliance. The full set of documents would likely be 10s of millions of tokens, far exceeding any LLM’s capabilities. Yet, RAG infrastructures, especially Agentic Graph RAG ones can manage these complex problems. The ability to save these data sets as Cognitive Cores that can be shared and loaded on demand are fundamental to TrustGraph’s Agentic Graph RAG approach.

• 🌟 TrustGraph on GitHub 🚀 

• Load the MIL-HDBK-516C Knowledge Package 🧠 

• Join the Discord 👋 

• Watch tutorials on YouTube 📺️