Your company as a graph: the operational digital twin Minte builds for every customer

Most companies have an enormous amount of data and still can't answer simple questions about themselves. What happens if this supplier fails tomorrow? Which processes depend on the person who just went on holiday? Do we actually have the capacity to take on this new client, or are we about to burn out a team? The information exists, but it's scattered across spreadsheets, people's heads, and a dozen tools that don't talk to each other.

The problem is rarely a lack of data. It's the lack of a model that connects it: one that knows a team uses a resource, that the resource enables a capability, that the capability sustains a process, and that the process delivers the product you sell to a customer. When that model doesn't exist, every interesting question becomes an analytics project. When it does exist, it becomes a conversation.

What Palantir understood before anyone else

Palantir popularized an idea that had been circling computing for decades but that almost no one had put into practice at enterprise scale: the ontology. They define it disarmingly: it's the nouns and verbs that make up your business. Instead of seeing your data as tables and columns, you model it as what it actually represents —plants, warehouses, orders, customers— and the relationships between them: this warehouse supplies this plant, this plant ships product to this customer. The goal, they say, is to model how your business actually operates, not how the other systems need it to look so they can work.

Their framework for making decisions has three pieces: data, logic and actions. The data represents the current state of the business. The logic is how you think about those things —from a rules-based spreadsheet to a machine-learning model. And the actions are what you can execute to change reality. Put the three together and you get, in their words, a digital twin of how your business is operating: a living replica you can reason with and act upon.

The most interesting part arrived with AI. As they themselves acknowledge, language models were not trained on your business's data or processes. The ontology is precisely what gives them the context they lack: not just the data, but how your business works. With that context, the model can reason, call the deterministic logic, and drive an action back into the systems. Instead of a person having to swivel-chair from a dashboard over to another tool to make a decision real, the system orchestrates that action on the back end. The ultimate goal, in their words, is for AI and humans to work together on the ontology and automate more and more of the business over time.

It's a brilliant idea. The catch is that for years it came with a multi-million price tag, an army of consultants and months of integration. It stayed reserved for governments, banks and industrial multinationals. The question we asked ourselves at Minte was different: what if that digital twin could be built for any company, maintain itself, and —above all— talk to teams in plain language?

From data to operating model

Inside Minte, every customer has their own graph. It isn't a pretty diagram for a slide deck: it's a living data structure that represents how the organization actually works. We model the company with a handful of entity types that, together, describe almost any business.

There are units (departments and areas, with their hierarchy), members (the people), the groups and the roles those people perform. There are resources —human, software, physical or financial, each with its capacity and cost—, the capabilities the organization can execute, the processes that orchestrate them, the offerings (the products and services you sell), and external parties: suppliers, partners and clients.

What matters isn't the nodes but the verbs that join them. A team consumes a resource. A resource enables a capability. A process uses that capability and delivers an offering. A capability requires a role. A supplier relates to an offering. Each of those relationships carries extra information —how much, whether it's critical, what kind of relationship— so the graph says not just what is connected, but how much and how important it is. Those are exactly the nouns and verbs Palantir talked about —the data and logic of the ontology— except built automatically from the information your company already has.

Not just querying: acting too

A map you can only look at has limited value. The difference between a dashboard and a digital twin is that you can operate on the latter. That's why Minte's graph is not read-only.

The Minte agent has two hands. With one it reads: it traverses the graph to answer questions, find bottlenecks, compute dependencies or diagnose inconsistencies. With the other it writes: it creates or modifies entities and relationships when you ask it to reorganize an area, onboard a supplier or reassign a capability. This is the direct equivalent of the actions in Palantir's ontology —the third piece, alongside data and logic— except here the interface isn't a complex admin panel but a conversation. Nobody has to swivel-chair from a dashboard to another tool to make the decision real: you ask, and it happens.

And because every action on a company's structure is sensitive, each write passes an ownership check before touching anything: the agent can only modify entities that belong to your organization, never another's. We'll come back to this, because isolation between customers is the backbone of the whole system.

The questions that used to need an analyst

When your company lives as a graph, a whole class of questions stops requiring a project and starts being answered in seconds. Not because of magic, but because traversing relationships is exactly what a graph does well.

Where are the bottlenecks? The system sums the demand falling on each resource and compares it against its real capacity; if a resource is at 130% load, it flags it. What if a supplier goes down or a resource breaks? A dependency traversal shows, downstream, every capability, process and offering that would be affected. Do we have uncovered roles? A query finds the roles no member performs. What hangs off this specific person? The graph traces their impact before they leave. And if you want the full chain from a supplier to the final product that touches the customer, it's three hops in the graph.

None of this requires knowing how to write queries. The executive asks in their own language; the agent translates the question into a graph traversal, runs it safely —read-only, with limits so it never returns huge answers— and responds in plain language, citing the company's real structure.

How it stays alive and secure

A digital twin is only useful if it reflects today's reality, not the one from six months ago. That's why Minte uses two coordinated stores. The source of truth is the relational database: that's where the canonical data lives and where writes happen first, with full consistency guarantees. In parallel, we keep a graph database optimized for traversals and dependency analysis, which powers the visualizations and the complex questions.

Every time something changes, the change is written first to the source of truth and then propagated to the graph through a durable queue, with retries and no duplicates. And so the two copies never drift apart, a diagnostic process reconciles both worlds: it compares entity and relationship counts, detects orphan nodes or missing edges, and warns if there's drift. It's the difference between a map that ages and one that corrects itself.

On security, the principle is radical: each customer lives in their own isolated graph. It isn't a column filtering a shared table; it's a separate space by design. On top of that, every entity carries its ownership, every query filters by the customer's identifier, and every write checks ownership before acting. When the agent generates a query, it passes through a validator that blocks any disguised write operation and caps the response size. Several layers of defense so that the phrase your data is yours isn't a slogan but a property of the system.

A real case, end to end

Picture a professional-services firm. A big opportunity comes in: a new client who wants to start in three weeks. The head of operations asks the usual question, but this time to Minte's agent instead of a spreadsheet: can we take this on without breaking anything?

The agent traverses the graph. It sees that the new engagement needs a senior consulting capability; that the capability requires a specific role; and that the role is currently covered by three people already at 90% load on two other processes. It answers with numbers: accepting the project would push those three people past 100% and drag a delay into one of the processes that delivers to an existing client. It's not a hunch; it's a dependency traversal over the real structure.

The director decides to act. He asks the agent to evaluate hiring an external party to cover part of the capacity. The agent registers —with the hand that writes— the supplier as an external entity, relates it to the corresponding offering, and recomputes the load: now the internal team sits at 85% and the project fits without sacrificing the existing client. That entire conversation —diagnosis, mental simulation, decision and change to the model— happens in minutes, in a chat, without opening five tools or waiting for Monday's report.

That's what changes when your company stops being a pile of loose data and becomes a model you can reason with. The question stops being where's the data? and becomes what do we decide?.

The digital twin stops being a luxury

Palantir's ontology proved that modeling an organization as objects, relationships and actions is one of the most powerful ideas in enterprise software. What was missing was making it accessible: not requiring millions, consultants or months of integration, and operating it by talking instead of programming.

That's exactly what Minte builds for every customer: a living graph of your organization, that maintains itself, that's isolated from everyone else, and that your teams can query and modify in plain language. Your company, at last, as something you can have a conversation with.