The network
Your graph is a picture of who depends on whom. On its own it is a diagram. Version two trains a small neural network on top of it, so the shape of your company becomes something the software can read a score off: which relationships are fragile, what each one is worth if it breaks, and which ones resemble each other.
Build a twinHow it shows its working
It is a graph neural network, trained on your own twin, on your own server. It is not a large language model and it has not seen another company.
A spreadsheet knows your largest customer is 31 percent of revenue. The network knows that account sits between a segment whose satisfaction is falling and a supplier with one source, that its contract ends in five months, and that three other accounts look exactly like it.
That is the difference between a number and a structure.
What actually happens
This is the whole architecture. It is small on purpose, because a small model trained on your own data and explainable line by line is worth more here than a large one you have to take on trust.
Type, share of its own type, revenue and cost on the record, satisfaction, how many of your files mention it, whether it was read or inferred, how connected it is, the tone of what customers wrote about it, how close its contract end is, and headcount or quantity. Money is scaled, so a company turning over millions and one turning over thousands give the network the same shaped input.
A node mixes its own numbers with the average of the numbers of everything it touches, then squashes the result. After this round a customer already carries a trace of the segment it sits in and the salesperson who holds it.
The same operation again on the result. Two rounds means every node has seen two hops out, so a supplier now carries something of the department it supplies and the customers that department delivers to. That is deliberate. Three rounds on a graph this size smears everything into everything.
One head gives risk, between zero and one. One gives impact, the size of the hole if the thing goes wrong, in your own currency. One is trained on the structure itself, by predicting which pairs of nodes are connected, which is what makes find me the ones that look like this work.
Where the labels come from
This is the part most worth understanding, because it is where a model like this usually goes wrong.
There is no training set of companies that failed. There is no industry benchmark being quietly applied to you. The network is trained on answers the engine gives about your own twin.
Training picks a sample of nodes. For each one it runs the simulator twice: once as things are, and once with that node removed or damaged, using the lever that fits it. A customer is lost. A supplier raises its price. A department is eliminated. The difference between the two runs is the true impact of that node, in money, computed by the same equations that produce every other answer in the product. That difference is the label.
So the network is a fast approximation of an expensive calculation you could always have done. It is not a second opinion. If the engine is wrong about your company, the network will be wrong in exactly the same direction, and the honest limits page already says where the engine is weak.
What it gives you
Everything scoreable ranked on one scale, so the account nobody was worried about appears next to the one everybody was. It only scores the kinds of node it was trained on, and anything it cannot score is listed separately with the reason.
Risk on its own is a worry list. Impact is what turns it into an order of work. A fragile supplier holding two percent of cost sits below a solid one holding forty.
Trained by predicting which nodes are connected, so similarity is about position in your company rather than about a name being spelled the same way. When one account churns, this is what tells you which others are standing in the same place.
The architecture, written out
The whole model is in one file of ordinary PHP. It runs on the same server as everything else, needs no graphics card, and trains in under two minutes on a normal graph.
| Piece | What it is | Why this size |
|---|---|---|
| Inputs per node | 24 numbers | Twelve are the node type. The other twelve are things your files actually say. |
| Hidden width | 12 | Wide enough to hold a few independent patterns, narrow enough that the attribution of a score to its inputs stays readable. |
| Rounds of message passing | 2 | Two hops. Three starts averaging the whole company into every node. |
| Activation | tanh | Bounded both ways, which keeps one enormous customer from dominating the gradient. |
| Risk head | sigmoid, cross entropy | A probability, because that is what a risk is. |
| Impact head | linear, squared error | A quantity in your currency, so it is comparable across nodes. |
| Structure head | link prediction on sampled pairs | Self supervised. It needs no labels at all, which is why it works on a thin twin. |
| Training | 160 passes, gradient descent, weight decay | Small model, small data. Anything fancier would overfit a graph with eighty edges in it. |
| Seeded | Yes | Same twin, same weights. Training twice gives the same numbers, and the model page says so. |
Training is time boxed at ninety seconds as a safety net. If a graph is large enough for that to bite, the model page says the run was time boxed and that its numbers are therefore not exactly reproducible.
Attribution
Being honest about it
The model page always prints the held back error next to the error of simply guessing the average, and a plain sentence saying whether the network beat that guess. If it did not, it says so. A model that cannot beat the average on your graph is telling you your graph is too thin, and the cure is another file, not another training run.
Under two minutes on a graph of a hundred nodes, most of it spent running the engine to produce labels rather than in the network itself. It is a background job, so you can leave the page.
After a meaningful upload. The network learns the shape of the graph you had when you trained it, so adding thirty customers changes what it should say. The app marks a model stale when the graph has moved and tells you on the page.
No. It is a few thousand multiplications on shared hosting. That is the point of keeping it this size.
The structure head still trains, because it teaches itself from the edges. Risk and impact need labels, and if there are too few the page says the model is not usable yet and names the upload that would fix it.
Yes, through the API on the plans that include it, and they are stored as plain numbers against your twin. There is nothing in there but arithmetic.
Because the useful thing here is not raw capacity, it is that every score can be taken apart into the inputs that produced it and each of those inputs traced back to a line in a file you uploaded.
A larger model on a graph with a hundred nodes would fit the noise, and it would lose the property that makes the output arguable. The point is not to be impressive. The point is that when it says an account is fragile, you can find out why and disagree.
Every paid plan. The free tier builds the graph and runs the engine but does not train the network, because training runs the simulator dozens of times and that is the expensive part.
Build a twin, upload three files, and see what the network says about the relationships you already have opinions on. If it disagrees with you, it will tell you why.