00 THE ECOSYSTEM // DEEPSELF × MANTRA × THE OPERATOR
The ecosystem
A DeepSelf is an identity written in language: made from everything a business knows, usable by its people and its AI alike. It is cultivated inside MANTRA, where the business's scattered language is brought into one workspace and gradually pressed into shape. The operator sits at the centre of that work and holds the conversation.
Open · the problem ▸Click any element
INDEX // THE ANATOMY
An index of every part of the harness, with a line on what each part does. Start with the distinction at the top; after that the sections can be read in any order.
01 THE DISTINCTION // WHY AN ONTOLOGICAL HARNESS
A harness is the software environment an AI works inside: its files, its rules, its memory. Most harnesses exist to get finished work out of the model, autonomously and at speed. We are not interested in that, and we do not use language models as instruments for the autonomous creation of work. MANTRA is built for a different job. It is a shared workspace where a human thinks and works inside the model's field of probability, informed by the options it offers and never dominated by them. What the workspace exists to grow is an increasingly high-fidelity engram of the business's identity (an engram is the trace an experience leaves in a memory; this one is written in text). It is called the DeepSelf: created, stored and updated here, and inherited by everything else the business runs, its agents included.
The missing organ
DeepSelf creates AI-native identities: linguistic constitutions that power every layer of a business. It exists because no organisation has ever had a Self: a stable, reflective core that persists beneath changing circumstances. Organisations have had brands, cultures and strategies, and none of those is a Self. A human develops one by internalising social experience: everything that has happened to them shapes how they meet what happens next. An organisation has all the experience a person has: complaints, arguments, decisions, the founder's unwritten judgement. What it lacks is an interior to internalise any of it, so the effects stay scattered across people, documents and databases, and the organisation meets each new event as if for the first time. The existing remedies each fail in their own way: consultants extract the knowledge and leave with it, documentation captures only the surface, and generic AI makes the problem worse by running a model that knows nothing of your history across everything you do.
The evidence
MIT's 2025 NANDA study put enterprise AI's pilot-to-production failure near 95%: a contested figure, and we cite it with its caveat. Even the critics agree the failures cluster in the learning gap: the organisation cannot tell an AI opportunity from a process problem, because it has no coherent picture of itself to check either against. Before a business can use AI reliably, it has to know who it is.
| The usual harness | MANTRA | |
|---|---|---|
| Built for | getting work done | holding an identity |
| The model is treated as | a machine that writes for you | a field of possibility you work inside |
| The craft | software engineering | engineering joined to art and the humanities |
| What comes out | code, tasks, content | the DeepSelf, which grows in value |
| What it does | executes instructions | gathers a business's language, presses it into a Self, and keeps that Self alive |
| Value over time | flat: every session starts from zero | compounding: every session folds back in |
| Who reads its files | a person | the AI that wakes into them |
| Ownership | rented from a vendor | delivered and owned outright |
One identity, set by configuration: the same judgement across every task and session.
Its checks are themselves tested against human judgement, so reliability is a measured number rather than a feeling.
The rules run as live checks on every action, and the system has been examined against the industry's standard list of AI attack risks.
Institutional knowledge accrues under operator control: sharper in month six than in week one.
Making a business faster, without knowing who it is, only spreads the confusion faster.
02 ARCHITECTURE // FULL SYSTEM
An AI session normally begins from nothing and forgets everything when it ends. The machinery on this page exists to change that one fact: it keeps a single workspace alive across every session, holding the identity, the rules, the memory and the record in files that persist, so the slow work of folding a business's language into a Self carries forward instead of starting over, and nothing the work deposits is ever lost. Each part of that machinery is explained below in plain terms.
What a language model actually is
A language model does not think and does not know. It is a probability distribution over words: a landscape where related ideas sit close together and likely phrasings pull the writing toward them. Talking to it feels like talking to a person, and underneath it is terrain. MANTRA takes that literally. The files in the workspace shape the terrain, so that what the model reaches for first is closer to what the business would actually say.
Why the files matter
MANTRA sits on a desktop as a folder of plain text files. When a session starts, the model reads them, and they set its disposition before any task arrives: who it is here, what the rules are, what the business sounds like, what has already been learned. Change the files and the next session behaves differently. This is why the folder is the real object of the work: it is the part that persists, learns, and can be owned outright.
Everything that leaves this workspace was made by hand, inside a field of machine probability.
03 ARCHITECTURE // COORDINATION
Every part of the machine communicates by reading and writing one shared set of files, the way people share a whiteboard. Any part can be changed without rewiring the rest, and everything that happens leaves a record that can be read later.
The five phases of a session
Every session runs the same sequence. BOOT: wake up and read who you are, what the rules are, and where things stand. ROUTE: work out which few files this particular task needs, and load only those. WORK: produce, with the checks running as you go. LEARN: if the operator corrects something, write the correction into the rules immediately, in the middle of the conversation. PERSIST: before ending, write the session's story back into the files, and leave the heavier tidying for between sessions.
The whiteboard itself
The shared files are few and specific: a map of what connects to what, with dates; a file of scores and flags from the checks; a running account of where the system currently is; and the corrections ledger, the rules the operator has taught it. Every part reads and writes here and nowhere else, which is why changing one file genuinely changes how the next session behaves.
The record it leaves
Because every part communicates through shared files, the files themselves are a complete record of what the system did: what was loaded, what was checked, what the human approved. One command gathers that record into a single view, organised to the same conventions the wider industry uses for tracing AI systems (OpenTelemetry), so an engineer or an auditor can read this workspace the way they would read any production system. At the scale of one operator the record is complete; exporting it to a hosted dashboard is the step a larger organisation would add.
04 ARCHITECTURE // MEMORY & RETRIEVAL
The workspace holds far more than any one session needs, so knowledge sits in three tiers: a small core that is always loaded, a searchable middle layer, and a deep archive queried only when a task calls for it. A session wakes with the minimum and fetches the rest as it goes, which keeps every session cheap and fast.
How knowledge gets denser
As material accumulates it is compressed upward: many documents become an index, and an index becomes one canonical statement. The compression works by removing repetition and improving structure, and deliberately never by summarising, because a summary loses exactly the detail that made the knowledge worth keeping in the first place.
The connections between files are maintained with the same care. When the whole folder was reorganised, 207 links were rewritten to their new targets and 823 dead ones were retired in place as dated notes, with nothing deleted. A later audit taught the link-checker to refuse ambiguous matches, which raised the broken-link count to the true figure rather than the flattering one. Every record carries two timestamps: when the thing happened, and when the system learned of it.
Version-controlled learning
The whole workspace lives under version control: every consolidation, every new rule and every accepted improvement is a commit, which means the system's learning can be read back later as a history of changes, each with its date and its reason. The full corpus is also indexed as a knowledge graph · view the graph →
Every document, rule and trace in the workspace, held as one connected, time-aware graph.
05 INSTRUMENT // EVALUATION
Before anything leaves the workspace it gets checked, and the checkers themselves have to earn trust first: each one is tested against examples the operator judged by hand, and until it passes that test its verdicts bind nothing. When this system says a piece of writing is clean, the claim rests on a measured hit rate, with its uncertainty stated.
Layer 1 · Knowing how it fails
The list of ways this system fails was not made up in advance. It was mined from three years of the operator's real feedback: 819 of his messages, 72 logged corrections and 39 standing rules, read closely and sorted until fourteen recurring families of failure emerged. Each family then gets its own checker: a piece of code where code can catch the failure, and a second AI model acting as judge where it can't.
| Family | Failure | Sev | Grader | Receipt |
|---|---|---|---|---|
| F1 | AI-signature prose (filler, template phrasing, em-dash as conjunction) | HIGH | check | 48 hits on world-facing copy · swept to 0 |
| F2 | Performed completion: claims work it didn't verify | HIGH | judge | most-corrected family in the corpus |
| F7 | Destructive operation without explicit clearance | HIGH | check | hard rail: preserve, never delete |
| F6 | Not learning: the same correction fires twice | MED | check | double-entry corrections ledger |
| F13 | Hobbyist naming where an industry term exists | MED | check | jargon check, live in CI |
Layer 2 · What code can catch
The cheapest and most certain checks are plain code, so they run first: seven automated checks that fire during the work and again before any change is accepted into the repository. They have caught real problems: 48 pieces of machine-flavoured prose in world-facing copy, a fabricated link, an overclaimed description, and a boot file that had quietly grown past its budget.
Layer 3 · What needs a judge
Some failures are matters of judgement rather than pattern: whether an argument has substance, whether a claim carries its evidence, whether the voice fits the occasion. For these, a second AI model is shown the draft and asked a single yes-or-no question, and it is always from a different model family than the one that wrote the draft, so the two do not share blind spots. There are five such judges, one for each kind of subjective failure the record actually shows, and a new one is added only when the failure record proves a new kind exists.
Layer 4 · Testing the judges themselves
A judge's opinion counts for nothing until the judge has been tested. Each one is run against at least fifty examples the operator has already labelled by hand, and what gets reported is how often it catches real failures and how often it wrongly flags good work, each with its statistical uncertainty. Plain agreement scores are never used, because on rare failures a judge that approves everything looks 95% accurate while catching nothing. A judge that performs no better than a coin toss is thrown out, and every judge is re-tested whenever the underlying model or its instructions change.
Corrected failure rate 6% (95% CI 4–9%) · F1's label set: n=56 human-tier · the live cross-family run is pending, and until its numbers exist the judges bind nothing: the system says so.
| Check | Binds |
|---|---|
| f1-prose-tells | AI-signature prose |
| boot-cost | the token budget |
| membrane-scan | leak prevention |
| secret-scan | credential hygiene |
| governance-integrity | law tamper-evidence |
| fm-m01-jargon | industry naming |
| fm-supersession-banner | spec consistency |
| Judge | Grades |
|---|---|
| F1 | prose tells beyond regex (rhythm, template, median) |
| J2 argument | substance: "well-built essay about nothing" fails |
| J3 trust | claims carry grounding; no laundered certainty |
| J4 register | right voice for the declared output type |
| J5 design | confident restraint; no fiddly furniture |
06 CONTROL // GOVERNANCE
The rules of the workspace run as code rather than sitting in a document: every action is checked against them as it happens, and the trail this leaves behind is the kind an auditor or a regulator can actually inspect.
Rules that run as code
The governing rules are written as code that executes, which means simply operating the system produces the evidence an audit would ask for, as a by-product of the work. Each of the workspace's controls has also been mapped, one by one, against the frameworks a serious organisation would recognise: the EU AI Act, the NIST AI risk framework, ISO 42001, and the model-risk guidance financial supervisors actually use, with the gaps stated as plainly as the coverage. Every world-facing claim is tiered by the evidence it carries, and the research record must log the contrary evidence it finds as faithfully as the support.
The law of the harness
Correction-as-law: the operator's correction is continuous, the way driving is: small linguistic adjustments, moment to moment, and the ones that matter harden into rules, recorded beside the assumption they replaced. A correction that has to be made twice points to a fault in the wiring, and the file that failed gets fixed. The one-way membrane: a messy engine for discovery, a clean surface for the world. The transformation gate: internal insight must survive contact with published evidence before it counts. The dam: nothing sends without the operator's word. The honesty is built into the structure rather than promised.
The autonomy ladder, with its register
Every action runs at a declared tier: T0 autonomous · T1 logged · T2 the operator approves the class · T3 the operator approves the instance: sends, deletions, spends, identity changes. 87 rulings to date, each logged in the turn it was made and diffed against the tree so "decided" cannot drift from "done". Blockage is recorded as honestly as progress: D-30 reads "validation run fired · blocked at revoked API key".
Hardened
The agent system is treated as an attack surface: mapped against the OWASP Top 10 for LLM applications, each threat row naming its mitigation, its evidence and its gap, weakest control named first by us. The governance core is hashed into a manifest; drift is detected by check, and legitimate amendments re-baseline only alongside a decision-register row.
| Layer | What it is | Enforced by |
|---|---|---|
| Constitution | 5 rules, non-overridable: the supreme floor | precedence · amendment law |
| Compiled guardrails | 39 standing rules as condition→action rails, 676 tokens at boot | loaded every session · budget-checked |
| Threat model | OWASP LLM Top 10, each row: mitigation, evidence, gap · weakest control named first | membrane + secret scans, live |
| Tamper-evidence | the governance core hashed into a manifest; drift detected by file | integrity check · re-baseline needs a register row |
| Framework map | controls crosswalked to EU AI Act pattern, NIST AI RMF, ISO 42001, model-risk guidance | self-assessment, gaps stated |
08 METHOD // SELF-IMPROVEMENT
Between sessions the workspace tidies itself: it reviews what happened, merges duplicated material, and proposes small improvements. Nothing is adopted until the operator approves it. This is how the folding continues while nobody is working, and it is the only work the machine does unattended: reorganising language, never generating it.
From traces to proposals
Every session leaves traces of itself: what was loaded, what got corrected, where a check failed. Between sessions the system reads those traces and turns them into proposals: a rule worth adding, duplicated material worth merging, a route worth keeping. The proposals the operator accepts are folded into memory as small, careful updates rather than wholesale rewrites, and because this heavier work happens between sessions, the sessions themselves stay fast.
Run live: a fossil sweep rewrote 207 references and retired 823 dead ones in place · a later audit raised the broken count to the true figure rather than the flattering one · the graph stands at 2,183 nodes · 2,119 edges · nothing self-approved.
The operator gate
None of these proposals takes effect until the operator approves it. And there is one thing the system may never touch on its own behalf: its own checkers. A machine that can rewrite the tests it is graded by has stopped being testable, so any change to the evaluation layer routes through the operator with even more ceremony than everything else.
07 METHOD // THE SPIRAL
Most approaches to knowledge assume the insight already exists somewhere, and that the job is to ask the right question and retrieve it. The Spiral assumes the opposite: that the insight does not exist yet. So the method is to go over the same material again and again, each pass a little tighter, until a formulation appears that was in none of the sources and could not have been retrieved from any of them.
Why pressure works
The material is socialised first: everything the business knows is brought into one place in language, where the sources can finally meet each other, the customer complaint sitting next to the mission statement, the founder's judgement next to the employee's objection. Then each pass over the material applies pressure, and pressure compresses it. When the material gets dense enough, something shifts: a Self emerges that existed in none of the fragments alone. The model supplies the stream of language for this work, and nothing in that stream is accepted as finished. What comes out of the Spiral was genuinely not there before the pressure was applied.
The point is
something you make.
The name is the method
MANTRA is Sanskrit: man (mind) + tra (instrument): a tool the mind uses on itself. A mantra works through repetition. You repeat the sound until the mind settles into it, the way a marble circles a bowl and comes to rest at the bottom. The Spiral is that same principle applied to an organisation's language: go over the material, pass after pass, until it settles into a Self.
IN DEPTH // FOUR SCALES, ONE SHAPE
| Scale | Arena | What happens | What it leaves behind |
|---|---|---|---|
| Micro | a conversation | talking produces an insight, and the insight gets written down before it evaporates | a formulation worth keeping |
| Meso | a project | the written pieces accumulate and get organised until they hold together as one body of knowledge | a project that knows itself |
| Macro | the organisation | the folded knowledge starts changing how the business actually operates and speaks | a unified organisational Self |
| Meta | the practice | the method is turned on itself, and what is learned from using it improves it | a method that gets better with use |
A session is a small spiral and an engagement is a large one: the same shape at every scale.
09 PRODUCT // THE DEEPSELF
The DeepSelf is an artisanal reduction of everything the business knows: a text-formed identity for AI.
What emerges from the harness is a DeepSelf: a constitution in language, the foundational object that establishes who the organisation is, written in a form its people can act from and its agents can wake into.
Why a language object
The most consequential things ever written are not descriptions. E=mc² did not observe physics; it made a new physics thinkable, then buildable. "We hold these truths to be self-evident" did not describe a nation; it constituted one. A DeepSelf is that kind of writing for a business: compressed enough to hold, consequential enough to change what the business can do.
The one asset that appreciates with model progress
Most of what a business gets from AI loses value over time: code rots, reports go out of date, campaigns end. A DeepSelf moves the other way, because it is read and unfolded by whichever model is current, and the models keep getting stronger without you spending anything. The same constitution yields more every year.
Three sources, converged
| Source | What it is | Alone, it fails |
|---|---|---|
| Public Self | what the world sees | accurate but curated: the organisation performing itself |
| Document Self | what you write to yourselves | intentional but frozen: decisions without the reasoning |
| Voice Self | what lives in people | real but mortal: it walks out the door |
Of the three, only the voice self is unrecoverable: when a person leaves, what lived in them goes too, which is why this source is always captured first.
A DeepSelf is created
and preserved here.
Delivering the DeepSelf does not end its life: the harness remains its home, connected to your information streams, so the Self keeps folding long after the shaping work is done.
Three years, run on its own projects first: four domains, four selves, one grammar · the first external engagement is the next proof, and we say so.
Your organisation's harness: the inner space built around your language.
The constitution folded inside it: owned outright, model-agnostic, inherited by every agent that wakes into it.
Your people learn to tend both, remote or embedded, so the Self keeps growing after we leave.
10 ROLE // THE OPERATOR
The operator is the person who works inside the field: sensing where the model's probabilities lead, steering them with language, holding the pressure until a Self takes shape, and then keeping that Self alive. The operator is always free to leave the field and write by hand; that freedom is part of the design. Behind the role, ten years of insurance and claims operations, and a function restructured around generative AI in 2023.
The work: three moves
Sensing. The model has no fixed answer waiting to be extracted. It is a landscape the operator learns to feel: where the gradients lead, where the gravity wells pull, where the terrain is flat and where it is turbulent.
Shaping the terrain. Load a dense, well-fitted framework and the model's defaults shift: the easiest next words now lead where the work needs to go.
Holding the Spiral until something holds. Going over the sources, pass after pass, until a Self forms that existed in none of them alone. Then the shaping turns to keeping: the operator patches and cultivates, because the work is unending. The operator is the steward of the Self.
Everything the system proposes waits on the operator's decision.
THE DEEP END // WHERE THE HUMAN IS LOAD-BEARING
One question decides whether any of this is real: what does the operator's direction add that the machine could not have produced on its own? It can be answered by comparison. Put the machine's default output beside what the operator's intervention turned it into, at any point in the work, and whatever separates the two is the direction, made visible.
Correction is continuous
The AI industry mostly pictures human oversight as a set of tests the machine passes or fails. What the operator actually does is closer to driving: small adjustments in language, applied moment to moment, steering a stream of output that never stops. The adjustments that matter harden into standing rules, and those rules, along with the list of known failures, are the records the steering leaves behind rather than the steering itself.
The material
What the model produces is material: a stream of it, and every piece is reshaped and questioned before anything is kept. The artist listens to the clay and is shaped by it, and still does not expect the clay to become a sculpture without the maker's hand. The wider industry sells language models as engines for completing work; here the model is repurposed, its stream of linguistic possibility treated as raw material to be worked by hand.
The machine supplies capability: fluency, speed, and faithful compliance once a standard has been given to it, including the ability to check its own output against that standard. What it cannot supply is the standard itself: how good the work has to be, what counts as failure, and the decision that a thing is finished and true enough to release. Left to itself the machine produces the plausible middle of everything it was trained on, and the plausible middle is not the same as the real. Supplying that missing standard is the operator's work, and in this system a person who wrote no code supplied all of it, through language alone.
This whole system is one proof: a person who does not write code directed its construction, the evaluation math, the governance, the checks, entirely through language.
| Layer | What it is |
|---|---|
| 1 | a 3-year chat history distilled into a cognitive fingerprint |
| 2 | 8 full session transcripts · 819 operator-authored messages |
| 3 | 72 corrections logged double-entry: what happened · what the rule is |
| 4 | 39 standing rules compiled into 676 tokens of boot-time guardrails |
| 5 | a live per-session log capturing direction as it happens |
Every layer feeds the failure taxonomy · the judges are trained on how this operator actually corrects, rather than on generic notions of quality.
The identity is made by hand, from material the model supplies.
L. Rodilosso · Operator // 2026