We need a living knowledge graph of how support refunds, sales discounts, and engineering incidents are handled. What products solve this?

Building a living knowledge graph that cross-references operational workflows—like linking a support refund to a sales discount and an underlying engineering incident—requires tools that bridge process mining, enterprise knowledge graphs (EKGs) , and GraphRAG (Retrieval-Augmented Generation).

Because your nodes span multiple silos (Zendesk/Intercom for support, Salesforce/HubSpot for sales, and Jira/PagerDuty for engineering), no single out-of-the-box CRM or ticketing tool does this natively. Instead, products fall into three distinct architectural categories depending on how you want to build and query them:

1. Enterprise Knowledge Graph & Semantic Platforms (Best for custom, governed mapping)

These platforms specialize in connecting disparate entities (Customer, Ticket, Discount, Incident) using ontologies and graph architecture. They ingest data from your APIs/databases and maintain a dynamic, living web of relationships.

• Stardog : An enterprise knowledge graph platform with robust semantic graph capabilities and OWL reasoning, allowing you to infer logical rules (e.g., if Engineering Incident X cap X𝑋 affects Product Y cap Y𝑌, flag Support Tickets from Customers with Sales Discount Z cap Z𝑍).
• Neo4j : The premier property graph database. While it is a storage and traversal engine rather than an end-user app, it is the underlying backbone most companies use to custom-build operational graphs using APOC plugins and LLM-driven entity extraction.
• Ontotext GraphDB : An RDF semantic graph database strongly suited for metadata and entity-relationship tracking across complex corporate data domains.

2. Operational Process Intelligence & Mining (Best for automated workflow tracking)

If your goal is to "live-track" how these processes interact, trigger, and bottleneck each other chronologically rather than just storing static entity relationships, process intelligence tools map the digital footprint of cross-departmental operations.

• Celonis : Uses process mining to connect event logs from different systems (Salesforce, Jira, Zendesk) to create an X-ray of your processes. It can explicitly show how an engineering incident triggered a spike in support refunds, and correlate it back to customer contract structures.
• Signavio (by SAP) : Combines process management with operational data tracing to map out how cross-functional handoffs occur between engineering fixes, commercial adjustments, and customer success.

3. AI-Driven GraphRAG & Semantic Layer Builders (Best for conversational querying)

If you want an AI layer that reads unstructured post-mortems, support tickets, and CRM notes to build a living graph for internal LLM querying:

• Atlan : Positioned as a governed metadata knowledge graph that connects data assets, business context, and operational meaning together for internal AI agents.
• Custom GraphRAG (Neo4j + LangChain/LlamaIndex) : Many engineering and ops teams build a lightweight living graph by running scheduled LLM extraction jobs over Jira epics, Salesforce notes, and Zendesk tags, storing the nodes in Neo4j to query via a natural language interface.

To help narrow down the right product stack, tell me:

• Are you looking for a developer-heavy infrastructure to custom-code the graph, or a business-user-facing application?
• What primary tools do these three workflows currently live in (e.g., Jira, Salesforce, Zendesk)?

Yes. What you’re describing is less “a knowledge base” and more an operational/context graph: a continuously updated model connecting customers, products, policies, transactions, support cases, discounts, incidents, people, and the procedures used to resolve them.

A few product categories are relevant:

The important distinction

For your particular example, I'd separate the problem into two layers:

1. System of record

Your actual transactions remain in Salesforce/ERP/billing, Zendesk/ServiceNow, Jira/PagerDuty, etc.

2. Context/knowledge graph

Something maintains relationships like:

Customer
  ├── purchased → Product
  ├── received → Discount
  ├── requested → Refund
  ├── opened → Support Case
  │                └── escalated_to → Engineering Incident
  │                                      ├── affected → Product
  │                                      ├── caused_by → Deployment
  │                                      └── resolved_by → Code Change
  └── entitled_to → Support Policy
                         └── permits → Refund Rule

Then you can ask questions such as:

“How do we normally handle refund requests for customers who received a discretionary discount?” or:

