Your AI Agents Route to the Wrong Person. Here's the Missing Layer.

You built the RAG pipeline. You wired the knowledge graph. Retrieval scores look solid. But the agent still routes the invoice approval to someone who left the team three months ago. The problem is not retrieval. It is context.

The pain point platform teams already know

If you run a platform team deploying AI agents, copilots, or enterprise search, you have seen this pattern:

1. Agent retrieves the right document 2. Agent identifies the right entity (person, team, process) 3. Agent routes to that entity 4. The entity is wrong: the person moved, the team restructured, the approval chain was shortened after the last reorg

The failure is not in step 1 or 2. Retrieval works. The failure is in step 3, where the system acts on stale organizational data as if it were current.

This is not a model problem. It is a data layer problem. Your agents are operating on two tiers of organizational data when they need three.

Enterprise search, GraphRAG, and agentic systems all operate on Tier 1 and Tier 2. They understand the official version of the organization: the org chart and the documents. They do not understand how the organization actually operates right now.

How the industry is approaching this

GraphRAG has become the default architecture for multi-hop reasoning over organizational knowledge. Microsoft's Graph RAG paper (Edge et al., 2024) demonstrated that extracting entity-relation graphs from documents and retrieving subgraphs at query time outperforms naive RAG on complex, multi-hop questions. HippoRAG (Gutierrez et al., NeurIPS 2024) pushed this further with neurobiologically inspired memory indexing. More recent vector-native approaches like Vector Graph RAG (Zhang, 2026) eliminate graph database overhead entirely, achieving high recall with only two LLM calls.

The engineering is strong and improving rapidly. But the ceiling enterprise teams hit is not an infrastructure problem.

The invisible network your agents cannot see

Rob Cross's research on organizational network analysis (California Management Review, 2002) demonstrated that formal org charts capture only a fraction of how work actually gets done. The real information flow, decision-making authority, and expertise location live in informal networks that are invisible to document-based systems. His later work on collaborative overload (Cross, Rebele, Grant, HBR 2016) showed that high-value connectors in these networks are often the first to burn out, creating single points of failure that org charts never reflect.

Granovetter's strength of weak ties theory (1973) proposed that acquaintance-level connections between clusters are disproportionately important for information flow. In 2022, Rajkumar et al. ran the first causal test of this theory at scale: a randomized experiment across 20 million LinkedIn users, published in Science, confirming that moderately weak ties are the most effective for job mobility and cross-group information transfer. These cross-team bridges are precisely what knowledge graphs miss, and precisely what a behavioral layer captures.

For platform teams, this research translates into specific failure modes:

• The knowledge graph routes to the document author. The team routes to the person who actually maintains the system, who never wrote a doc about it.
• The approval chain in the graph reflects the pre-reorg structure. The actual approval path was shortened informally and never updated in any system of record.
• A cross-team bridge connector handles escalations across three teams. No document, ticket, or org chart edge captures this role.
• The titled "approver" is routinely bypassed in practice because a more trusted colleague makes the real call. This is invisible to every explicit data source.

These are not data freshness problems. Even a daily-refreshed knowledge graph would not capture them because they were never written down in the first place. They are behavioral patterns observable only through collaboration metadata.

Gartner's 2024 prediction that at least 30% of generative AI projects will be abandoned after proof of concept cites "inadequate risk controls" and "unclear business value" as primary causes. Routing failures, where the AI is technically correct but organizationally wrong, are a significant contributor to both.

> Your AI keeps surfacing the person who wrote the doc. The team keeps going to someone else. Authorship is easy to index, but it is the wrong signal for who actually knows how the work gets done.

What we built: the behavioral context layer

BehaviorGraph is the organizational behavioral context layer for enterprise AI. It does not skip Tier 1 and Tier 2. It indexes documents, org structure, and transactional data the same way enterprise search systems do. The difference is that it also builds and maintains Tier 3: the behavioral layer that captures how work actually routes, who the organization actually relies on, and where expertise actually lives. All three tiers, unified in one graph.

The system ingests collaboration metadata, not content. It observes patterns: who communicates with whom, how often, who tends to be involved in certain types of decisions. From these signals, it constructs a behavioral graph that continuously updates as teams, workflows, and networks change. In Steve Blank's framing, organizations accumulate organizational debt: structural shortcuts and informal workarounds that diverge from the official record. The behavioral layer makes that debt visible and actionable.

What the behavioral layer captures

• Trust density: Confirmed trust ties divided by total interaction opportunities. High activity plus low confirmed trust is a caution signal. Frequent interaction does not always mean reliance.
• Real escalation paths: Who people actually escalate to versus who the org chart says they should. The gap between these two is where routing fails most often.
• Load and capacity: Hours per week, active task count, and capacity signals that tell your agent whether the right person is also the available person.
• Silence as signal: Nonresponse is data, not missing data. High load plus nonresponse suggests overload. Low activity plus nonresponse suggests disconnection.
• Cross-system context: The real decision path crosses Slack, email, calendar, and ticketing systems. A context layer that only sees one platform reflects only a slice.

How it works in your stack

BehaviorGraph plugs into your existing search, agent platform, or governance layer via REST API, MCP (Model Context Protocol), or direct RAG enrichment. No rip-and-replace.

Integration patterns

POST /v1/agents/route
{ "action": "approve_contract",
  "domain": "auth" }
→ { "route_to":"ENG-04",
    "trust":0.94,
    "backup":"ENG-09",
    "escalation":"DIR-01" }

