Pennant: A First Look at the New Knowledge Engineering Studio for Checkable Reasoning

Pennant (found at github.com/galeluka/Pennant) is a newly published tool that positions itself against a very specific frustration: language models produce fluent text, but that text is hard to verify, argue with, or audit. Pennant's answer is to make you build an explicit model instead — typed nodes (claims, obligations, evidence, entities) and typed relationships (supports, contradicts, requires, satisfies) that can be inspected, queried, and arithmetically checked rather than just read and trusted.

What it actually does

Instead of asking an LLM "does this contract comply with regulation X" and getting back a paragraph, Pennant has you (optionally with AI-suggested first drafts) structure the domain: each obligation becomes a node, each piece of evidence becomes a node, and the relationships between them (satisfies, conflicts-with, depends-on) become explicit edges you can enumerate. Contradictions surface because two nodes both point to the same claim with opposing relationship types — not because a model "noticed" something in a stochastic pass. Where relationships carry numeric weights (probabilities, dollar amounts, time constraints), the tool can run arithmetic checks across the graph — for example, do the funded obligations sum to more than the disclosed budget, or does an evidence node's date fall after the claim it supposedly supports.

AI assistance is present but demoted to a suggestion role: it can propose candidate nodes or relationships from a source document, but the structure that results is what gets checked, not the model's prose. This is the core differentiator from most "AI knowledge assistant" tools currently shipping.

Concrete use cases

• Contract and compliance review: model obligations from a contract as nodes, link evidence documents to each obligation, and get a checkable list of unsatisfied or contradicted obligations instead of a summary paragraph.
• Due diligence / investment memos: structure claims made in a pitch deck as nodes, attach evidence (or lack thereof) as counter-nodes, and produce an arguable map of what's actually supported versus asserted.
• Research literature mapping: encode competing findings across papers as claim nodes with supports/contradicts edges, useful for spotting where a field's evidence base actually disagrees rather than trusting a survey's narrative.
• Policy/regulatory analysis: turn a regulation's requirements into obligation nodes and check draft compliance documents against them line by line.

Where it stands today

This is an early-stage, individually published project on GitHub rather than a hosted SaaS product with a marketing site. There is no published pricing page, no tiered plans, and no enterprise sales motion visible yet — it reads as a working studio/tool you clone, run, and adapt rather than something you subscribe to today. If you need a supported, contracted, enterprise-grade deployment, you're not going to find one here yet; if you want to experiment with the modeling approach on your own documents, the barrier to entry is a git clone, not a credit card.

How it compares

	Pennant	Palantir Foundry	Neo4j	Roam Research
Price	Not published; open project, no listed tiers	Custom enterprise contracts, typically six figures annually, no public self-serve tier	Free (AuraDB Free), Professional from ~$65/month, Enterprise custom	$15/month monthly, $165/year annual, $500 one-time "Believer" 5-year plan
Core unit	Typed nodes + typed relationships built for checkability (claims, obligations, evidence)	Ontology-driven data integration across enterprise systems	General-purpose property graph database and query engine (Cypher)	Bidirectional-linked outline blocks for notes
Verification focus	Explicit contradiction detection and arithmetic checks on the graph	Data lineage and operational analytics at enterprise scale	Query results only as reliable as the data modeled; no built-in claim/evidence semantics	None — designed for freeform note association, not claim verification
Best for	Analysts who need arguable, checkable models of claims/obligations/evidence in a specific document or domain	Large organizations integrating messy operational data across many systems	Developers building graph-backed applications or running graph analytics at scale	Individuals doing freeform networked note-taking and journaling
Setup	Clone repo, run locally, structure your own domain	Managed enterprise deployment via Palantir sales/implementation team	Self-hosted or managed cloud (AuraDB), SDKs in multiple languages	Sign up, use hosted web/desktop app immediately

Should you try it today

If your problem is genuinely "I need to argue about whether X follows from Y with receipts," not "I need a nicer note-taking app" or "I need to integrate ten enterprise data sources," Pennant is worth an afternoon of cloning and testing against a real document you already know well — a contract, a research thread, a budget. It won't replace Foundry-scale data integration or Neo4j-scale graph infrastructure, and it's not a Roam-style daily notes tool. It's narrower and newer than all three, with no pricing model yet because it isn't a commercial product yet — treat it as an early studio tool to pressure-test the checkable-knowledge-model idea, not as a vendor you're signing a contract with this quarter.