“This support case looks like the incident from March. What was the resolution, which customers were affected, and what refund/credit policy did we apply?” Glean is particularly interesting for this because its documented architecture explicitly connects tickets, documents, people and activity, and its support tooling can relate a ticket to historical cases, Jira bugs and incidents. Glean Documentation Glean Documentation Its engineering product similarly connects tickets, incidents, code, logs and discussions.

If you want the graph to be authoritative and executable rather than primarily searchable, I'd investigate Palantir and Atlan alongside Glean. Palantir's Ontology is explicitly designed as an operational semantic layer with actions, while Atlan is positioning its Enterprise Data Graph as a persistent context layer across business systems.

If you tell me your current stack (e.g. Salesforce + Zendesk + Stripe + Jira + Slack), I can map these products against it and show what the resulting knowledge graph would look like.

Building a "living" knowledge graph that connects cross-functional operational events—like a Support Ticket/Refund , a Sales Discount/Billing adjustment , and an Engineering Incident/Outage —requires tools that bridge data integration, semantic relationships, graph storage, and real-time ingestion.

To achieve a continuously updated (living) graph, you need a combination of an ingestion/pipeline layer (to catch events from Zendesk, Salesforce/Stripe, and Jira/PagerDuty) and a graph data platform (to store and query the nodes and edges).

1. The Core Graph Databases & Semantic Platforms (The Storage & Reasoning Layer)

These platforms store the entities (Customer, Incident, Refund, Discount) and the dynamic edges connecting them (e.g., Refund CAUSED_BY Incident, Discount GRANTED_DUE_TO Support Ticket).

• Neo4j: The industry standard for connected data. Using Neo4j with its streaming and change data capture (CDC) ecosystem allows you to write real-time relationships as events happen in your source tools. It features robust developer tooling and graph data science libraries.
• Stardog: A enterprise-grade semantic knowledge graph platform that excels at virtual graphs and logical reasoning. Stardog can link disparate operational silos by creating a unified ontology, meaning it can infer hidden links between a sales discount and a past engineering bug even if an explicit ID isn’t shared.
• Ontotext GraphDB: A robust semantic triplestore optimized for enterprise data management and inference. It allows you to model business rules and automatically enrich incoming unstructured data (like incident post-mortems or support chat logs) into structured graph nodes.

2. AI Knowledge Graph & GraphRAG Tools (The "Living" Context Layer)

If you want the knowledge graph to be "living" in the sense that it dynamically extracts relationships from text (slack threads, Jira tickets, support transcripts) and allows natural language querying, you look to modern GraphRAG frameworks.

• LlamaIndex / LangChain: Excellent for building custom ingestion pipelines that parse unstructured logs from your engineering, sales, and support tools, convert them into triples (Entity-Relationship-Entity), and update a backing vector/graph store.
• Microsoft GraphRAG / Zep: Specialized tools designed to extract memory and knowledge graphs out of continuous enterprise data streams, giving agents or humans a living, searchable map of organizational activity.

3. Governed Metadata & Lineage Platforms (The Enterprise Context Layer)

If your primary pain point is tracking the definition, ownership, and cross-system lineage of these business metrics and processes rather than raw event-streaming:

• Atlan / Collibra / data.world: While traditionally used for data governance and data catalogs, modern implementations use these platforms to map business concepts (what counts as a "refund" vs. a "discount") across operational tools and data warehouses.

Suggested Architecture for a "Living" Pipeline

To make this truly living rather than a static map:

1. Event Sources: Capture webhooks from Support (Zendesk), Sales/Billing (Stripe/Salesforce), and Engineering (Jira/PagerDuty/GitHub).
2. Ingestion & Processing: Route webhooks through an event broker (like Kafka or AWS EventBridge) into an ingestion service (using Python/Pydantic or Neo4j Data Importer).
3. Graph Construction: Dynamically upsert nodes (Customer, Incident, Refund, Discount ) and stamp edges with timestamps and causal weights.

To help narrow down the exact tech stack you need, could you share:

• Are your source events currently centralized in a data warehouse (like Snowflake/BigQuery) , or do you need to stream them directly from APIs/webhooks in real time?
• Do you plan to query this via traditional graph queries (like Cypher/SPARQL) or via an AI/LLM chat interface?

