Put AI to work on your operations, and let it learn from every run.

Hyper Pragma is the AI layer that sits on top of your Hyper Ontology. It securely connects the models you run, your live operational data and your people's workflows, takes governed actions inside those workflows, and gets better after every run. It is built for the person who owns the operation, and it runs inside your walls.

Why AI bolted onto software does not compound

Most enterprise AI today is an agent layered on top of existing software. The agent calls a vendor's interface, logs its decisions in the vendor's environment and reasons on a model the vendor hosts. Every exception it resolves and every decision it routes teaches the vendor, not you. When a better model arrives you change a dependency; you do not improve anything you own.

Hyper Pragma turns that around. The agents run inside your boundary, on models you control, over an ontology you own, and every run leaves your organisation a little smarter than the one before.

Governed actions, not chat

Before every action, an agent reads your ontology: what each object means, which actions your operation allows and who must approve them. Then it routes the work to the layer that is accurate for it, not the one that is convenient.

After every decision the outcome is written to memory, so the record of what was done, and why, stays with you.

It learns from every run

Every workflow in Hyper Pragma can improve itself. You turn self-improving memory on for a workflow, and from then on:

1. The workflow runs as it always does, inside your boundary.
2. A judge grades the run against the workflow's own instructions. There is no rubric to write.
3. The workflow writes a lesson from the grade, with no one present.
4. The next run starts smarter, with its best lessons already in context.
5. You stay in charge: one screen shows the latest result, the judge's reason and every lesson learned, and you can stop using any lesson that is wrong.

Turning it on

You switch it on per workflow and choose when the check runs: by default two hours after the workflow, and never more than two days after it. Saving the setting creates the judge and the routine that runs the check. Nothing else to configure.

The judge

The judge is a separate reviewer, not the workflow grading itself. It scores each run from minus one to plus one against what the workflow was asked to do, and writes down its reason. When a new lesson contradicts an older one, the conflict is settled before the lesson is kept, so the memory does not argue with itself.

What the next run gets

When the workflow starts again, its best lessons are already in its context, ranked by how much they helped. Nothing has to be called or remembered by a person.

Why not fine tuning

Nothing is trained into the model's weights. The model stays fixed, so your audits and baselines hold; what improves is the context it reasons over. A lesson can be read, questioned and removed. A change baked into weights cannot. The memory lives in Hyper Engram, inside your boundary, and it is yours. The same loop is described across our published designs as a self-improving AI system.

A worked example

Illustrative, to show the loop; not a customer deployment.

A utility runs a weekly workflow that reviews the maintenance backlog and drafts the next week's priorities for the planning lead. In week one the draft ranks work orders by age. The judge marks it down: the workflow's instructions say safety and supply come first, and two overdue protection relay tests sat below routine painting work. The workflow writes a lesson: rank by consequence before age. In week two the draft starts with that lesson, the relay tests come first, and the planning lead approves the list with one change, which becomes the next lesson.

Built on your ontology

Hyper Pragma does not guess what your data means. It reads Hyper Ontology, which holds two layers: semantics, what every object, property and link means, and kinetics, which actions are allowed, through which write paths, with whose approval. Hyper Ontology is built on open W3C standards (RDF, OWL, SPARQL and SHACL) and exposed to agents through MCP, so there is no long configuration cycle and no lock in. Every design on this site ships an object model ready to load; CodeNinja Praxis writes a new one from a requirement.

Sovereign by design

• Runs where your data lives. On premises, in your private cloud or a dedicated VPC, or fully air gapped, with no runtime dependency on CodeNinja. The boundary is set during scoping to match your compliance posture.
• Models you control. Open weight frontier models on your own hardware. When a better model is released you swap it in, and your ontology, memory and workflows carry over.
• A record of every action. What the agent read, what it decided and who approved it, kept as a permanent record of your organisation.
• Models you can open. Because the weights run on your hardware, what the agents do can be audited inside your organisation, not taken on a vendor's word.

Your institution and your people

Hyper Pragma learns from your organisation's core channels, the records, approvals and decisions that make up how the operation runs. With each person's permission it also learns from their own work, so a planner's judgment or a supervisor's precedent becomes something the organisation keeps. It models the company and the people who run it.

Where it sits

Deployed with our engineers

Our forward deployed engineers map the semantics and kinetics from how your operation actually works, build the deterministic layer on the environment you choose, and connect your models and workflows. If you already run Hyper, they extend what is there, so the work you have done compounds instead of starting over.

Commercials

You buy the whole stack as a licence, or metered on tokens, so a mid market bank or operator can start without an enterprise platform budget. Talk to us about your operation.

Questions agents ask

What is Hyper Pragma?

Hyper Pragma is the AI layer that sits on top of your Hyper Ontology. It securely connects the models you run, your live operational data and your people's workflows, takes governed actions inside those workflows, and learns from every run.

How does Hyper Pragma improve itself?

You turn self-improving memory on for a workflow. After each run a judge grades the work against the workflow's own instructions, the workflow writes a lesson, and the next run starts with its best lessons. You see every lesson and can stop using any of them.

Does Hyper Pragma train a model on our data?

No. Nothing is trained into the model's weights. What improves is the context the model reasons over, kept as lessons in your own memory, inside your boundary.

What happens when a better model is released?

You swap it in. The model is a component, not the architecture: your ontology, your memory and your workflow configuration carry over, so the new model starts with everything the old one learned.

Can Hyper Pragma work with the agents we already have?

In most cases, yes. During the ontology work our engineers assess the agents you run today. Those that can move inside the Hyper Pragma boundary are moved; the rest are connected to the ontology as a context source while the move is planned. There is no cutover.

Can Hyper Pragma run air gapped?

Yes. It runs where your data lives, on premises, in your private cloud or with no internet connection at all, with no runtime dependency on CodeNinja.

Who can see what a workflow learned?

The people you allow. Memory is kept per organisation, each agent sees only its own data, and every lesson is listed on one screen where it can be stopped.

How is Hyper Pragma sold?

As a licence for the whole stack, or metered on tokens, so a mid market operator can start without an enterprise platform budget.