THE LOGIC OF RESOLUTION
Tacitus does not just summarize emails. It reconstructs the topology of the conflict: who is involved, what they really want, which constraints bind them, and where common ground can realistically emerge. The Deep Analysis view is the narrative layer on top of the same ontology and conflict graph used across the Tacitus platform.
HOW THE ENGINE “THINKS” ABOUT CONFLICT
ONTOLOGY STABLEEvery Tacitus analysis runs on a shared conflict ontology. Instead of treating disputes as “angry text blobs”, we decompose them into structured elements that show who is involved, why they care, what binds them, and where resolution can realistically emerge.
Individuals, teams, boards, ministries, factions. Nodes in the graph; each with role, power, mandate, and red lines.
What they actually care about beneath stated positions: security, recognition, fairness, continuity, autonomy, identity.
Law, budgets, coalitions, reputations, time horizons. Hard limits on what a “solution” can demand without causing collapse elsewhere.
Alliance, dependency, rivalry, mediation, veto power. In the UI: structural ties vs narrative ties (who listens to whom, who shapes the story).
The “Zone of Possible Agreement” emerges where interests overlap and constraints permit. Tacitus continuously searches for those intersections and tests how stable they are.
> parse_emails() → extract_actors() → infer_interests() → map_constraints() → build_graph()
> resolution_logic = graph.search_paths(common_ground & mandate & minimal_cost)
> output: conflict_map, leverage_points, recommended_steps
THE TACITUS ONTOLOGY AGENT
DETERMINISTIC ENGINEThe Tacitus Ontology Agent is the core reasoning module that turns raw, emotionally charged communication into a stable, machine-readable conflict model. Where generic LLMs fluctuate with wording or tone, the Ontology Agent runs through a deterministic pipeline grounded in negotiation theory, human needs research, and formal argument mapping.
Drawing on work from Fisher & Ury (interests vs. positions), Burton (human needs: security, identity, recognition), Kelman (interactive problem-solving), Zartman (ripeness and mutually hurting stalemates), and Walton/IBIS-style argument schemes, Tacitus encodes recurring conflict patterns into a fixed schema. The goal is simple: same inputs, same structure, every time.
> deterministic_extract(actors)
> deterministic_extract(interests)
> deterministic_extract(constraints)
> deterministic_extract(relationships)
> deterministic_extract(zopa_signals)
> assert(stability_of_ontology == true)
>> FOUR-STAGE REASONING PIPELINE
1. IDENTIFICATION
Extracts all actors, claims, demands, and explicit positions from emails, memos, minutes, and briefings. Uses hybrid NER and rule-based normalization to map “the board”, “our investors”, or “legal” into coherent Actor nodes.
2. INFERENCE
Infers latent interests behind positions: “I deserve 60%” → authorship and recognition; “I can’t sign this” → reputational or legal risk. The Agent draws on conflict-psychology patterns: identity, fairness, autonomy, continuity, security.
3. STRUCTURING
Builds a constraint matrix (law, calendars, budgets, veto thresholds, coalitions) and a relationship graph (alliances, dependencies, rivalries, influence lines, mediation channels). Distinguishes hard constraints from soft preferences.
4. COMPUTATION
Runs graph algorithms: centrality, shortest paths, bottlenecks, coalition fragility, overlap of interests. Computes ZOPA candidates, likely escalation paths, and minimal-cost resolution sequences. These outputs feed Tacitus’ narrative reports and simulations.
>> OUTPUT ARTIFACTS
Every Ontology Agent run produces a consistent set of artifacts:
- > Actor registry: roles, power scores, mandates, red lines
- > Interest map: explicit and inferred motivations, with strength scores
- > Constraint matrix: hard vs. soft constraints, time and law overlays
- > Relationship graph: alliances, veto edges, mediation channels, trust lines
- > ZOPA candidates: overlapping interests plus feasible concessions
- > Escalation projections: where the conflict is likely to fracture
- > Resolution scripts: evidence-backed pathways expressed in plain language
Tacitus uses LLMs for language, but not for logic. The logic is governed by a stable ontology and deterministic reasoning, so that organizations can trust the structure beneath each recommendation.
> input: messy narrative
> output: structured conflict_graph + zopa_pathways
> key_property: deterministic_logic ∧ pluralist_ontology ∧ explainable_outputs
WHY WE MODEL CONFLICT AS A GRAPH
CRUCIAL DISTINCTIONSemantic search is powerful for finding similar text. Resolution requires more: you need to see where power flows, where trust breaks, who can bridge factions, and which paths avoid triggering vetoes. That is why Tacitus commits the ontology to a graph database and exposes it in the Ontology & Conflict Graph view as an explorable map.
>> SEMANTIC SEARCH
"Show me emails similar to: ‘We should delay the vote’."
Excellent for finding text but blind to structure. It knows which sentences are similar, not how influence and constraints interact. It can cluster themes, but it cannot tell you who can actually unlock a stalemate.
- > Finds related messages
- > Clusters topics and tones
- > Misses leverage, vetoes, and structural risk
>> GRAPH DATABASE
"Show all paths from Actor A to Actor B that avoid crossing a hard veto and minimize reputational risk."
Graph DBs (Neo4j-style / property graphs) let Tacitus ask questions about relationships and power: centrality, bottlenecks, potential mediators, fragile alliances, vulnerable nodes.
- > Model: (Actor)-[RELATION]->(Actor)
- > Structural queries: “Who can pressure X without escalating Y?”
- > Output: actual options, not just similar sentences
>> HOW THE ONTOLOGY POPULATES THE GRAPH
The Ontology Agent sends its outputs to a property graph where each element becomes a node or edge:
(Actor)-[:SEEKS]->(Interest)
(Actor)-[:CONSTRAINED_BY]->(Constraint)
(Actor)-[:IN_RELATIONSHIP {type: "alliance" | "rivalry" | "dependency"}]->(Actor)
(Interest)-[:COMPATIBLE_WITH]->(Interest)
(Constraint)-[:LIMITS]->(Solution)
This lets Tacitus combine semantic similarity (what emails sound alike) with structural reasoning (who matters, where risk sits, how to get from A to B without breaking the system). As new emails and documents arrive, the graph updates—turning the platform into a living conflict model rather than a one-off analysis.
> MATCH (a:Actor)-[r:CONFLICTS_WITH]->(b:Actor)
> WHERE a.role = "CEO" AND b.cluster = "Board"
> RETURN a, b, r, shortestPath( (a)-[*..4]-(b) ) AS mediation_routes
> resolution_logic: semantic_similarity overlays the graph, but decisions run on structure.
FROM THEORY TO LIVE CASES
STRUCTURE OVER STORIESThe same ontology and graph logic applies to founder disputes, M&A friction, urban planning, political coalitions, and diplomatic crises. Below are three stylized Case Files that show how Tacitus treats conflicts as structured systems, not anecdotal drama.
FOUNDER DISPUTE: "THE PIVOT"
HIGH ENTROPYA classic founder dispute: two truths in collision. One says, “I built the architecture.” The other says, “I saved the company.” Both are right. Both exclude the other. Tacitus models this not as a simple fight over percentages, but as a clash of authorship, risk, and recognition.
>> STAKEHOLDER NARRATIVES
"I built the core IP. The pivot was my architecture. I deserve 60%."
"The code is useless without the clients I brought. I saved the runway."
>> GRAPH READING & COMMON GROUND
> analyzing_incentives()... DONE
> mutual_threat: "Down-round and talent loss if dispute persists into Q3"
> shared_value: "Preserving the legacy of the original mission"
> leverage_point: "Upcoming fundraise forces public narrative clarity"
> STRUCTURAL VIEW: both depend on each other to avoid a governance crisis.
> RECOMMENDATION: Reset vesting & titles as co-authors of “Act II” of the company, framed explicitly in external narrative. Avoid retroactive punishment; anchor solution in shared future credit.
POST-MERGER: "SPEED VS SAFETY"
DIVERGENCE DETECTEDThe conflict is framed as “reckless cowboys” vs “bureaucratic dinosaurs”. Tacitus reveals it as a mismatch of time horizons and risk grammars: a weekly clock colliding with a quarterly one.
"Compliance is bureaucracy." Horizon: Week — shipping velocity, optionality, survival-by-momentum.
"Process is protection." Horizon: Quarter — risk management, regulators, brand, long-term capital.
Structural breakdown imminent if no shared frame emerges.
> SYNTHESIS: Conflict ≠ “laziness” (corp view) nor “stupidity” (startup view).
> ROOT_CAUSE: Incompatible temporal horizons and incompatible definitions of “responsibility”.
> GRAPH_LOGIC: Critical decisions bottleneck through one director with veto on both sides — a structural choke point.
> BRIDGE: Create a "Sandboxed Compliance" zone.
> IMPLEMENTATION: Startup moves fast inside a bounded risk envelope; Director is recast as a “Boundary Guardian” rather than “Blocker”; Corp gets documented guardrails; Startup retains its identity as a high-velocity unit.
URBAN PLANNING: "THE NEW TOWER"
RESOLVEDUrban disputes are rarely just about zoning or shadows. They are about whether a community sees itself reflected in the future being built around it. Tacitus models this as an asymmetry between formal power and narrative centrality.
>> SURFACE TEXT
"The traffic will be a nightmare. The shadow will kill the park."
>> DECODED FEAR
"We are being erased. Our history doesn't matter to the city."
> Tacitus maps Residents as a cluster with high narrative centrality but low formal power.
> Developers + City Hall hold formal power but face legitimacy risk if residents disengage or mobilize opposition.
> RESOLUTION_LOGIC: binding design covenant (height cap, park investment) + explicit narrative recognition (“this project completes the story of the old neighborhood, it does not overwrite it”).
> RESULT: Shared vocabulary of "neighborhood vitality" replaces abstract fight over "density vs heritage".
FROM POLARIZATION TO DELIBERATION
CONCORDIA DISCORSTacitus is built on a simple, hard truth: competing values are not a bug of politics or organizations, they are the starting point. The goal is not to erase disagreement, but to make it legible and governable.
We search not for “agreement on everything”, but for narrow, actionable overlaps: a clause both sides can live with, a sequence of steps both can defend in public.
Deliberation is modeled as an iterative update to the conflict graph: each round removes some edges (misperceptions) and adds others (new guarantees, new channels of trust).
Polarization shows up as disconnected subgraphs: clusters that no longer share channels of trust. Tacitus highlights potential “bridge nodes” that can still speak to both.
> step_1: reveal_structure(conflict_graph)
> step_2: identify_bridge_nodes(actors, trust_edges)
> step_3: simulate_deliberation_rounds() → project_plausible_paths()
> step_4: recommend_actions() aligned_with(mandate, risk_tolerance, ethics)
CONCORDIA DISCORS & THE TACITUS PHILOSOPHY
PLURALISM ENGINE>> WHAT IS CONCORDIA DISCORS?
Concordia Discors is the editorial sister to Tacitus: a magazine of essays on liberty, conscience, pluralism, and polarization. It treats disagreement not as pathology but as the normal condition of a free society.
The phrase concordia discors means “discordant harmony”: the idea that political and moral life are made of conflicting goods that must be balanced rather than eliminated. Drawing on thinkers like Raymond Aron, Isaiah Berlin, Tocqueville, Simone Weil, and others, the magazine explores how societies can live with deep difference without collapsing.
>> WHY IT MATTERS FOR AI & RESOLUTION
Tacitus does not try to compute a single “correct” value system. Our ontology is explicitly pluralist: different actors can legitimately care about different goods (security, fairness, identity, mercy, order, autonomy).
In the Tacitus worldview:
- > Competing values are normal
- > Conflict is information
- > Common ground is discovered, not imposed
- > Pluralism is a data structure, not a slogan
This is why the Tacitus graph is built to handle competing values instead of flattening everything into “for” or “against”. The same intellectual stack that powers Concordia Discors essays about polarization also powers the Tacitus Engine for live conflicts.
>> Run This Analysis on Your Data
Tacitus connects to your real communication graph (email, memos, minutes) in read-only mode. We build an initial conflict ontology and graph in days – and refine it with you over time.
Start Pilot