$ hyper-ontology --for developers
Studio writes it. You own it.
Model your operation in Hyper Studio. Every change regenerates your ontology as typed code in your repository. Try it below.
Change the object
$ git diff other-platforms hyper
Other ontology platforms rent you your own operation.
They hold the model of your business on their side, enforce its rules in places you cannot read, and sell your agents access to it. Here is the difference, the way engineers read differences.
--- other ontology platforms+++ hyper ontology@@ where your ontology lives @@- in the vendor's cloud, behind a console+ in your repository: src/mcp/manifest.ts@@ export @@- none, or a partial schema dump+ the full source, regenerated on every publish@@ how rules are enforced @@- settings inside a screen you cannot read+ generated code, in locked transactions@@ how agents connect @@- a proprietary SDK and a service account that sees everything+ an MCP endpoint, four tools, filtered by role@@ your existing systems @@- migrate the data into their platform+ Atlas connects them in place@@ your models @@- the vendor's choice+ any model you host, air gapped if you want@@ leaving @@- rebuild from nothing+ you already own the code
$ tree mining-gold-project
Read the docs like a repository.
Every page of the docs is a file you will find in your own export, or a screen in Hyper Studio. Nothing here describes a system you cannot open.
README.md
Quickstart
Model your operation in Hyper Studio, publish, and export. What you download is a complete, typed backend with the ontology inside it. A few commands stand it up.
# 1. In Hyper Studio: Code, Export project (backend)
$ unzip mining-gold-project-backend.zip && cd mining-gold-project
$ cp .env.sample .env # your Postgres, your secrets
$ npm install
$ npm run migrate # create the schema
$ npm run seed # optional sample records
$ npm run dev
# API http://localhost:8000
# Agents http://localhost:8000/mcp
# Docs http://localhost:8000/api-docsYou click through a hosted console and never see the system your ontology runs on.
src/mcp/manifest.ts
Ontology as code
The ontology is a file, src/mcp/manifest.ts, generated beside the code that enforces it. Diff it in a pull request, review it like any other change, and roll it back with git.
mining-gold-project/
src/
mcp/
manifest.ts // the ontology: objects, links, kinetics, functions
gateway.ts // four meta tools agents call
server.ts
kinetics/
maintenanceWorkOrder.ts // generated state machine, the only write path
crusherDumpPocket.ts
runtime.ts
models/ // one Sequelize model per object
modules/ // routes, controllers, Zod validation
migrations/ // umzug, versioned with the schema
generation-report.json
Dockerfile
package.jsonexport interface OntologyObject {
apiName: string;
displayName: string;
description: string;
synonyms?: string[]; // the names the business really uses
semanticDomain?: string; // authored business domain
labelProperty?: string; // what identifies a record to a person
properties: OntologyProperty[];
links: OntologyLink[];
lifecycles?: OntologyLifecycle[]; // kinetics
derivedStatuses?: OntologyDerivedStatus[]; // computed on read
actions?: OntologyAction[]; // business actions
functions?: OntologyFunction[]; // analytics by name
sideEffects?: OntologySideEffect[];
agentAccessible: boolean;
}generation-report.json lists every decision the generator made and why.The ontology is a configuration in someone else's database. There is no file to review, and no history you control.
synonyms · links
Semantics
Semantics write down what every object means, in the words the business uses. The Mining GOLD Copper ontology carries 18 objects, 46 typed links and 37 synonyms, so an agent asked about a repair ticket finds the Maintenance Work Order without a lookup table.
- Object: an
apiName, a display name, a description and alabelPropertypeople recognise. - Synonyms and domain:
synonymsfor every other name,semanticDomainfor where it belongs. - Links: a cardinality, the property that stores it, a phrase that reads as a sentence, and
via, the tool that walks it.
{
"apiName": "maintenance-work-order",
"displayName": "Maintenance Work Order",
"description": "A tracking document for repairing and servicing mining machinery, support vehicles, and safety infrastructure.",
"synonyms": ["Repair Ticket", "Service Order"],
"semanticDomain": "Operations and Maintenance",
"labelProperty": "workOrderNumber",
"links": [{
"to": "haul-truck",
"cardinality": "many-to-one",
"fkProperty": "haulTruckId",
"phrase": "belongs to",
"via": { "tool": "detailHaulTruck", "filter": "id" }
}]
}Synonyms live in a separate search index, if at all, and links are join keys with no meaning attached.
src/kinetics/
Kinetics
Kinetics model how the operation moves. A lifecycle names the states a record can be in and the transitions between them. Each transition is generated as its own function: it locks the row, checks the move is allowed, and commits in one transaction. Ordinary updates are stripped of the governed field, so a transition is the only way the state can change.
// src/kinetics/maintenanceWorkOrder.ts (generated, do not edit by hand)
export const transitionMaintenanceWorkOrderAssign = async (params, input = {}, actor = null, opts = {}) => {
const run = async (t) => {
const wo = await MaintenanceWorkOrder.findOne({ where: { id: params.id }, transaction: t, lock: t.LOCK.UPDATE });
if (!wo) throw notFound('MaintenanceWorkOrder', 'INVALID_MAINTENANCE_WORK_ORDER_ID');
if (wo.orderStatus !== 'unassigned') {
throw badRequest(`Cannot 'Assign': orderStatus is '${wo.orderStatus}', allowed from: unassigned`, 'KINETICS_INVALID_TRANSITION');
}
return wo.update({ orderStatus: 'assigned' }, { transaction: t });
};
return opts.transaction ? run(opts.transaction) : sequelize.transaction(run);
};
// ordinary updates can never touch a governed state
export function stripMaintenanceWorkOrderGovernedFields(payload) {
delete payload.orderStatus;
}unassigned. completed and cancelled end it.KINETICS_INVALID_TRANSITION, with the states it was allowed from.Try it: move a work order through its lifecycle.
Actions are buttons wired in a hosted builder. Nothing stops a script that writes the field directly.
functions · actions
Functions and actions
Functions are the numbers the operation runs on, computed once on the server and callable by name: collection insights and dashboard measures. Actions are business operations that are neither plain edits nor lifecycle moves, each fired by a named tool, with a precondition and a flag for the ones that need a person to confirm. Derived statuses are computed on read and arrive on every row as _derived.<key>.
export interface OntologyFunction {
name: string; // the MCP tool that computes it
kind: 'insight' | 'dashboard';
title: string;
aggregation?: string; // count | sum | avg | min | max
chartType?: string; // bar | line | pie | table
}
// from the Interaction Event object
{ "name": "dashboardAvgProximityDistancem", "kind": "dashboard",
"title": "Avg Proximity Distance (m)", "aggregation": "avg" }Every dashboard recomputes the same number its own way, and agents compute a third version.
src/mcp/gateway.ts
Agents over MCP
Every export serves the ontology to agents at /mcp. The gateway registers four meta tools however large the ontology grows, so an agent discovers what it needs instead of loading hundreds of tools. Access is fail closed: search results and manifest objects are filtered by the caller's role, and properties a role cannot see are hidden from the ontology too.
// The gateway registers four meta tools, whatever the size of the ontology:
// describe-project what every object IS, how objects link, kinetics, functions
// search-tools the tools this caller may use, filtered by role
// get-tool-schema the JSON input schema of one tool
// invoke-tool validate the arguments and run the tool
// an agent, before it acts
{ "method": "tools/call", "params": { "name": "describe-project" } }
{ "method": "tools/call", "params": { "name": "search-tools", "arguments": { "query": "work order" } } }
{ "method": "tools/call", "params": { "name": "invoke-tool",
"arguments": { "tool": "assignMaintenanceWorkOrder", "args": { "id": "…" } } } }Hyper Pragma's agents work exactly this way: they call describe-project before they act. See them at work.
Agents get a vendor SDK and a service account that sees everything.
Studio · Atlas
Atlas
Atlas connects the systems you already run to the ontology, in place. Add a source, map its fields to objects and properties, choose how it stays in step, and approved changes write back. Nothing is migrated, and the source system stays the system of record.
Sources 5
Maintenance ERP → ontology in step · 4 s ago
| Source field | Object | Property | |
|---|---|---|---|
AUFNR | → | maintenance-work-order | workOrderNumber |
QMTXT | → | maintenance-work-order | faultDescription |
PRIOK | → | maintenance-work-order | priorityLevel |
EQUNR | → | haul-truck | link: belongs to |
ERDAT | → | maintenance-work-order | reportedAt |
Records stay in the source system. Atlas maps them onto objects, keeps them in step and writes approved changes back.
- Connect a source: databases, ERP and maintenance systems, message streams, file shares and spreadsheets.
- Map: each source field to an object property, or to a link between objects.
- Keep in step: live, on a schedule, or on event, per source.
- Write back: a transition approved in the ontology is written to the system that owns the record.
Connecting a legacy system means a migration project, a copy of your data in their cloud, and a second source of truth.
Studio · Agents
Agentic Studio
Agentic Studio is where you build the agents that work on the ontology: bind each one to the objects it serves, give it a schedule and a role, and turn on Self Improving Memory, so every run is graded against its own instructions and the agent keeps what it learned. When you publish, the agents export with the application, beside manifest.ts, and you run them yourself.
Managed agents 4+ New agent
| Agent | Bound to | Runs | Self Improving Memory | Last grade |
|---|---|---|---|---|
| fault-to-work-order | Maintenance Work Order | hourly | memory on | +1.00 |
| critical-escalation | Supervisor Alert | every 30 min | memory on | new |
| evidence-attach | Evidence Clip | hourly | memory on | new |
| sla-watch | Supervisor Alert | hourly | memory on | new |
Export targets
The memory loop is the one behind Hyper Pragma: a judge on an open weight model, one lesson per run, and a person who can retire any lesson.
Agents are hosted features you configure, not software you own. Their memory, if they have one, stays with the vendor.
Dockerfile
Run it anywhere
The export is a standard Node.js service on Postgres, with a Dockerfile, migrations and an OpenAPI description. Run it on premises, in your private cloud or air gapped, beside models you host yourself.
$ npm run build && npm start # or: docker build -t mining-ontology .
# Postgres of your choice, inside your network
# one instance behind /mcp until a shared token store is configured
# no call leaves your walls: models, agents and data stay where you run themAir gapped is a separate product line, if it exists at all.
$ ls starters/
Start from a real ontology.
Each starter is a Hyper Studio project and the repository it exports.
Collision avoidance, maintenance and evidence for an open pit mine, with the agents that run on it.
The orderStatus lifecycle of a work order, generated as a state machine that refuses every move it does not allow.
Bring one operation and its systems. We build its first ontology with you, export it, and hand you the repository.
$ hyper community