Reads relational data directly
Point it at your tables. The graph engine learns from foreign keys and multi-hop paths, with no feature engineering and no manual joins.
Platform
Surface the graph. Predict.
Surface the graph. Predict.
Then act.
A production-grade graph foundation model reads the relationships hiding in your raw tables, predicts what is next, and hands the result to governed agents that take the action. One closed loop, run inside your environment.
The model
One model that reads relationships, not flat rows.
A relational foundation model learns across your tables at query time, honoring foreign keys, timestamps, and the multi-hop patterns that connect entities. It predicts in-context, so there's no task-specific pipeline to build and maintain.
Because it understands time, every prediction is anchored: the model only sees what was knowable at the cutoff. That's what makes a backtest honest and a deployment safe.
From relational tables to a governed action in three steps.
1
Connect your data
Each use case declares the tables and columns it needs. Upload to its schema contract. AhinsaAI validates and rebuilds the temporal graph in place.
2
Ask a predictive question
Define the task in PQL, a compact, SQL-like predictive query. Pick the entity, the target, and the horizon. The graph engine does the rest.
3
Let agents act
Under your policy, governed agents take the action the prediction implies, with a held-out backtest, risk drivers, and a reversible, hash-chained audit record.
predictive_query.pql
# Will this account see a fraudulent payment in the next week?
PREDICT payments.is_fraud
FOR EACH account.id
WITHIN NEXT 7 DAYS
# → scored predictions + held-out backtest + risk drivers + audit recordSix things that make Graph AI production-grade.
Temporal-safe by construction
Point-in-time labels and anchor timestamps mean the model only sees what it could have known. No forward leakage, ever.
Runs on your data
Every use case accepts your uploaded tables and runs its real feature pipeline, backtest, and governance, never a canned demo.
Governance & audit
Policy checks at decision time and a hash-chained, tamper-evident audit log of every prediction and review action.
Enterprise security
Multi-tenant isolation, fail-closed authentication, request limits, and tenant-namespaced storage. Hardened, not bolted-on.
Pluggable model engine
A local model and a graph prong engine score every example and blend, with per-prong held-out backtests so you see what's working.
Built to pass the review, not just the demo.
The difference between a research model and a production platform is everything that surrounds the prediction.
Hash-chained audit
Every prediction and review action is written to a tamper-evident, hash-chained log, so you can reconstruct exactly what was decided, when, and on what.
Multi-tenant isolation
Tenant-namespaced datasets and registries. One tenant can never see another's data. Verified, not assumed.
Fail-closed auth
The gateway and APIs reject unauthenticated requests by default. Access is explicit, scoped, and revocable.
Request & ingestion limits
Body-size, row, column, and table caps with strict validation stop malformed or oversized uploads at the door.
Point-in-time governance
Temporal safety is enforced in the pipeline, so backtests can't leak the future and scores stay trustworthy.
Explainable by default
Every score arrives with risk drivers and a held-out backtest, so a human can confidently review and sign off.
See the platform on your data.
Bring a labelled table or use a bundled sample. We'll walk the full path (connect, query, score, backtest, audit) in minutes.
We'll reach out within one business day.