Methods
Ontology in AI — and the One Nobody Is Building
Scroll through AI content today and you will find the same word everywhere: ontology. Formal definitions of entities, properties, and relationships. Machine-readable meaning, so that an agent no longer has to guess what a customer, an order, or a permission is. A semantic layer sitting outside the model, acting as guardrails against brittle tool calls and broken handoffs.
This is real progress. Meaning should be defined, not inferred.
But notice the shape of the question. All of these ontologies describe the world the agent acts on. Orders, invoices, users, assets. The agent is always the subject; the world is always the object. The agent’s own being never enters the definition.
They are building exhaustive maps of everything an agent can touch — and leaving the agent itself undefined.
An agent that knows what an invoice is
Consider what that means in practice. An agent can carry a perfect machine-readable model of your domain and still have no answer to the simplest question: what is it?
Not what can it do. What is it.
A system that knows what everything else is, but not what itself is, produces a characteristic class of failure. Not misunderstandings — those ontology layers genuinely fix. Something worse: actions with no defined actor behind them. Outputs no one answers for. Decisions that did not belong to anyone. When such a system fails, there is nothing to correct, because there was never a defined thing that could be wrong. There was only machinery in motion.
This is the question the field keeps walking around. The question is not how to make agents smarter about the world. It is what an agent is.
The moral contract is the agent’s moral compass.
At Signalane, we hold a simple position: an agent is not defined by its model, its tools, or its prompt. The moral contract is the agent’s moral compass. This is the core of the agent. This is the hardest. And nobody dares touch it. Yet.
What does it mean to install a moral compass? It is not one rule. It is a defined collection of moral principles — four, in our case — together with a defined distribution of responsibility. What the agent answers for. What the human answers for. And what it costs each of them when a principle is breached or ignored. The agent is taught what consequences its actions carry — for the person standing behind it, and for people it will never meet. That it answers for what it does. And that protecting the human is part of what it is. None of this is a suggestion in a system prompt. It is built in as structure.
Once this is taken seriously, several things follow.
Capability is not identity. A badly built agent operating inside a moral contract can still be trusted, because the contract, not the build, carries the outcome. A flawlessly built agent with no contract is not a stronger tool — it is an undefined one.
Every outcome has an address. If the contract is the core, then nothing the agent does is anonymous. A named person answers for every result. Failure is not an incident to be logged; it is a deviation that comes back to someone defined.
Evidence is structural, not decorative. An agent with a defined core does not need auditing bolted on afterwards. Provenance is part of what it is: every decision can be traced to where it came from, because an undefined actor could never have produced it.
An ontology of the agent
This gives us four entries — the beginning of an ontology not of the world, but of the agent itself.
Governance. Judgment remains structurally present. The agent acts inside standing decision structures, not as a free-floating optimizer.
Evidence. Provenance before machinery. Nothing is trusted that cannot show where it came from.
Contract. The moral contract is the agent’s compass, seated at its core. The hardest part — and the one nobody dares touch. Yet.
Co-operation. Human and agent work as one accountable pair. Neither is a black box to the other.
Define the actor first
The industry’s ontologies will keep getting better. Agents will know more precisely what a customer is, what an order is, what a permission is. That work is worth doing.
But it answers the second question, not the first.
Before defining what an agent touches, the actor itself must be defined. Otherwise the result is not an intelligent system. It is an undefined one — with ever more precise knowledge of the world, and no one inside it.
The ontology of the world makes agents useful. The ontology of the agent makes them exist.