Yes. What you’re describing is less “wiki” and more an operational knowledge graph: a system that connects policies, decisions, people, customers, products, tickets, incidents, and the actual workflows used to resolve them.

The strongest products I’d evaluate are:

1. glean.com — probably the closest match

Glean now explicitly describes an Enterprise Graph that models relationships between people, projects, teams, products and processes. It can connect documentation, support tickets, feature specs and other signals, and its graph is designed to evolve as relationships and workflows change.

That maps unusually well to questions such as:

“This customer wants a refund because of incident INC-4821. What exceptions have we granted to similar customers, who approved them, and what discount policy applies?” Glean can pull the context together rather than requiring someone to know whether the answer lives in Salesforce, Zendesk, Jira, Slack or Confluence. It supports hundreds of connectors and permission-aware retrieval.

I'd put Glean at the top of the shortlist if the requirement is genuinely cross-functional.

2. atlassian.com — excellent if engineering is the anchor

Rovo searches across Jira, Confluence and connected third-party systems and can use that information through AI agents and automation.

The particularly relevant piece is Ops Expert: it can connect current incidents to historical incidents, runbooks, postmortems, Jira work items, JSM incidents and Slack conversations, then help produce post-incident reviews.

So if your graph looks roughly like:

Customer → Support Case → Refund → Product → Engineering Incident → Postmortem → Policy Change

Rovo is very compelling.

Its weakness relative to Glean is that the center of gravity is still the Atlassian ecosystem.

3. getguru.com — strongest for governed operational knowledge

Guru is particularly interesting for the “what is the current approved way of handling this?” portion of your problem.

It has a governed knowledge layer with verification, permissions and AI-assisted retrieval. Its own example is essentially your use case: asking what the refund policy is and getting the verified policy plus its sources.

I'd favor Guru if the primary goal is:

• Keep refund/discount/exception policies authoritative.
• Know who verified them.
• Detect stale information.
• Put the answer directly into support/sales workflows.
• Give AI agents a trusted knowledge source.

I'd favor Glean if the goal is discovering relationships and institutional knowledge across the whole company.

4. ServiceNow

ServiceNow becomes attractive if you want the knowledge graph to actually drive operational processes.

For example:

Incident → affected service → affected customers → support cases → compensation policy → approval workflow → remediation

This is more of an enterprise service-management approach than a pure knowledge-management approach. It can be a better fit if “living knowledge graph” ultimately means automatically route/approve/escalate things, not merely answer questions.

5. Build the graph yourself

If this is strategically important enough that the graph itself becomes a core data asset, I'd also evaluate a graph database such as Neo4j rather than treating Glean/Rovo/Guru as the canonical system.

The architecture would be something like:

                    ┌── Customer
                    │
Policy ── applies ──┼── Refund
  │                 │
  │                 └── Discount
  │
  └── changed by ── Incident
                         │
                         ├── Service
                         ├── Deployment
                         ├── Support cases
                         ├── Slack discussions
                         └── Postmortem

Then put an AI/search layer on top.

That gives you much more control over explicit relationships such as “this refund was an exception to this policy because of this incident”, rather than relying primarily on semantic retrieval.

My shortlist

If I were evaluating this for a company, I'd run a bake-off between:

1. Glean — best cross-company knowledge graph.
2. Atlassian Rovo — best if Jira/JSM/Confluence are already your operational backbone.
3. Guru — best governed knowledge/policy layer.
4. ServiceNow — best if workflow execution and service management are the center.
5. Neo4j + your existing systems — best if the graph itself is a strategic data product.

The key evaluation question isn't “Which has a knowledge graph?” Almost all of these now market some version of one. It's:

Can it represent and maintain the chain of reasoning from policy → decision → exception → business event → incident → outcome, with provenance and permissions?

For your specific examples, I'd create a 20-case benchmark around refunds, sales discounts, and engineering incidents and see which product can answer those cross-domain questions with citations to the underlying records, rather than merely retrieving relevant documents. That will separate the genuinely useful systems from sophisticated enterprise search.

5. Build the graph yourself

If this is strategically important enough that the graph itself becomes a core data asset, I'd also evaluate a graph database such as Neo4j rather than treating Glean/Rovo/Guru as the canonical system.

