Semantica bets that AI accountability is a graph problem, not a model problem

The pitch on Semantica’s GitHub repository is blunt: “Most AI agents act without a trail. They store embeddings, not meaning.” The project, an open-source framework it calls “the Open Source Palantir for AI Agents,” builds a deterministic graph layer underneath LLMs, vector stores, and agent frameworks. No LLM required for graph construction, reasoning, or provenance. Every agent decision becomes a first-class, queryable node with W3C PROV-O provenance, causal links, and policy gates.

What is genuinely new here is not the ambition. Governance layers for AI have been pitched since the first enterprise RAG deployment. What is new is the mechanism: Semantica treats the decision, not the document, as the unit of accountability. A decision is a graph node with a lifecycle. It has upstream causes, downstream effects, a confidence score, and an exportable audit trail. That framing, plus the deterministic reasoning engines underneath, is the actual story.

The repository is explicit about the pain point. In lending, an underwriting agent’s approval “has to survive a regulator’s ‘why’ months later.” Vector databases answer “what is similar?” with embedding similarity. They do not answer “what is connected, why, and how?” Semantica’s Context Graph does, via graph traversal instead of token windows. The comparison table in the README is stark: vector DB plus RAG stores no decision history, no provenance, no reasoning, no conflict detection. Semantica stores all of it, with PROV-O, SHACL, OWL, and RDF exports for compliance.

The technical details matter because they are the difference between a marketing slide and a shippable system. The pipeline runs Ingest to Parse to Normalize to Split to Extract, then Conflict Detection and Deduplication before the Knowledge Graph is built. Conflicts are flagged, not silently overwritten. Duplicates are merged with provenance preserved. On top of the graph sit four engines: SHACL/OWL ontology governance, Rete/Datalog/SPARQL inference, PROV-O lineage, and first-class decision records. Storage is polyglot: RDF triple stores (embedded Oxigraph, Blazegraph, Apache Jena, Eclipse RDF4J) and Labeled Property Graphs (Neo4j, FalkorDB, Apache AGE, AWS Neptune), all swappable without touching code.

The enterprise connectors are the most telling detail. Native Databricks integration reaches into Unity Catalog and Delta Lake with PAT/OAuth M2M auth, and introspects catalog, schema, table, and lineage. Snowflake support covers warehouse, database, and schema with key-pair and OAuth auth. The point is explicit: tables already sitting in Unity Catalog or a Snowflake warehouse become graph nodes with provenance, “without exporting that data to a third-party SaaS first.” That is a direct answer to the compliance objection that has blocked every hosted AI governance product in regulated industries.

Semantica’s positioning is a bet on a specific theory of the AI market. The theory says the bottleneck for enterprise agent deployment is not model capability. It is the absence of a defensible answer to “why did the AI do that?” in a format a regulator will accept. The project’s answer is to make the reasoning layer deterministic and the provenance W3C-standard, so the audit trail is not a post-hoc narrative but a structural property of the system.

The “no LLM required” claim deserves scrutiny, because it is both the project’s strength and its limit. Graph construction, conflict detection, and reasoning are deterministic. That means the provenance layer is trustworthy in a way a model-generated explanation never can be. But the extraction stage, the NER, relation, and event extraction that turns messy source documents into triplets, is where an LLM is almost certainly doing the heavy lifting in practice. The repository lists “entity-aware chunking” and “GraphRAG-native” splitting, which implies model involvement somewhere in the pipeline. The distinction Semantica draws is that the LLM is not required for the graph, reasoning, or provenance layers once extraction is done. That is a real and meaningful boundary, but it is not the same as an LLM-free system.

The decision intelligence API is where the design philosophy becomes concrete. The README walks through a loan pipeline: credit application, underwriting, interest rate. Each step calls record_decision() with a category, scenario, reasoning string, outcome, and confidence. Then add_causal_relationship() links them with relationship types restricted to CAUSED, INFLUENCED, or PRECEDENT_FOR. trace_decision_chain() returns full causal ancestry. find_similar_decisions() does semantic precedent search. check_decision_rules() runs a policy gate against configurable rule sets. The confidence scores are stored, not discarded, which means an auditor can see not just what the agent decided but how sure it was.

This is the shape of the accountability stack the industry has been circling. The EU AI Act’s high-risk provisions, the growing list of AI governance frameworks from NIST, and the regulatory pressure on financial services all point the same direction: decisions need to be explainable, traceable, and reproducible. Semantica’s bet is that graph-native infrastructure, not better models, is what makes that possible. The project calls it “Decision Intelligence,” and treats every AI choice as “a permanent, auditable, queryable record” rather than an ephemeral inference.

The open-source, self-hostable, zero-vendor-lock-in positioning is a direct response to the Palantir comparison. Palantir’s Foundry has dominated the graph-native decision intelligence space in defense and government, but it is proprietary, expensive, and a black box of its own. Semantica is trying to be the open alternative: auditable by construction, governed by W3C standards, and swappable across storage backends. Whether that is a real challenge to Palantir’s enterprise foothold or a complementary layer for teams that would never get Palantir budget is an open question. The README’s target list, finance, healthcare, legal, government, defense, is exactly Palantir’s home turf.

The version number tells part of the story. The semantica doctor output in the README shows version 0.6.0. This is early software. The architecture is ambitious and the module list is long, which raises the classic open-source question: how much of this is actually battle-tested in production, and how much is a roadmap rendered as a README? The repository claims every stage is “a shipping module, independently importable,” which is a strong claim for a 0.6 release. The integrations list is real, Agno support, an MCP server, a CLI, a REST API, but the depth of each integration is unverifiable from the landing page alone.

What is most interesting about Semantica is what it implies about the direction of AI infrastructure. The industry has spent two years optimizing retrieval and generation. The next phase, if Semantica is right, is about memory and accountability as first-class infrastructure. The Context Graph is described as “the structured memory layer that traditional RAG is missing.” That is a specific and testable claim: flat embeddings answer similarity, graphs answer connectivity and causation. For agents that make consequential decisions, causation is the property that matters.

The project’s real contribution may be forcing the question of what “explainable AI” actually means in practice. Semantica’s answer is that explanation is not a natural-language string a model generates about its own reasoning. Explanation is a structural property: a causal chain of recorded decisions, each linked to evidence, each governed by policy rules, each exportable in a format compliance frameworks accept. That is a harder standard than most of the AI industry has been willing to meet, and it is the standard regulators are moving toward.

For AI builders, the takeaway is concrete. If you are shipping agents in regulated domains, the vector store plus RAG stack is going to hit a wall at audit time. Semantica is worth evaluating as the deterministic layer underneath, not as a replacement for your model or framework. The polyglot storage and drop-in integrations mean the cost of trying it is low, a pip install semantica and a ContextGraph(advanced_analytics=True) call. The cost of not having an answer to a regulator’s “why” is considerably higher.

The open question is whether the market wants a separate graph infrastructure layer or whether the big platforms absorb this functionality. Databricks and Snowflake both have graph ambitions, and the major agent frameworks are adding memory features. Semantica’s bet is that a neutral, self-hosted, standards-based layer wins because regulated enterprises refuse to send their data to a third-party SaaS and refuse to lock into one vendor’s backend. That bet is either prescient or naive, and the 0.6.0 version number suggests the project is about to find out which. The confidence scores in the README’s loan example are high, 0.88, 0.94, 0.99. Whether the market assigns Semantica’s own prospects a similar confidence is the story to watch.