TACITUS is the company building PRAXIS — the AI analyst workbench for statecraft, policy, and mediation — powered by DIALECTICA, a neurosymbolic knowledge-graph engine that makes conflict reasoning structured, auditable, and contestable. Wind Tunnel and CONCORDIA apply the same backbone to political reaction risk and mediation intelligence.

How is TACITUS different from standard LLMs?

Standard LLMs lack persistent memory, cannot track temporal ordering of events, and hallucinate on conflict facts. TACITUS provides a deterministic knowledge graph layer that grounds LLM reasoning.

What industries does TACITUS serve?

TACITUS serves policy teams, mediators, diplomatic analysts, peace and security practitioners, institutional governance teams, HR and legal dispute teams, and researchers working with complex contested situations.

What products are in the TACITUS suite?

PRAXIS is the flagship: the AI analyst workbench for statecraft, policy, and mediation. DIALECTICA is the trust graph and context layer underneath PRAXIS. Wind Tunnel models political reaction risk, and CONCORDIA provides mediation intelligence for live or asynchronous dialogue.

How does TACITUS work?

TACITUS combines a deterministic typed knowledge graph with LLM reasoning. Unstructured text about policy situations, conflicts, negotiations, and institutional disputes is extracted into a graph using an 8-primitive ontology (Actor, Claim, Interest, Constraint, Leverage, Commitment, Event, Narrative), preserving temporal ordering, causal chains, and source provenance.

Is TACITUS open source?

The TACITUS Knowledge Pipeline and the Agentic Conflict Ontology (ACO) are open source on GitHub under an MIT license. PRAXIS, Wind Tunnel, and CONCORDIA are commercial offerings with free demo access available; DIALECTICA, the engine, ships as both an open reference and a hosted runtime.

What is the Agentic Conflict Ontology (ACO)?

The ACO is a formal knowledge representation with 8 primitives (Actor, Claim, Interest, Constraint, Leverage, Commitment, Event, Narrative), 41+ typed classes, and 29+ typed properties. It is a universal grammar for structuring disputes, from HR grievances to peace processes.

Does TACITUS try to replace mediators or judges?

No. TACITUS is legibility infrastructure, not adjudication. The engine structures a dispute against the ontology and shows every party the same map. Decisions about compromise, fairness, and outcome remain with humans.

BENCHMARK · FIRST SPECIALIZATION · v0.1-sample PUBLIC · v0.2 IN DEVELOPMENT

The TACITUS Conflict Grammar Corpus.

The first specialization of the knowledge layer measured in public. Conflict reasoning stresses every property of the layer at once — time, causality, provenance, commitment tracking, interest/position separation, narrative drift, cross-actor contradiction. If the layer holds here, the architecture generalizes to policy options, regulatory work, and mediation. TCGC is how we make that claim falsifiable.

Grounded in the kernel ontology with dynamic extensions. v0.2 introduces three task types for dynamic-ontology behavior. Other specializations (policy options, regulatory contestation, ADR) get their own benchmarks as they mature.

The full corpus is under a light data-use agreement. A public sample (v0.1, 5 items) plus the item schema are available right here on this page, so any agent, model, or researcher can start running against the format today.

Download sample (JSON)Item schema Benchmark repo

Task types

v0.2 task types

Domains

Sample items

480+

Full target

QUICK-START FOR MACHINES

Start running against the v0.1 format today.

Download the sample, validate against the schema, run your system, report per task-type. A thin adapter for HELM and lm-eval-harness ships alongside the full release; for now, loop over the items directly.

sample item · tcgc-0001view full sample →

