Read cofounder Muhammad Umar's memo, Compression and Reinflation
CodeNinja AtomsUnited StatesSaudi ArabiaPakistan

$ 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.

Hyper StudioMining_Gold_Project

Change the object

src/mcp/manifest.tsgenerated · do not edit by handpublished

$ 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.

why-hyper.diff
--- 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.

terminal
# 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-docs
Elsewhere

You 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.

project tree
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.json
src/mcp/manifest.ts · the shape of every object
export 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;
}
Generated, never hand editedStudio is the source of truth for what things mean. The manifest is its derived layer, rebuilt on every publish.
Typed end to endObjects, links, lifecycles and functions are TypeScript types your editor and your agents both understand.
A report on every buildgeneration-report.json lists every decision the generator made and why.
Elsewhere

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.

  1. Object: an apiName, a display name, a description and a labelProperty people recognise.
  2. Synonyms and domain: synonyms for every other name, semanticDomain for where it belongs.
  3. Links: a cardinality, the property that stores it, a phrase that reads as a sentence, and via, the tool that walks it.
maintenance-work-order, from the generated manifest
{
  "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" }
  }]
}
Elsewhere

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
// 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;
}
Initial and terminal statesA new work order starts unassigned. completed and cancelled end it.
Role gatedEvery transition carries a permission. A person and an agent pass the same check.
One error for every bad moveKINETICS_INVALID_TRANSITION, with the states it was allowed from.

Try it: move a work order through its lifecycle.

Elsewhere

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>.

functions in the manifest
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" }
Elsewhere

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.

what an agent calls
// 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.

Elsewhere

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.

Mining_Gold_Project
CollectionsRolesAreasAutomationAtlasAgentsSettingsCodeInterface
Publish

Sources 5

Maintenance ERPSAP PM · OData
Live
Fleet managementDispatch · SQL Server
Every 15 min
Collision avoidanceCAS · MQTT
Live
Video managementVMS · REST
On event
Permit registerpermits.xlsx · SharePoint
Nightly

Maintenance ERP → ontology in step · 4 s ago

Source fieldObjectProperty
AUFNR→maintenance-work-orderworkOrderNumber
QMTXT→maintenance-work-orderfaultDescription
PRIOK→maintenance-work-orderpriorityLevel
EQUNR→haul-trucklink: belongs to
ERDAT→maintenance-work-orderreportedAt

Records stay in the source system. Atlas maps them onto objects, keeps them in step and writes approved changes back.

  1. Connect a source: databases, ERP and maintenance systems, message streams, file shares and spreadsheets.
  2. Map: each source field to an object property, or to a link between objects.
  3. Keep in step: live, on a schedule, or on event, per source.
  4. Write back: a transition approved in the ontology is written to the system that owns the record.
Elsewhere

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.

Mining_Gold_Project
CollectionsRolesAreasAutomationAtlasAgentsSettingsCodeInterface
Publish

Managed agents 4+ New agent

AgentBound toRunsSelf Improving MemoryLast grade
fault-to-work-orderMaintenance Work Orderhourlymemory on+1.00
critical-escalationSupervisor Alertevery 30 minmemory onnew
evidence-attachEvidence Cliphourlymemory onnew
sla-watchSupervisor Alerthourlymemory onnew

Export targets

BackendAPI, models, routes, manifest.ts✓
FrontendComponents, pages, hooks
Agentic StudioManaged agents, their memory and schedules✓

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.

Elsewhere

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.

production
$ 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 them
Elsewhere

Air 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.

mining-gold-copper-safety

Collision avoidance, maintenance and evidence for an open pit mine, with the agents that run on it.

TypeScriptPostgresMCPKinetics
18 objects · 46 links · 2 lifecycles · 4 agent tools
maintenance-kinetics

The orderStatus lifecycle of a work order, generated as a state machine that refuses every move it does not allow.

TypeScriptKinetics
6 states · 5 transitions · 1 error code
your-operation

Bring one operation and its systems. We build its first ontology with you, export it, and hand you the repository.

StudioAtlasAgentic Studio
one build day · your repository