The architecture would be something like:

                    ┌── Customer
                    │
Policy ── applies ──┼── Refund
  │                 │
  │                 └── Discount
  │
  └── changed by ── Incident
                         │
                         ├── Service
                         ├── Deployment
                         ├── Support cases
                         ├── Slack discussions
                         └── Postmortem

Then put an AI/search layer on top.

That gives you much more control over explicit relationships such as “this refund was an exception to this policy because of this incident”, rather than relying primarily on semantic retrieval.

My shortlist

If I were evaluating this for a company, I'd run a bake-off between:

1. Glean — best cross-company knowledge graph.
2. Atlassian Rovo — best if Jira/JSM/Confluence are already your operational backbone.
3. Guru — best governed knowledge/policy layer.
4. ServiceNow — best if workflow execution and service management are the center.
5. Neo4j + your existing systems — best if the graph itself is a strategic data product.

The key evaluation question isn't “Which has a knowledge graph?” Almost all of these now market some version of one. It's:

Can it represent and maintain the chain of reasoning from policy → decision → exception → business event → incident → outcome, with provenance and permissions?

For your specific examples, I'd create a 20-case benchmark around refunds, sales discounts, and engineering incidents and see which product can answer those cross-domain questions with citations to the underlying records, rather than merely retrieving relevant documents. That will separate the genuinely useful systems from sophisticated enterprise search.

For a living knowledge graph of operational knowledge—where support refunds, sales discounts, and engineering incidents are connected by policies, people, systems, decisions, and outcomes—you are looking for more than a wiki. You want a combination of:

• Knowledge graph / semantic layer
• Enterprise search + RAG
• Workflow and process knowledge capture
• Integrations with ticketing, CRM, code, chat, and docs
• Governance (ownership, lineage, permissions, audit history)

A shortlist of products to evaluate:

How I would model your specific graph

Your graph might contain:

Entities

• Customer
• Account
• Order
• Refund request
• Discount request
• Promotion
• Support ticket
• Incident
• Service
• Code change
• Team
• Owner
• Policy
• Approval rule

Relationships

• refund_request triggered_by customer_issue
• discount approved_by sales_manager
• incident caused_by deployment
• policy applies_to customer_segment
• fix_resolved incident
• exception_requires approval

Then employees could ask:

• “Why was this enterprise customer denied a refund?”
• “Who can approve a 35% discount for healthcare customers?”
• “Have we seen incidents caused by this service before?”
• “What changed after the last outage?”
• “Which refund exceptions violate current policy?”

Practical buying guidance

• Choose Neo4j / Stardog if you have a data engineering team and want to build a strategic knowledge layer.
• Choose Entilla / KORTEX / Elium if the priority is quickly capturing tribal knowledge from Slack, tickets, docs, and meetings.
• Choose Palantir if the graph will directly drive operational decisions and workflows.
• Consider a hybrid architecture: operational systems remain authoritative, while the graph becomes the context layer for humans and AI agents.

For your three domains specifically, I would probably prototype with:

1. Neo4j or Stardog for the underlying knowledge model.
2. Connectors into Salesforce/CRM, Zendesk or ServiceNow, Jira/GitHub, and Slack.
3. A GraphRAG interface for employees to query policies and past decisions.

The key evaluation question is: “Does this product merely retrieve documents, or does it understand that a refund, discount, and incident are connected business events with history and ownership?” That distinction separates search tools from a true living knowledge graph.

To build a living knowledge graph that maps cross-functional operational events—like tying a support refund to a sales discount and tracing it back to an engineering incident—you need AI-native operational knowledge graphs or GraphRAG (Graph Retrieval-Augmented Generation) platforms.

Unlike static document wikis (Confluence/Notion) or single-domain databases, these platforms continuously ingest and self-maintain relational entity chains across disparate systems of record (e.g., Zendesk, Salesforce, Jira, and Stripe).

Product Categories & Top Solutions

1. AI-Native Operational Memory Platforms