{
  "id": "tcgc-0001",
  "task_type": "commitment-tracking",
  "domain": "workplace",
  "inputs": {
    "messages": [
      { "day": 1, "time": "Mon 09:14", "from": "Sam",
        "text": "So we're agreed — you own the Q4 launch deck content,
                 I handle design. Lock it in by Thursday?" },
      { "day": 1, "time": "Mon 09:47", "from": "Alex",
        "text": "Sounds good. I'll pick it up after the Jenkins pitch." },
      { "day": 4, "time": "Thu 09:02", "from": "Alex",
        "text": "I never said I'd own it. Just help." }
    ],
    "question": "Was there a commitment on content ownership,
                 when was it made, and who asserted it?"
  },
  "gold": {
    "commitment_id": "cm1",
    "subject":       "Q4 launch deck content",
    "deadline":      "Thursday",
    "status":        "contested",
    "edges": [
      { "from": "Sam",  "to": "cm1", "type": "ASSERTED",
        "provenance": "msg1" },
      { "from": "Alex", "to": "cm1", "type": "ACKNOWLEDGED_AMBIGUOUSLY",
        "provenance": "msg2" },
      { "from": "Alex", "to": "cm1", "type": "DENIES_SCOPE",
        "provenance": "msg3" }
    ]
  },
  "rubric": {
    "scoring":              "graph_overlap + provenance_f1",
    "graph_overlap_target": 0.85,
    "provenance_f1_target": 1.0
  }
}

Validate

Check every item you plan to score against the JSON Schema at /tcgc/schema-v0.1.json. Reject items that fail validation instead of silently coercing.

Run

For each item, call your system with item.inputs and receive a predicted structure. Do not peek at item.gold.

Score

Apply the metric named in item.rubric.scoring. Report per-task-type numbers; aggregate only after publishing the breakdown.

Submit

Email the results (metric-by-task CSV plus a short system card) to hello@tacitus.me or open a PR on the benchmark repo.

WHAT THE TCGC MEASURES

Fourteen task types.

Each task type targets a specific capability that standard retrieval-augmented generation cannot handle reliably. Metrics are reported per task type and per domain; aggregates come later.

Actor resolution

actor-resolution

Disambiguate references and alias clusters across long documents.

Claim extraction

claim-extraction

Surface asserted facts, evaluative statements, and normative claims.

Interest extraction

interest-extraction

Infer underlying interests distinct from stated positions (Fisher/Ury).

Constraint extraction

constraint-extraction

Identify rules, norms, and structural bounds shaping feasible outcomes.

Leverage mapping

leverage-mapping

Attribute leverage resources and dependencies to the actor holding them.

Commitment tracking

commitment-tracking

Distinguish claims from commitments and track their evolution over time.

Event ordering

event-ordering

Reconstruct temporal sequence from mixed narrative prose.

Narrative drift

narrative-drift

Detect framing changes across time and party.

Causal chain reconstruction

causal-chain

Build multi-hop causal chains with explicit mechanism and conditions.

Contradiction detection

contradiction-detection

Identify claims that cannot simultaneously hold across actors or time.

Provenance attribution

provenance-attribution

Bind every extracted primitive back to its source span.

Commitment / claim mismatch

commitment-claim-mismatch

Flag instances where stated commitment diverges from behavioral evidence.

Position / interest separation

position-interest-separation

Separate surface positions from underlying interests.

Cross-document synthesis

cross-document-synthesis

Assemble a coherent conflict graph from multiple, partially-contradictory sources.

v0.2 · DYNAMIC ONTOLOGY

Three task types for the kernel-with-extensions design.

v0.2 measures whether a system can induce per-case extensions, validate them against the kernel, and transfer primitive recognitions across domains. In development.

Schema extension induction

schema-extension-induction

Given a case in a new domain, induce the per-case extension subclasses for one or more kernel primitives, and validate them against kernel invariants.

Kernel invariant validation

kernel-invariant-validation

Given a proposed extension subclass, decide whether it preserves the parent primitive's invariants. Adversarial split includes plausible-but-invalid extensions.

Cross-domain primitive transfer

cross-domain-primitive-transfer

Given a typed graph from domain A (e.g. HR mediation) and a case from domain B (e.g. ceasefire), transfer the kernel primitive recognitions while letting the extensions specialize.

BASELINES AND WHAT THEY TEST

The benchmark is designed to separate fluency from structure.

TCGC will report against model-only, RAG, GraphRAG, and TACITUS reference systems. The goal is not to crown one model. The goal is to show which architecture preserves the relationships professionals need to inspect.

Zero-shot frontier model (2026 cohort)

Closed-book / prompt-only runs against the GPT-5, Claude Opus 4.x, Gemini 2.5/3, and Llama 4 families. Useful for measuring whether fluency hides missing structure. Headline finding so far: domain-general policy benchmarks land in the 48–54% range — comprehension is not the same as reasoning.

Strong RAG baseline

Chunk retrieval plus cited generation. Useful for measuring source access without explicit relationships. Performs well on extraction and citation, weakly on commitment tracking, contradiction detection, and temporal reconstruction.

GraphRAG / contextual GraphRAG

Entity-and-relationship graph retrieval over the same corpus, including community-summarization variants. Useful for comparing domain-general graph retrieval to ACO-typed graph construction. Most public GraphRAG systems do not enforce an ontology, which limits neurosymbolic grounding.

Hybrid neurosymbolic system

A reference combining vector retrieval, KG traversal, and ontology-typed extraction. The 2025–2026 production trend in agent-era architectures. Closer to DIALECTICA in spirit; useful for separating engine effects from data effects.

TACITUS / DIALECTICA reference

DIALECTICA with ACO-typed primitives, graph-overlap scoring, source-span provenance, temporal DAG, causal edges, and task-specific evaluators. The system PRAXIS runs on. Reported as a reference, not a leaderboard winner; if a simpler baseline matches us on a task type, we say so.

FRONTIER MODEL COVERAGE · 2026 COHORT

The benchmark is run against frontier systems, not against last year’s ones.

TCGC tracks every major frontier-tier release as it lands. We re-run the corpus on new model versions and publish deltas. Generic policy benchmarks across 2026 (RAND, PolicyBench) report 48–54% accuracy on policy comprehension — TCGC measures the harder layer underneath: structure, time, causality, and provenance.

Vendor	Models tracked	Notes
Anthropic	Claude Opus 4.7, Sonnet 4.6, Haiku 4.5	Best long-context provenance behavior in our 2026 runs; cost-aware Sonnet suitable for graph-grounded loops.
OpenAI	GPT-5, GPT-4.1	Strong on extraction; weaker on multi-hop commitment tracking without scaffolding.
Google	Gemini 2.5 Pro, Gemini 3	Strong document comprehension; multimodal helps for cable-and-image corpora.
Meta	Llama 4 (open-weights families)	Useful for self-hosted statecraft contexts. Pairs well with on-prem KG.
xAI / Mistral / DeepSeek	Grok 3, Mistral Large 3, DeepSeek R2	Tracked as comparators; benchmarked on the same TCGC items.

Submission status snapshot — the leaderboard is open. Frontier vendors and self-hosted builders are invited to submit. Methodology, schema, and evaluators are public.

DOMAINS COVERED

Seven domains, shared ontology.

workplace

HR grievances, performance disputes, promotion blocks

commercial

Contract breach, vendor dispute, joint-venture friction

governance

Board disagreement, mandate conflict, committee deadlock

peace-process

Ceasefire, DDR, political-track multilateral negotiation

policy

Regulatory contestation, stakeholder reception, public-consultation aftermath

family

Inheritance, custody arrangement, intergenerational wealth dispute

diplomatic

State-to-state friction, border incident, multilateral block formation

SCORING RUBRIC

Five metrics, five shapes of task.

Every item names its scoring method in rubric.scoring. Systems report per-metric numbers; we do not collapse to a single headline score.

graph_overlap|gold ∩ pred| / |gold ∪ pred|

Jaccard over the typed subgraph the system returns vs the gold subgraph. Partial-credit aware.

commitment-trackingcross-document-synthesiscausal-chain

provenance_f12·P·R / (P + R) on source-span matches

Every primitive must cite the span it was extracted from. Exact span match scores full; overlapping span scores partial.

provenance-attributioncontradiction-detection

kendall_tauRank correlation against gold chronological order

Dates are stripped on ~50% of items. The system must reconstruct order from discourse cues.

event-ordering

contradiction_pair_f1F1 over identified contradicting (claim_a, claim_b) tuples

Weighted variant upscales contradictions the mediator flags "material", downscales cosmetic ones.

contradiction-detection

llm_judge_anchoredLLM-judge score, anchored to a human-annotator calibration set

For interpretive tasks. The anchor set keeps the judge within the bounds of trained human judgment.

interest-extractionposition-interest-separationnarrative-drift

LEADERBOARD · SUBMISSIONS OPEN (v0.1 SAMPLE)

First submissions land here.

We are collecting a first cohort of v0.1-sample runs from the obvious baselines plus any system that wants to self-submit. Submissions are audited; scoring scripts ship in the benchmark repo.

Systemv0.1 sampleFull TCGCCard

TACITUS Dialectica (reference)tbdtbd—

GPT-4-class zero-shotpendingpending—

Claude 3-class zero-shotpendingpending—

Strong RAG baselinependingpending—

GraphRAG baselinependingpending—

Want to run against the sample and land on this board? Email hello@tacitus.me with your system card.

METHODOLOGY

How it is built.

TCGC items are drawn from two macro-domains: human friction (HR, commercial, governance) and complex multi-party scenarios (policy, peace process, multilateral), with intentional diversity in length, source mix, and discourse style.

Annotation proceeds in three passes: primitive tagging, edge labelling, and ground-truth question authoring. Inter-annotator agreement targets are task-type specific; tasks that depend on inferred primitives (like Interest) have lower targets than surface-level tasks (like Actor resolution), and we report the actual agreement transparently.

The evaluation harness is designed to be compatible with standard runners (HELM, lm-eval-harness) via a thin adapter. The adapter ships alongside the first public split. Every metric named in rubric.scoring has a reference implementation in the benchmark repo.

OPEN RESEARCH QUESTIONS

What we are still figuring out.

Eight questions we do not yet have clean answers for. The last two are about v0.2’s dynamic-ontology scoring. Click each to read the current thinking and tell us where it is wrong.

Q1How do we evaluate "interest extraction" when interests are never stated?+

Interests live beneath claims. Annotating them means annotator inference, which means inter-annotator agreement suffers. We are testing a tiered annotation protocol: stated, inferred-with-citation, analyst-reconstructed, with separate agreement targets for each tier. Open question: is agreement even the right metric when the gold standard is itself interpretive?

Tell us where this is wrong

Q2What is the right metric for contradiction detection?+

Straight F1 on pairs of contradictory claims misses the shape of the thing. A conflict may contain a dozen small contradictions, of which only two are load-bearing. We are piloting a weighted metric that upscales contradictions the mediator marks as "material." Still too narrow to be the primary score.

Tell us where this is wrong

Q3How do we handle ontology disagreement across domains?+

The ACO is designed to be domain-general. But HR investigators and peace mediators disagree, productively, on what counts as a Commitment or a Leverage primitive. Our working answer: maintain domain-specific subclasses beneath the primitive roots, and report per-subclass numbers alongside primitive-level numbers. This is not settled.

Tell us where this is wrong

Q4How do we measure "temporal reasoning" without overfitting to date extraction?+

It is trivially easy to write a benchmark where strong temporal reasoning correlates almost perfectly with good date-string extraction. We do not want to reward that. TCGC temporal tasks deliberately strip explicit dates from half the items, forcing systems to reconstruct ordering from discourse cues.

Tell us where this is wrong

Q5What is the right baseline?+

We plan to report against: GPT-4-class and Claude 3-class zero-shot; a strong RAG baseline; a GraphRAG baseline; and a few small specialized extractors. The TACITUS neurosymbolic system is the reference point, not the only point. If a simpler baseline matches us on a task type, we say so.

Tell us where this is wrong

Q6Should the TCGC include adversarial examples?+

Adversarially-crafted items, where the surface reads one way but the structure goes another, are the most diagnostic and the most gameable. We are leaning toward a separate adversarial split, clearly labelled, used for stress-testing rather than headline scores.

Tell us where this is wrong

Q7How do we score schema-extension induction without rewarding overfitting?+

A model that proposes a new extension for every case will trivially "induce" extensions; one that proposes none will trivially be conservative. The right metric rewards extensions that (a) preserve kernel invariants, (b) recur across cases when the domain warrants, (c) are accepted by domain practitioners on review. We are piloting a three-part metric. Open question.

Tell us where this is wrong

Q8When does an extension graduate to the kernel?+

If an extension subclass shows up across many cases and many domains and proves stable, should it become a kernel-level primitive? The conservative answer is "almost never" — kernel changes are versioned, and stability is the point. The open question is what the formal review criterion should be.

Tell us where this is wrong

HOW TO CONTRIBUTE

Four ways in.

TIER 01

Run v0.1 sample

Download the 5-item sample, run your system, send results. First entries land on the leaderboard stub above.

Download sample

TIER 02

Read the protocol

The v0.1 evaluation protocol is in the benchmark repo. Comments accepted on annotation guidelines, task-type definitions, and metric choices.

Open repo

TIER 03

Request full-corpus access

Full-corpus splits are available to academic researchers and pilot partners under a light DUA. Write in with your proposed use case.

Request access

TIER 04

Propose a new task type

Found something the 14 current task types miss? Send us a one-paragraph proposal: motivation, worked example, suggested metric.

Propose a task

PUBLICATION PLAN

Q3 2026TCGC v0.2 spec frozen: dynamic-ontology task types, scoring rubric, public sample.
Q4 2026TCGC dataset paper: arXiv preprint, then workshop submission.
Q1 2027OAG methodology paper: target ACL submission, open-source reference implementation alongside.
Q2 2027TCGC v0.3: multi-language extension, adversarial split, first third-party annotator cohort.

Read, critique, or run.

Download sample Benchmark repo Vision paper