Share this article:

“AI mass psychosis” – an enterprise edition

Share This Article

An AI-driven mass psychosis. That’s how Palantir CTO Shyam Sankar described Silicon Valley’s obsession with the race toward artificial general intelligence (AGI).

AI researchers taking up smoking because they believe AI will eventually cure cancer? That’s an actual claim made by Sankar. Whether it’s really happening is another question. But as an illustration of the almost blind faith in AGI, it gets the point across remarkably well.

This will be a bit controversial to say, but I personally think we have our own version of this in enterprise technology. Yes, I said it.

Knowledge graphs, ontologies, RAG, agentic AI. I have seen discussions start with the technology before anyone has properly defined the business problem. We want a knowledge graph. We need agents. But what exactly are we trying to solve?

I’ll use two scenarios, customer service and manufacturing, to illustrate when retrieval, semantic modeling, deterministic logic and AI make sense, and how to decide what is actually needed.

If the problem is finding information, fix search first

Imagine a service team spending too much time looking up answers in an internal knowledge base. The content exists, is mostly correct and is a living knowledge base updated weekly. The call time for human customer service agents needs to be between 3 and 5 mins. Retrieval, however, is slow and unreliable, particularly in accuracy and consistency across different human agents. Let’s assume this does not allow them to stick to their target call-time range. So how do we tackle this?

Start with a baseline. Measure the time from search to usable answer, the share of queries that return the correct document, how often staff open an outdated version, and the effect on First contact Resolution and average handling time. Call-time targets vary by query, so an assumed generic target of 3-5 minutes benchmark is a poor substitute for actual measurements. Challenge it!

For a reasonably contained repository, the first technical changes are usually in the search pipeline:

  • Documents need to be parsed, deduplicated and tagged with reliable metadata.
  • Version information and access permissions must follow the content into the index.
  • Chunking can improve retrieval for long documents.
  • A lexical index such as BM25 handles exact terms, while embeddings help match differently worded queries.
  • Hybrid search combines both candidate sets, and a re-ranker orders the results.

So the first step is to assess the knowledge base: is it confluence, notion or simply a document?

RAG is useful when staff benefit from a short answer assembled from several passages. It introduces model latency and another potential failure mode, so generated answers need source links, evaluations against known questions and a fallback to ordinary search. Content updates and deletions also need to propagate into the indexes.

Manufacturing has similar retrieval problems. An engineer looking for a historical work instruction may only need a part number, revision and plant identifier. Different supplier part numbers can be handled through identifier mapping, master data rules and where useful similarity matching. Vector search can produce similar but ambiguous candidate matches. If the matches are not close enough, additional validation would be required.

  • When the content exists and users struggle to retrieve the right version quickly: this is probably the most effective path.
  • What to measure: Precision and recall on a test set, retrieval latency, time to usable answer, failed searches, First Contact Resolution (FTR) and manual search effort.

Building a knowledge graph for an isolated search problem needs a stronger justification than better indexing can usually provide.

If the problem is connecting information, consider semantic modeling

Now the service representative needs to determine whether a customer is entitled to an additional service. Customer records sit in the CRM, product data in an ERP or product catalogue, and contract terms in a separate system. Regional policies may use different product names and effective dates.

Retrieving each record is straightforward. Combining the records correctly is harder. The system needs to know that two identifiers refer to the same product, which contract version applies, and how the service entitlement relates to a specific product and customer.

Start with identifier reconciliation and a common data model.

  • A taxonomy helps classify products or policies.
  • An ontology defines concepts and allowed relationships, such as a customer holding a contract that covers a product.
  • A knowledge graph then stores instances of those entities and their relationships.

Many applications can implement the same logic with relational tables and joins. The choice depends on the relationships, query patterns and maintenance requirements.

Record provenance and effective dates matter here. A technically correct join can still return the wrong answer if it connects a customer to an expired contract or a superseded policy. Access controls also need to apply across the combined records.

Manufacturing provides a larger example. CAD, bills of materials, MES data, tooling lists and plant-specific work instructions may all describe the same part or operation differently. A shared model can link part revisions, tooling requirements, workstations and plant variants. That becomes valuable when several planning and engineering applications repeatedly need the same relationships.