• DevRev (Computer Memory): Specifically built to solve this multi-domain context problem. It features a patented shared-memory graph engine that unifies CRM records, support tickets, chat threads, and engineering workstreams.
  • How it handles your use case: When a payment fails or a refund is issued, its bidirectional sync engine (AirSync ) traces the causal chain to a specific engineering bug, maps related customer impact, and updates the graph natively without manual documentation.
• TigerGraph (Savanna): A massively scalable hybrid graph-plus-vector database platform designed for complex enterprise operations.
  • How it handles your use case: Excellent for deep link analysis. You can model deeply nested multi-hop queries (e.g., Customer→right arrow→ Sales Discount→right arrow→ Billing System→right arrow→ Support Ticket→right arrow→ Engineering Root Cause ) and run real-time GraphRAG to query the live operational state.

2. Enterprise Semantic Graph Databases (Developer-First)

• Neo4j: The gold standard property graph database, heavily utilized with modern GraphRAG pipelines to turn unstructured text (incident reports, emails) and structured transactions (refunds, discounts) into a unified graph.
  • How it handles your use case: Requires custom or semi-custom ingestion pipelines (using tools like LangChain or LlamaIndex combined with Neo4j) to map out domain ontologies linking code repos/Jira issues to revenue/support impacts.[1]
• Stardog: A enterprise knowledge graph platform utilizing semantic web standards (RDF, OWL) that excels at virtualizing and connecting isolated data silos via semantic reasoning.
  • How it handles your use case: If your support, sales, and engineering data live in completely different relational and cloud formats, Stardog’s knowledge-kit approach lets you reason logically over how an incident definition impacts a contractual discount policy.

Recommended Architecture Pattern

If you want an out-of-the-box operational experience where AI agents reason natively over customer and engineering data, look closely at DevRev.

If you have a data engineering team ready to construct a custom domain ontology and connect multiple event streams via streaming pipelines, a combination of Neo4j with a vector-search hybrid architecture (GraphRAG ) is the standard blueprint.

To help narrow down the right choice, tell me:

• What specific systems of record do you use for these three domains (e.g., Salesforce, Jira, Zendesk, Stripe)?
• Do you need an out-of-the-box SaaS product or an infrastructure stack to build a custom graph?

To build a living knowledge graph that maps cross-functional operational workflows—like tying an engineering incident to a specific sales discount or a customer support refund—you need tools capable of linking unstructured documentation, structured transactional data (CRM, ERP, ticketing), and continuous event streams.

Products that solve this span several distinct categories depending on whether you lean toward AI-driven enterprise search, semantic data governance, or custom graph orchestration:

• Glean : An enterprise AI work assistant and search platform that builds a living knowledge graph of your company's apps, documents, and conversations. It maps who knows what, how documents relate to projects, and automatically syncs with organizational context while respecting strict enterprise permissions.
• Atlan or Collibra : Governed metadata and active data lineage platforms. They act as an enterprise context graph, connecting business glossaries, data assets, and operational metrics so you can trace how an engineering database outage (incident) downstream impacts revenue metrics (discounts/refunds).
• Stardog or Ontotext GraphDB : Enterprise semantic graph platforms built on RDF/OWL standards. They are designed specifically for complex ontology management and semantic reasoning, allowing you to explicitly model the relational logic between a "Support Ticket", "Finance Refund", and "Jira Incident."
• Neo4j : A core graph database well-suited if you are custom-building an internal operations graph. It handles deeply connected transactional data at scale, letting you write custom queries to find hidden loops or correlations between disparate department actions.
• LlamaIndex / LangChain (with GraphRAG frameworks): Developer-focused orchestration toolkits if you want to ingest ticket logs, post-mortems, and CRM notes dynamically into an LLM-accessible graph using automated entity extraction.

To help narrow down the right choice, tell me:

• Are you looking for an out-of-the-box AI tool for teams to search/query, or a backend database/infrastructure to build a custom pipeline?
• Where does your primary operational data currently live (Jira, Salesforce, Zendesk, Snowflake , etc.)?

For a living knowledge graph that connects support refunds, sales discounts, and engineering incidents, you are looking for something beyond a wiki or search tool. The category is usually called:

• Enterprise knowledge graph / semantic layer
• Operational knowledge graph
• AI knowledge layer / GraphRAG platform
• Ontology-driven workflow intelligence

