myonto turns your domain model into a governed knowledge graph and serves it to every AI agent as real MCP tools. Answers are derived from your data — with a test suite that proves it, question by question.
myOWL SHACL SPARQL
MCP Neo4j PostgreSQL. No proprietary lock-in.
Vector search finds text that looks like an answer. An ontology defines what is actually true in your business — which entities exist, how they relate, and which values are valid. myonto makes that model executable, so an agent can only answer from it.
Every answer traces back to a row or a graph traversal. If the data doesn't support it, the agent says so instead of inventing something plausible.
A built-in hallucination suite grades answers on four layers — factual, grounding, citation and reasoning — against ground truth computed from your database.
Your ontology is OWL and SHACL. Your queries are SPARQL. Your tools are MCP. Export it all as Turtle and walk away whenever you like.
Run the same grounded tool surface on LangChain, PydanticAI, smolagents, AutoGen, n8n — or myonto's native loop. Swap engines without remodelling anything.
Virtual Knowledge Graph maps ontology classes onto your existing tables and rewrites SPARQL to SQL on the fly. Your data stays where it is.
Watch an agent think in real time — the planner's decisions, the LLM round trips, and the exact SQL and Cypher it ran, with per-step timing.
Six capabilities that fit together — author the model, ground it, serve it, reason over it, test it, and ship it.
Author classes, properties, relationships and SHACL constraints. Version and roll back. Import and export valid Turtle. Bootstrap fast: reverse-engineer from a live database, or let an LLM draft one from your competency questions.
ObDA mappings bridge each ontology class to a table and each property to a column. SPARQL is rewritten to SQL and executed against your own database — no triples stored, no pipeline to maintain.
Your ontology compiles into real MCP tools — per-class get/list/create, relationship traversals, and a SPARQL fallback. SHACL constraints become JSON-schema validation, so invalid calls are rejected before any query runs.
Ground an agent to a model, a knowledge graph and a tool surface in one step. An OWL-S IOPE planner checks preconditions and repairs bad tool calls before they run.
Replay any question and watch the full execution trace stream live — agent reasoning, LLM round trips, tool calls, and the raw SQL and Cypher. Then score the answers with the hallucination suite.
Publish an agent behind an API key and call it from anywhere — curl, Python, Java, C++, JavaScript, or a ready-made n8n workflow. Unpublish once and every key stops working instantly.
Most teams stall not on tooling but on modelling. These engagements exist to get you past that — and they're the fastest route to a working system.
Two to four weeks with your domain experts. We run competency-question sessions and leave you with a validated OWL/SHACL model — plus the reasoning behind every decision.
We connect your warehouse or operational databases, map classes to tables, and tune the SPARQL→SQL rewrites so queries return in production-acceptable time.
Independent evaluation of an existing agent — yours or ours. You get a scored report on factual accuracy, grounding, citation and reasoning, plus the failing cases.
We run myonto in your cloud or ours, with upgrades, backups, monitoring and an SLA. Your data never has to leave your account.
Every tier includes the full modelling stack — we don't put ontologies behind a paywall. What scales is workspaces, throughput and assurance.
Prices exclude tax. Annual billing saves 20%. Bring your own LLM keys on every tier — you're never resold inference.
Engineering write-ups on grounding, evaluation and the semantic layer.
Hand-written tools drift from the model the moment someone edits a class. Generating them makes drift structurally impossible — and SHACL becomes free validation.
Read →"Hallucination-free" is a marketing claim until you can measure it. Here's the rubric we grade every answer against, and why factual accuracy alone isn't enough.
Read →Hand-scoping every query makes isolation depend on never making a mistake. Pushing it into Postgres makes the failure mode "empty result" instead of "someone else's data".
Read →No — and this is the most common blocker, so we built two ways around it. You can reverse-engineer a starting ontology from a live database schema, or describe your domain in plain language and have an LLM propose the competency questions and draft the model. Both produce a proposal you review and edit before anything is applied.
Those translate a question into a query and hope the schema is self-explanatory. myonto puts a formal model in between: the agent can only use classes, properties and relationships that exist, constrained by SHACL. That's what makes the answers checkable — and it's why the same question gives the same answer twice.
Not for querying. The Virtual Knowledge Graph rewrites SPARQL to SQL and runs it against your own database — no copies, no sync. If you use a hosted LLM, prompts and the rows returned by a tool call go to that provider; run local models via Ollama if you need everything to stay in your network.
Claude and local Ollama models today, with your own API keys. Agents run on your choice of engine — myonto's native loop, LangChain, PydanticAI, smolagents, AutoGen, or a real n8n workflow you can edit on a canvas. The ontology-grounded tool surface is identical across all of them.
Each answer is scored on four layers: factual accuracy against ground truth computed directly from your database, grounding (did it actually use the tools), citation (does it reference real entities), and reasoning (does the conclusion follow). You get per-case results, not a single vanity number.
Yes, on the Enterprise tier — in your own cloud account or on-prem. It's PostgreSQL, Neo4j and two Python services; nothing exotic. You keep the ontology as Turtle, so you're never locked in even if you stop paying us.
It's in active development and being used for real workloads, but we'd rather you heard the caveats from us than discovered them. Talk to us about your scale, isolation and compliance requirements before you commit — we'll tell you honestly whether we're a fit yet.
Publish an agent, generate a key, and it's a plain HTTPS endpoint. No SDK required, no client library to keep in step.
# Ask a published, ontology-grounded agent curl -X POST 'https://app.myonto.ai/api/v1/agent/public/chat' \ -H 'Authorization: Bearer myo_your_key_here' \ -H 'Content-Type: application/json' \ -d '{"message": "Which jobs are failing?"}' # → { "reply": "dbt_fct_revenue is failing …", # "source": "claude-opus-4-8" }
Snippets for Python, Java, C++, JavaScript and Windows curl are generated for you alongside every key.
From empty workspace to a grounded agent answering questions — about fifteen minutes.
Point Claude Desktop, n8n's MCP node or any MCP client at your server over SSE.
Map classes to tables, columns to properties, and foreign keys to real graph edges.
Interactive OpenAPI for every endpoint, generated from the running service.
Whether you have an ontology already or just a messy warehouse and a mandate to make AI trustworthy — we'll tell you straight whether myonto fits.
Email
hello@myonto.ai
Already a customer?
Sign in to your workspace →