Arkhe: An Ontology Language for AI Systems

Two weeks ago I argued that the ontology layer is where the recurring agentic failures get retired, and that the artifact doing the retiring should live in your repository rather than a vendor’s console (Stevens, 2026a). I closed that piece with a demand: insist on a neutral, versioned, reviewable form for your entities, relationships, and permitted actions. The obvious follow-up question: neutral form in what language, exactly?

So I spent my evenings since building one.

Arkhe v0.2.0 shipped today: a small, open-source ontology language for AI systems. Arkhe is my personal project, written on my own time, Apache-2.0 licensed, free forever, with no CLA. It is a Sakura Sky product in no sense at all. I am writing about it here because the argument started here.

One file, three registers

An Arkhe module is a YAML file in git. It declares the three registers from the previous post: what exists, how it connects, and what may be done, by whom, with what trace.

entities:
  FinancialModel:
    keys: [model_id]
    properties:
      status: {type: state, values: [draft, in_validation, validated, production, retired], initial: draft}
      last_validated: {type: date, optional: true}

links:
  owned_by:
    from: FinancialModel
    to: TradingDesk
    cardinality: many_to_one
    reverse: models

actions:
  grant_production_use:
    target: FinancialModel
    guard: target.status == "validated" && months_since(target.last_validated) <= 12
    authority: head_of_model_risk
    audit: mandatory
    effects:
      - target.status: production

Listing 1. A fragment of the model-risk fixture: an entity, a link, and a guarded action.

A head of model risk can read that file and object to line eleven. That property, reviewability by the person who owns the business concept rather than the pipeline, drives most of the design. Guards are written in CEL, Google’s Common Expression Language, because it is small, side-effect free, and already the policy expression language of half the cloud estate (Google, n.d.). The world is closed: entities and actions that are absent from the file are absent from the system, and no inference engine conjures new ones. The philosophical tradition behind the word ontology is acknowledged and then firmly set aside; Gruber’s definition, an explicit specification of a conceptualisation, is the whole ambition (Gruber, 1993).

The other load-bearing decision: the spec is a contract, never a runtime. Arkhe compiles your module into a neutral intermediate form, one tool contract per action, and emitters generate what your systems consume from there. Nothing of Arkhe executes in your serving path. If the project vanished tomorrow, everything it generated for you would keep working, and the YAML would still be yours to compile with something else.

What compilation buys you

The compiler pipeline is deliberately dull. Validate the module (structural rules from a published JSON schema, then semantic rules: key references, link endpoints, guard names, effect types). Generate contracts. Emit.

Two emitters exist today:

1. The first produces a native Python library of guarded functions: call grant_production_use on a model that was validated fourteen months ago and you get a refusal that names the failing clause, months_since(target.last_validated) <= 12, rather than an exception or, worse, a success. An agent wired to those functions inherits the refusal semantics without any prompt engineering.
2. The second emitter, new in v0.2, produces an Open Knowledge Format bundle: one markdown concept document per entity, link, and action, generated from the module’s annotations, for LLM consumption.

I think of the pair as complementary halves: the contracts declare what an agent may do, and the OKF bundle declares what it should know. Both are regenerated from the same file, so they cannot drift apart.

v0.2 also added synonyms as first-class annotations, so grounding can match the vocabulary people actually use (“desk” for TradingDesk, “sign-off” for grant_production_use) while the canonical names stay stable, and resolved types inline on effects, so downstream consumers stop re-deriving what a write will do.

The release I am most pleased with, though, is the one users will never invoke: a second implementation. The Rust port of the validator now passes the same frozen golden fixtures as the Python reference. Porting surfaced three behaviours the spec had never actually decided, all inherited silently from Python’s YAML library, including the venerable Norway problem, where no parses as a boolean. All three are now pinned strictly in a public ADR. My conclusion from that exercise is worth its own post: a language with one implementation has a spec by accident.

Who it is for

I wrote persona guides for the three audiences I keep meeting in this work, and they map onto the registers:

• GRC professionals get controls as structure. authority: head_of_model_risk and audit: mandatory are enforced properties with a trace, and a refusal that cites its failing clause is audit evidence in a way that a prompt instruction never will be. The reviewable YAML is the control library; the git history is the change record your auditor keeps asking for.

• Data engineers get the semantic layer as code, sitting in the same repository as the schema it describes, validated in CI with finding codes and line numbers like any other artifact. If you have ever maintained business definitions in a wiki while the warehouse drifted underneath them, the appeal of arkhe validate failing your pipeline should be immediate.

• Architects get protocol independence. The tool-contract IR sits at the centre; MCP, OpenAI function schemas, and Google ADK tool definitions are all planned as thin emitters from it, which means the protocol churn of the past two years stops being a rewrite trigger. Choosing Arkhe commits you to a file format, and deliberately to nothing else.

The use case I most want to see built, and intend to build as the flagship module, is an ontology of the AI estate itself: models, agents, tools, datasets, evals, guardrails, and incidents, with actions like promote-to-production guarded on eval results. The industry currently manages its most consequential systems with less structural rigour than it applies to a customer table. That seems worth fixing with the same medicine.

What it refuses to be

Arkhe is a language and a compiler. There is no workspace, no operational database, no query engine, no agent runtime. Palantir productised the three registers inside a platform a decade ago (Palantir Technologies, 2026), and several open projects are now circling the same territory with runtimes attached; the prior-art section of the README names them rather than pretending the idea arrived from nowhere. The bet Arkhe makes is narrower than any of them: the durable artifact is the reviewable file and its compiled contracts, and everything stateful belongs to systems you already run. If that bet is wrong, the cost of having tried it is one YAML file you can still parse with anything.

v0.2.0 is on PyPI (pip install arkhelang), crates.io (cargo install arkhe), and GitHub, with the spec sketch, nine ADRs, the golden fixtures, and the persona guides. It is deliberately small. If the previous post convinced you the neutral form should exist, this one is an invitation to argue with a concrete candidate, ideally in the form of an issue with a failing fixture attached.

Disclosure: Arkhe is the author’s personal open-source project and is unaffiliated with Sakura Sky; Sakura Sky has no commercial interest in it. The author also maintains GATE, an open framework for governed agent runtimes, with which Arkhe aims to interoperate on equal terms with any other runtime.

References

Google (n.d.) Common Expression Language specification. Available at: https://github.com/google/cel-spec (Accessed: 23 July 2026).

Gruber, T.R. (1993) ‘A translation approach to portable ontology specifications’, Knowledge Acquisition, 5(2), pp. 199-220.

Palantir Technologies (2026) Ontology overview, Foundry documentation. Available at: https://www.palantir.com/docs/foundry/ontology/overview (Accessed: 23 July 2026).

Stevens, A. (2026a) Your ontology is the asset. Stop renting it back. Sakura Sky, 10 July. Available at: https://www.sakurasky.com/blog/own-your-ontology/ (Accessed: 23 July 2026).

Stevens, A. (2026b) Arkhe: an ontology language for AI systems. Available at: https://github.com/arkhelang/arkhelang (Accessed: 23 July 2026).