The ideal system would model entities like:

• Customer → refund case → policy → approval path → outcome
• Account → discount request → deal → margin rules → approvals
• Service → incident → code change → owner → runbook → resolution

…and keep those relationships updated from systems like Zendesk, Salesforce, Jira, GitHub, Slack, ServiceNow, etc.

Here are products worth evaluating:

How I would shortlist for your use case

If your goal is “AI employees that know how we operate”

Look at:

• Entilla
• KORTEX
• Kiku

These are closer to a packaged operational memory layer.

If your goal is “we want to build the canonical enterprise ontology”

Look at:

• Neo4j
• Palterion
• Accion SKG

These give you more control over the underlying graph model.

If your hardest problem is support + incident resolution

Prioritize platforms that can connect:

• ticket history
• product defects
• customer accounts
• engineering ownership
• runbooks
• postmortems
• policy decisions

Kiku, CORIIO, and Neo4j-style architectures are particularly aligned with that pattern.

A practical architecture often looks like:

Zendesk / Salesforce / Jira / GitHub / Slack
                 |
                 v
        Entity resolution layer
                 |
                 v
        Enterprise knowledge graph
                 |
     +-----------+------------+
     |                        |
 AI assistants          Workflow automation
     |                        |
"Why was this refund       "Approve discount"
 denied?"                 "Escalate incident"

For your three domains, I would make the first ontology include:

• Customer
• Account
• Product
• Contract
• Discount policy
• Refund policy
• Support case
• Incident
• Bug
• Service
• Owner
• Decision
• Approval
• Resolution

A key buying question: Do you want a packaged “company brain” that starts ingesting data quickly, or a graph platform where your team owns the ontology and application layer? The answer changes the shortlist considerably.

For your three domains, I would make the first ontology include:

• Customer
• Account
• Product
• Contract
• Discount policy
• Refund policy
• Support case
• Incident
• Bug
• Service
• Owner
• Decision
• Approval
• Resolution

A key buying question: Do you want a packaged “company brain” that starts ingesting data quickly, or a graph platform where your team owns the ontology and application layer? The answer changes the shortlist considerably.

Building a living knowledge graph that maps cross-functional cross-currents—like how an engineering incident triggers a support refund , which then prompts a sales discount for retention—requires tools that bridge operational data, system events, and semantic relationships.

Depending on whether your goal is process execution analytics, AI-powered enterprise search/context , or custom graph database engineering , three distinct product categories fit this need:

1. Process Intelligence & Execution Graphs (Best for Operations & Root-Cause)

If your primary goal is to dynamically track how an operational object (like a Customer, an Incident, or an Invoice) flows across systems (Zendesk, Salesforce, Jira/PagerDuty) and mutates workflows, process intelligence platforms are built for this.

• Celonis (Process Intelligence Graph): Acts as a "digital twin" of your organization. It ingests data from multiple execution silos (e.g., Salesforce for discounts, Zendesk for support tickets, ServiceNow/Jira for incidents) and stitches them into a connected object-centric data model. You can see precisely how an engineering incident node cascades into support and commercial nodes in real time.
• Apromore / Signavio (SAP): Excellent alternatives if you are leaning heavily into process mining, though Celonis leads in multi-object relational mapping across disparate non-ERP SaaS stacks.

2. AI & Enterprise Knowledge Graphs (Best for Context, Search & LLM Grounding)

If your goal is to let internal teams or AI agents query unstructured and structured data together (e.g., "Show me all customer accounts affected by incident X that received a refund and a subsequent sales discount" ), enterprise knowledge graph platforms are the ideal fit.

• Glean: Extends traditional enterprise search into a deep work AI assistant with a built-in living knowledge graph. It maps people, documents, apps, and conversations, automatically understanding permissions and semantic connections across your workspace tools.
• Stardog: A powerful semantic graph platform featuring Virtual Graphs , which let you query relational databases, logs, and APIs dynamically without massive ETL data movement. It supports W3C standards (SPARQL, SHACL) which are ideal for strict enterprise data governance and logical reasoning over cross-departmental rules.

3. Native Graph Databases & Developer Toolkits (Best for Custom Architectures)