The cost is ongoing ownership. Someone must resolve identifier collisions, maintain definitions, handle source changes and decide which system is authoritative. For a single well-defined query, a few reliable joins may be cheaper and easier to operate.

  • When to use it: Inconsistent identifiers and relationships across systems repeatedly cause wrong answers, manual reconciliation or duplicated integration work.
  • What to measure: Entity-match accuracy, unresolved identifiers, cross-system reconciliation time, stale relationships and reuse across applications.

If decisions follow explicit rules, use deterministic logic

Once the service representative has the contract and policy, the next step might be a refund decision. Eligibility could depend on contract status, purchase date, product type and exclusions. Those conditions can be implemented as versioned decision tables or rules in a policy engine, with a reason code for each outcome.

Manufacturing makes the need for explicit constraints even clearer. Certain assembly operations must precede others. Tooling capacity, physical access, cycle time and workstation availability limit which sequences are valid. This is when a precedence graph comes into play.

An engineering-approved precedence graph represents dependencies between operations. A constraint solver then looks for feasible sequences. A greedy algorithm may provide a quick valid sequence under defined priorities. Using historical precedence graphs and leveraging them to get the most common, least changed steps for a new model for a line can be a first starting point as well. This would be especially true when the goal includes minimizing cycle time and line balancing. The choice depends on problem size and the required optimization quality.

This separation is useful. The graph stores dependencies, the solver evaluates constraints, and the objective function determines what a good plan means. An LLM may help interpret engineering documentation or explain a proposed plan, while the actual constraints remain explicit and testable.

  • When to use it: Decisions follow defined policies or engineering constraints and must be reproducible or auditable.
  • What to measure: Constraint violations, decision errors, planning time, solver runtime, manual corrections and rework.

Deterministic methods still depend on correct inputs and maintained rules. They make the reasoning traceable when a decision needs to be reviewed.

If the problem involves uncertainty, bring in probabilistic AI

Consider a new vehicle component that has no exact equivalent in the planning history. The constraints still apply, but the planner needs candidate operations or a likely position in the assembly sequence.

Similarity models can find components with related geometry or specifications. A model can propose work steps based on approved historical examples and retrieved engineering material. Each proposal then passes through rule checks, a solver, simulation and, where required, an engineering review before entering the production plan.

The model’s job is to produce useful candidates where historical data and fixed rules do not fully specify the solution. Invalid proposals are discarded or revised. The system should retain the evidence used, the model version, the validation results and the final approval.

An unusual customer service request follows a related pattern. A language model can classify the request, retrieve applicable clauses and draft an explanation. If the proposed response involves a refund, contract change or other consequential action, the existing rules and approval process still determine what can happen.

Agents can coordinate retrieval, rules and external systems. Their value depends on the number of steps they can reliably complete, the quality of the tools they call, and the controls placed around state-changing actions.

  • When to use it: The task involves ambiguous requests, unseen cases or candidate generation where explicit rules cannot cover every input.
  • What to measure: Proposal acceptance, constraint-check rejection rate, manual review effort, accuracy on unseen cases, end-to-end latency and cost per completed task.

These approaches can be combined in one process. A service assistant might retrieve contract clauses with hybrid search, resolve a product identifier through a shared model, apply refund rules and use an LLM to draft the response. Each component should have a defined responsibility and a measurable reason to exist.

So, when does a knowledge graph actually make sense?

There is no required progression from search to semantic models to agents. Each solves a specific problem. Some manufacturing applications need a precedence graph and a solver from day one. A service team may achieve its target by improving document indexing and search.

I would base the decision on observed failure modes, the scale of repeated work and the operating cost of the proposed solution. If several teams continuously reconcile the same entities across changing systems, a shared model or knowledge graph may pay for itself. If the use case involves one repository and straightforward document retrieval, start there.

Every additional layer carries a maintenance obligation.

  • Search indexes must stay current.
  • Canonical definitions need owners.
  • Rules require versioning.
  • Models need evaluation and agents need monitoring and access controls.

In short, Sankar’s criticism applies equally well to enterprise architecture. We can spend months designing sophisticated systems without establishing whether the complexity is justified.

Sometimes better search is enough. Other problems require shared semantics, deterministic algorithms or AI. Each comes with implementation and maintenance costs. Start with the problem, define what success means, and use only as much technology as you need to get there.

Otherwise, we might have our own version of AI mass psychosis, just with many more boxes and arrows in our architecture diagrams.

Knowledge graph, ontology or simply better search? 👉Let’s talk about what your use case really needs.

Want to receive updates from us?

close

This page is only available in english