How GraphLogic Turns Enterprise Decisions Into Connected Graph Context

By Sabika Tasneem

11 min readAugust 25, 2026

Most GraphRAG systems focus on retrieval. They help an LLM find better context before generating an answer.

That is useful, but it doesn’t solve the harder enterprise problem: what happens to the reasoning after the answer is generated?

In this Memgraph Community Call, John Thomas, Founder and CEO of GraphLogic, walked through how his team is building a reasoning platform on Memgraph where arguments, evidence, risks, assumptions, decisions, and actions are stored as graph structures.

The core idea is simple: enterprise reasoning should not disappear into prompts, meetings, slide decks, or chat history. It should become connected, traceable, and reusable.

Watch the full Community Call recording to see John’s walkthrough of the GraphLogic platform and how it uses Memgraph as part of its reasoning layer.

Key Takeaway 1: The Enterprise Problem Is Not Lack of Data

Large organizations already have plenty of data. The problem is that important context is scattered across too many systems:

Databases and data warehouses
Enterprise tools
Email inboxes
Documents and reports
PowerPoint decks
Architecture reviews
Tickets and project systems

John described a familiar enterprise pattern. Teams usually know the high-level goal, but they don’t always understand what is happening underneath it. They leave meetings unsure why a decision was made, what changed or which dependency everyone missed.

That is where basic retrieval starts to break down.

You can ask an AI system to read documents and generate a plan. The output may even be good. But six months later, when someone asks why the team made that decision, “the AI said so” is not enough.

The real challenge is not just generating answers. It is preserving the reasoning behind those answers.

Key Takeaway 2: GraphLogic Models Reasoning as Graph Structure

GraphLogic’s approach is to represent both enterprise context and reasoning in the graph. That means the graph does not only store entities and relationships. It also models the thinking around them.

In the session, John explained how GraphLogic combines:

Formal logic, such as if/then/else rules and business rules
Informal logic, such as arguments, rebuttals, evidence, premises and competing viewpoints
AI agents that participate in structured reasoning workflows
Enterprise data connections across APIs, databases, repositories and federated sources

This matters because real organizational decisions rarely depend on one fact. They depend on connected evidence, assumptions, tradeoffs, constraints and past decisions.

A graph is a natural fit for that problem because it can preserve the relationships between those pieces.

GraphLogic Context Graph.png

If you are already exploring GraphRAG with Memgraph, this session is worth watching because it pushes the idea further. Instead of using the graph only to retrieve better context, GraphLogic uses it to represent the reasoning process itself.

Key Takeaway 3: Why Retrieval Alone Is Not Enough

GraphRAG improves retrieval by connecting semantic search with graph structure. That helps an AI system find more relevant context before answering a question.

GraphLogic builds on that idea, but John explained how retrieval is only one part of reasoning.

In GraphLogic, documents can be ingested, chunked, vectorized and used in RAG workflows. But relevant information is also extracted, curated and connected to the engagement being reasoned about.

That engagement may be a cloud migration, cybersecurity review, enterprise architecture decision or digital transformation initiative.

The platform can then break the work into reasoning threads, involve AI agents and humans, call tools and write outputs back into the graph.

The result is not just a generated response. It is a connected reasoning trail.

GraphLogic Enterprise Context Reasoning Graph.png

That trail can show:

What evidence supported a decision
Which assumptions shaped the outcome
Which risks or objections were considered
Which systems or teams were involved
How the decision connects to later actions

That means it is both easier to audit as well as easier to inspect, query, and improve.

Key Takeaway 4: The LEAP Framework

A key highlight of the session was John’s clear breakdown of the LEAP cycle. LEAP stands for:

GraphLogic Leap Framework.png

John described it as inspired by the OODA loop, but adapted for modern AI, analytics, and organizational learning.

Learn

The platform looks at what is happening now, what happened before, and how information changes over time.

John also discussed Bayesian techniques for understanding whether information is fresh, how it has changed, and how the current reality compares to what the organization believed months earlier.

Envision

The system can explore multiple viewpoints. John described a triad pattern where people or agents can act as:

Protagonist
Antagonist
Mediator

This helps the system reason through competing perspectives instead of accepting the first answer that sounds plausible.

Act

The platform tracks what the organization actually does after reasoning through the p problem. This connects the decision to execution.

Perfect

The system compares expected outcomes with actual results. If the organization said it would achieve a goal, the platform can help examine whether that happened, what changed, and what should be learned from it.

Those lessons can then feed back into future reasoning. This is where the graph becomes more than context. It becomes organizational memory.

Key Takeaway 5: How Is Reasoning Grounded in Connected Context

GraphLogic uses Memgraph as part of the operational graph layer behind this reasoning model. In the demo, John showed how GraphLogic scopes reasoning around user context, including:

Organizational level
Role
Professional profile
Focus lens

For example, a CIO may look at the same enterprise context through a digital service delivery lens. An enterprise architect may need a different perspective. A cybersecurity lens may surface a different set of relevant concepts from the same source material.

That persistent context matters. Without it, users often restart every AI interaction from scratch. They gather documents, restate background information, ask a question, and then repeat the process next time.

GraphLogic tries to avoid that reset. The system keeps the user’s organizational context, reasoning engagement, and focus area available as part of the ongoing workspace.

Key Takeaway 6: How is Federated Access Beneficial

A weak implementation of this idea would copy everything into one giant graph and call it context. GraphLogic is more careful than that.