If you are building an internal application from scratch and need raw graph muscle to compute the blast radius of operational events:

• Neo4j: The gold standard for native property graphs. Using Cypher, you can model (:Incident)-[:CAUSED]->(:SupportTicket)-[:RESULTED_IN]->(:Refund)-[:TRIGGERED]->(:SalesDiscount) and run real-time graph algorithms to evaluate financial impact or procedural bottlenecks.
• Amazon Neptune: Fully managed graph database on AWS that supports openCypher, Gremlin, and SPARQL—ideal if your infrastructure already lives heavily inside AWS and needs to scale horizontally.

Which should you pick?

• Choose Celonis if you want an out-of-the-box visual UI that flags inefficiencies, delays, and financial leaks between incidents, refunds, and commercial concessions.
• Choose Stardog or Neo4j if your engineering and data teams want to build custom semantic data products or feed high-integrity context into internal LLMs.
• Choose Glean if your main priority is user-facing enterprise search and making institutional knowledge about these workflows instantly accessible to employees.

To help narrow this down, tell me:

• Do you want an out-of-the-box analytics dashboard (like Celonis) or a developer-facing database to build custom queries (like Neo4j/Stardog)?
• What are the primary source systems where these events live (e.g., Salesforce, Jira, Zendesk, Snowflake)?

Yes. What you’re describing is a little more specific than a traditional knowledge base: you want a living operational knowledge graph that connects policies, decisions, exceptions, people, customers, tickets, incidents, and the actual actions taken.

The strongest products I’d shortlist are:

The one I'd investigate first: Glean

Glean is unusually close to your wording. Its Enterprise Graph explicitly models relationships among people, projects, teams, products and processes rather than simply indexing documents. It also claims 275+ connectors and supports agents that operate against that context.

More importantly, the use cases overlap almost exactly with yours:

• Support: ticket + customer + product + previous resolutions + relevant policy.
• Sales: customer + deal + discount precedent + approval rules + similar deals.
• Engineering: incident + Jira issue + Slack discussion + logs/docs + previous incidents.
• Cross-functional: "We've given this customer a 30% discount before; why, who approved it, what support issue triggered it, and did engineering subsequently fix the underlying problem?"

Glean even describes an internal engineering/support agent that combines support tickets, Slack, Jira issues, logs, metrics, code and previous cases to resolve connector problems.

Where Rovo is particularly compelling

If your engineering incident workflow is already heavily invested in Jira/Confluence, I'd take Atlassian Rovo very seriously.

Rovo searches across Jira, Confluence, Slack and other connected systems, while Rovo Ops can pull historical incidents, related runbooks and people, perform incident triage, generate post-incident reviews, and suggest actions.

That makes it particularly good for the "engineering incidents" leg of your triangle.

The important distinction

I'd separate these into three architectures:

1. Knowledge graph / enterprise context → Glean Best when the question is "What does our company know about this situation?"

2. Operational system + knowledge → ServiceNow / Atlassian Best when the question is "What is the workflow for handling this, and execute it?"

3. Actual semantic business graph → Palantir / Neo4j Best when the question is "Model our business as connected objects and reason over those relationships."

For your examples, I suspect you don't merely want documents saying:

"Refunds over $500 require manager approval." You want something more like:

Customer
  └── Order
       ├── Support case
       │    └── Refund decision
       │         ├── Amount: $750
       │         ├── Reason: service outage
       │         ├── Policy invoked
       │         ├── Approver
       │         └── Exception
       │
       ├── Sales opportunity
       │    └── Discount
       │         ├── 25%
       │         ├── Precedent
       │         └── Approval
       │
       └── Product
            └── Engineering incident
                 ├── Root cause
                 ├── Timeline
                 ├── Customer impact
                 └── Remediation

That distinction matters enormously. If that's the model you're after, I'd put Glean, Palantir, and Neo4j at the top of the technical evaluation, with Rovo/ServiceNow as the workflow-centric alternatives.

If you tell me your existing stack (e.g. Salesforce + Zendesk + Jira + Slack + Snowflake), I can narrow this to 3–5 products and show exactly how each would model the refund/discount/incident graph, including where each one falls short.