A different starting point for ontology engineers
Ontology engineering gives systems a shared account of what exists and what it means.
Most of the data it works on reaches it as residue: states that persistence chose to keep, from which the acts that produced them have to be inferred. Puppeteer starts earlier. This note says where, what follows for what travels between organisations, where the idea sits among its neighbours, and what the evidence on this site does and does not establish.
StanceA perspective worth evaluating, not a settled result. Each piece of evidence links to the page that states its own limits.
The act is kept as the act.
A Puppet is a software subject with a repertoire — its domain — and a history of the acts it has admitted. Its classes are material; what the program models is the subject that acts with them.
An act is kept as that act: who performed it, and under which rules it was admitted. State is derived from the history, not the history from the state, so the storage model stops deciding what can later be known.
The history of a subject is not the history of its storage.
What this does not establish is that what was declared is true. What it keeps is who declared it, under which rules it was admitted, and which act was recorded.
- Subject of a proposition
- What a statement is about.
- In RDF, the subject is the thing a triple describes. The semantics are descriptive: they say what is the case, and the acts behind it have to be inferred from what was kept.
- Subject of an action
- Who did something.
- Here the subject is the one that acts, and the act is admitted under its own rules at the moment it happens. The semantics are performative: the act does something rather than describing something.
Domain and History, instead of a description of them.
When one organisation's records have to be read by another, the usual answer sends the data with a semantic description — a vocabulary, a mapping — so the receiver can interpret it. The agreement about meaning has to exist before the exchange.
The same starting point changes what can be sent. One party can deliver the Puppet itself: its domain and its history. The receiver keeps it inside its own boundary and asks it new questions, answered by the sender's own implementation of what its records mean — including through an AI assistant on the receiver's side.
The ontological agreement does not disappear. It moves: from before the exchange to the point where answers are combined.
The neighbours, and what each one already settles.
A reader who works on ontologies will know these. Naming them is what keeps the invitation honest: each one removes a claim this note is not making.
- PROV-O, event and commitment ontologies
- Agents, activities and responsibility are modelled already. PROV-O describes, after the fact, that an agent was responsible for an activity. Here the subject admits the act when it happens, under its own rules — a runtime, not a description of one.
- Event sourcing, durable workflows, transaction logs
- Deriving state from a history is established practice, and the journal here is an append-only one, as in event sourcing. What differs is whose history it is: a subject's, kept under the authority that admitted each act.
- The actor model and multi-agent systems
- Software that acts and communicates concurrently is not new, and Puppeteer starts from the actor. The site's own line: actors give us concurrency; Puppeteer gives them subjecthood.
- Mobile agents
- Code and state travelling to another host was explored in the 1990s. What is delivered here is a repertoire and a history that the receiver keeps and interrogates, not a program passing through.
- Data capsules and data preservers
- Data that travels with the code allowed to touch it, run under a controlled host interface. The box inside Mymi is a close relative: the institution's module runs in a sandbox that closed eight of eight attempts to get out.
- Data visiting and federated analysis
- The computation goes to the data instead of the data to the computation. Here the two are already in one place: the receiver keeps the domain and the history, and the question is asked there.
- FAIR digital objects
- Machine-actionable objects that agents can find and act on. A delivered Puppet is actionable in a particular way: it answers with the sender's own implementation of what its records mean.
- Solid and personal data stores
- Data stays under its owner's control and agents use it. Mymi shares the premise; what the person holds is the institution's records together with the rules that read them, so the answer is computed where the records are.
What we have not found is these pieces assembled with this intent: a subject whose identity is the continuity of the authority under which its acts are admitted; and a historical, executable representation that one party deliberately delivers to another, which keeps it and interrogates it under its own computational authority, with consumers that were not built for the sender.
We propose it as a perspective worth evaluating, not a settled result.
Can an executable representation of a domain reduce the need for prior ontological agreement between organisations, without losing the receiver's ability to interpret and combine what it learns?
Stated as something to test, not as something shown. The evidence below is where we are so far, each piece with the limit its own page states.
What is on this site, and what each piece does not establish.
- Ten papersThe Puppeteer Papers Series
What it shows
Ten papers, in the order the argument was built — identity, authority, causality, the journal as substrate, the assembled verb. Deposited on Zenodo, each with a DOI, and each with a laboratory anybody can run.
What it does not establish
An argument with laboratories behind it, and still being written: further papers are underway. What a paper measures is in its laboratory, not on the page that lists it.
- Deployment demoOne Play, Many Stages
What it shows
A Tetris domain held fixed while five stagings and six clients were built around it. The evidence is a diff over the domain directory, across fifteen commits, coming back empty.
What it does not establish
An empty diff is gameable by construction, and the stagings were written by the domain's own author. It measures invariance under staging, not under evolution; it is not a resilience result, and not a cost or performance evaluation.
- Executable comparisonThe Same Invoice, Twice
What it shows
The same invoice built two ways. In the Puppet implementation the domain owns the act: whether an act is valid, and what follows from it, is decided in the domain, with infrastructure at the boundary.
What it does not establish
An existence proof that the separation is buildable — not a cost or performance evaluation.
- Running systemThe Village Hall
What it shows
A bingo night on the phones in the room: no server, no database, one journal per handset. A wrong ball is fixed by a new entry, and every phone that replays the journal shows the same board.
What it does not establish
One evening staged entirely inside one hall. Nothing outside the room took part, and that is the extent of what it shows.
- Deployment demoThree Machines, One Paper
What it shows
The Ordering bounded context of Microsoft's reference microservice application, on a program that keeps its own journal, running on three machines that admit each other with a QR code printed on paper. Zero edits to the domain.
What it does not establish
A structural permission through one working case — not an appliance delivered end to end. It does not solve consensus, and the experiment is at three peers.
- Coordination seriesThe Stage Manager
What it shows
Five cases in which the things every machine must agree on — the price list, the catalogue, who counts as a member — are characters with a history rather than a second system beside the application.
What it does not establish
It dissolves the catalogue shape of coordination. It does not dissolve coordination tied to liveness: ephemeral locks, leases that expire with a session, ownership that depends on a heartbeat.
- Engineering recordFour ways to run a module on a phone — inside Mymi
What it shows
The institution's code and package never changed across four ways to run them on a phone, each figure named with where it was taken. In the box, eight of eight escape attempts closed.
What it does not establish
Its own “What this does not say”: no arrangement is the final one, no store has accepted anything, and the box was not built for macOS or for iPhone.
Context, not proof: Puppeteer has been in continuous production since 2018.
If this overlaps with your work, we would value your critique.
Which neighbour this note has misread, which claim the evidence does not carry, which question is worth running next. The papers and the laboratories are public; the demos run.