John was clear that GraphLogic is not meant to become a dumping ground for every piece of enterprise data. Instead, the platform can access information where it already lives and bring in what matters for reasoning.

That is where Memgraph Zero fits into the architecture. With Memgraph Zero, teams can query across systems without forcing all data into one centralized store. The first component, MemGQL, provides a federated GQL query engine that translates graph queries into backend-native languages.

This federated approach is what allows GraphLogic to pull in relevant context from wherever it lives, instead of duplicating it into the graph. In the session, John explained that this means the platform can work across a wide range of data and query environments, including:

Cypher for Memgraph
Gremlin
GraphQL
SQL sources
Vector stores
PostgreSQL
Time-series databases
Key-value stores

This is important for enterprise reasoning because evidence rarely lives in one place. Some data belongs in the graph. Some data should stay in source systems. Some data only needs to be queried, summarized or referenced at the right moment.

The graph becomes the reasoning layer, not the warehouse for everything.

Key Takeaway 7: Graph Queries Are Part of the Reasoning Process

GraphLogic also extends the role of graph queries. The platform is not only asking, “What nodes match this pattern?”

It also needs to reason over change, time, rules and outcomes. John discussed several capabilities, including:

Change events stored in the graph and other supporting systems
Temporal analysis
Aggregations
Embedded algorithms
Logic flows that combine graph queries with rules and summaries

For example, a query may need to find whether something changed six times in the last three months. That matters because reasoning depends on time. A fact that was valid six months ago may no longer be valid today.

This is where graph traversal, analytics and AI start to work together. The query finds connected context. The logic layer applies rules. The AI layer helps summarize and reason through the results. The output can then become part of the next reasoning step.

Key Takeaway 8: GraphLogic Use Cases

GraphLogic is not designed for small questions that a single LLM prompt can answer.

John positioned it for problems with enough complexity that teams need structure, traceability and shared context.

Examples include:

Digital transformation
Enterprise IT modernization
Large-scale cloud migration
Cybersecurity compliance
Cross-functional delivery planning
Major customer commitments with downstream technical impact

One real-world example from the session involved an organization with work spread across Azure DevOps, Smartsheet, internal systems and several business functions.

The problem was not that people lacked tools. It was that sales, delivery, development and project teams did not always share the same view of commitments, constraints and impact. That is exactly the kind of problem where a traceable reasoning layer starts to make sense.

Before a team commits to a customer request, they can put that proposed action into the reasoning environment, connect it to the relevant systems and dependencies, and evaluate the impact.

That is much better than discovering the consequences after the commitment has already been made.

Wrapping Up

This Community Call is useful if you are working on GraphRAG, enterprise AI, architecture governance, decision intelligence or graph-based reasoning systems.

The session goes beyond theory. John walks through how GraphLogic thinks about:

Modeling enterprise context
Representing arguments and evidence in the graph
Using AI agents as reasoning collaborators
Curating documents into graph context
Structuring problems as engagements and reasoning threads
Using Memgraph and Memgraph Zero as part of a broader reasoning architecture

The main takeaway is not that every AI workflow needs a graph, but that once decisions become complex, cross-functional, and long-lived, retrieval alone is not enough. You need a way to preserve how the organization reasoned, what evidence it used, and how outcomes changed over time.

Watch the full on-demand recording to see how GraphLogic is building that reasoning layer on Memgraph.

Q&A

Here’s a compiled list of the questions and answers from the community call Q&A session.

Note that these are paraphrased slightly for brevity. For complete details, watch the full community call recording.

What types of documents can GraphLogic ingest, and how does it structure unstructured data?
- GraphLogic can ingest any document type that an AI model can read. The system first establishes context, such as the organization and engagement, before processing documents. It then uses AI directives to extract relevant concepts and information from the document and place them into the graph. This process involves chunking, vectorization and RAG techniques.
  
  However, document extraction is acknowledged as a difficult problem and not fully solved. The system is designed to be extensible, allowing integration with other document processing tools if needed.
How does GraphLogic manage the cost of AI agents and model usage?
- GraphLogic follows a bring-your-own-model approach, allowing organizations to use their preferred AI models, whether hosted or local. It can run in customer infrastructure or cloud environments. Not all tasks require large frontier models; smaller models can be used when the graph already structures the data.
  
  By grounding AI interactions in graph context, the system reduces the amount of data sent to models, which can significantly reduce token usage, sometimes by up to 90% in certain cases.
How does the system determine what information is relevant?
- Relevance is determined through multiple layers of context, including organizational scope, user role, and focus lenses, such as cybersecurity. The system uses its concept and connection model to identify which information is likely relevant to a given engagement.
  
  It performs an initial pass to identify candidate concepts and then extracts related information. Users can control how much of this information is automatically inserted into the graph, and human oversight is recommended to avoid introducing low-quality data.
Does GraphLogic store all enterprise data in the graph?
- No, GraphLogic is not designed to become a centralized repository for all enterprise data. Instead, it uses a federated approach, accessing data where it already resides and bringing in only what is relevant for reasoning.
  
  Structured systems like SQL databases can be queried directly without copying all data into the graph. This approach avoids unnecessary duplication and keeps the graph focused on meaningful context.
How does GraphLogic handle different query languages and data systems?
- GraphLogic supports multiple query languages, including Cypher (for Memgraph), Gremlin, and GraphQL. The platform can determine the appropriate query format depending on the target system.
  
  For example, it uses Cypher for Memgraph and can translate queries into Gremlin or GraphQL when needed. This abstraction allows users to interact with multiple systems without manually managing different query dialects.