POST /v1/rag/enrich
{ "chunks": [...],
  "add_people": true }
→ { "owner":"ENG-04",
    "relevance":0.94,
    "backup":"ENG-09",
    "escalation":"DIR-01" }

GET /v1/search/enrich?query=auth
→ { "owner":"ENG-04",
    "relevance":0.94,
    "load":"32h/wk",
    "backup":"ENG-09" }

{ "name": "behaviorgraph_route",
  "inputSchema": {
    "properties": {
      "action": { "type": "string" },
      "domain": { "type": "string" }
    } } }

What this means for your GraphRAG pipeline

If you are running a GraphRAG system today, the behavioral layer sits alongside it, not on top of it. Your knowledge graph handles document retrieval and entity resolution. BehaviorGraph handles the question your knowledge graph cannot answer: is this still the right person, right now?

This is not a feature. It is a missing data tier. And it is designed to work with the tools you already have, not replace them.

Better together: how BehaviorGraph works with your existing stack

Glean is excellent at enterprise search. Neo4j is the standard for graph-based knowledge representation. LangChain and CrewAI are building strong agent orchestration frameworks. ServiceNow, Workday, and Salesforce each own critical vertical workflows. These are good tools doing important work in their respective areas.

What none of them have is thirty years of organizational network analysis research translated into a runtime behavioral layer. They capture what people write, file, approve, and assign. They do not capture who people actually rely on, how decisions informally route, or where trust concentrates across teams. That is a different research domain entirely, and it requires different data signals.

BehaviorGraph is built to complement these systems, not compete with them:

• Running Glean? BehaviorGraph enriches search results with behavioral context. Glean finds the right document. BehaviorGraph tells you who actually owns the problem right now, not just who wrote about it.
• Running Neo4j or a knowledge graph? Inject behavioral signals (trust density, load capacity, real escalation paths) as additional edge types and node properties. Your graph gets a live organizational layer it cannot build from documents alone.
• Building agents with LangChain or CrewAI? Wire BehaviorGraph as an MCP tool or REST call. Your agent gets routing context before it acts.
• On ServiceNow or Workday? BehaviorGraph surfaces the cross-system behavioral patterns that no single vertical platform can see on its own.

The integration is bidirectional. We inject behavioral context into your systems. Your systems feed workflow events, escalation logs, and structural data back into ours. The result is a feedback loop: the more your stack operates, the more accurate the behavioral layer becomes.

AI governance, security, and employee privacy

A common first question from platform teams: "Is this an HR tool?" No. BehaviorGraph is infrastructure for AI routing decisions. It is not an employee monitoring tool, a performance tracker, or a people analytics dashboard. The distinction matters for how it is built, how it is governed, and who should own it.

Why coded identifiers, not names

Every node in the behavioral graph is a coded identifier (ENG-04, LEG-07, DIR-01), not a name. This is a deliberate architectural decision, not a cosmetic one. Coded identifiers prevent the system from being repurposed for individual employee evaluation. The behavioral layer answers "which role or function should this route to" rather than "how is this person performing." This is what makes it safe for platform teams to deploy without triggering workforce surveillance concerns.

Why horizontal, not vertical

Most enterprise software is built vertically: an HR tool for HR, a ticketing system for engineering, a CRM for sales. Each captures activity within its own silo. But people inside organizations do not work vertically. They work across teams, across tools, across reporting lines. An engineer pings a product manager on Slack about a blocker, then joins a cross-functional standup, then gets pulled into an incident channel with SRE. A decision that starts in a Jira comment gets finalized in a hallway conversation and ratified in a calendar invite.

These informal, cross-boundary interactions shape who trusts whom, who influences which decisions, and where real expertise concentrates. No single vertical tool captures this. The behavioral layer works horizontally across systems precisely because organizational cognition is horizontal. People influence each other's thinking, shift each other's priorities, and build trust through patterns that span every tool in the stack.

Metadata only, never content

Capturing cross-system behavioral signals does not require reading what people say. BehaviorGraph observes communication structure: who interacts with whom, how often, across which channels, and who tends to be involved in certain types of decisions. It never reads email bodies, message content, document text, or call transcripts. This is not a configurable setting. The architecture does not support content ingestion. Pattern analysis, not content analysis. The signal is in the shape of the network, not the content flowing through it.

Audit trail and explainability

Every routing decision produces a full audit trail: which behavioral signals were used, what alternatives were considered, why the primary was selected over the backup, and when a human-in-the-loop step was triggered. This is not optional logging. It is built into the decision path. When a compliance team asks "why did the agent route this approval to ENG-04 instead of ENG-11," the answer is a structured record, not a model explanation.

AI governance alignment

For teams building AI governance frameworks, the behavioral layer addresses a gap that most governance models skip: routing accountability. Your model governance covers prompt safety, output filtering, and hallucination detection. But when an agent routes a security review to the wrong person because the knowledge graph is stale, that is a governance failure too. BehaviorGraph adds the organizational context that makes agent decisions auditable, explainable, and correctable.

What this looks like at scale

We have run this with organizations managing 2,000+ knowledge workers. The behavioral layer surfaces context that no amount of document indexing can capture:

For platform teams ready to close the gap

If your agents misroute, your search returns the right document but the wrong person, or your approval workflows still hit dead ends after every reorg, the problem is not retrieval. It is organizational context.

BehaviorGraph plugs into your existing stack. API, MCP, or RAG enrichment. Start with one use case, one routing decision. Validate that behavioral context changes the outcome. Then expand.