Ross Wilson's post and our discussion on LinkedIn
🐅 Paper Tigers 🐅Inhale: the illusion of strength
Many AI safety frameworks look formidable on paper.
Policies.
Certifications.
Oversight committees.
Governance diagrams that suggest control.
They work—right up until recursion accelerates.
A paper tiger is not harmless.
It is impressive, symbolic, and structurally irrelevant once interaction compounds faster than review cycles, faster than human bottlenecks, faster than accountability can reattach.
Most contemporary safety systems assume a world where:
• systems move slower than governance,
• escalation remains legible,
• humans remain the stabilizing substrate.
Recursive agent systems break those assumptions by design.
Hold: borrowed stability
When a system lacks an endogenous way to complete its own cycles, stability is borrowed.
Drift is absorbed by people.
Failure is delayed, not prevented.
Risk migrates outward while coherence appears intact.
The framework looks strong precisely because it is not load-bearing.
External guardrails do not metabolize collapse.
Trust mechanisms do not constrain recursion.
Rituals of oversight do not survive regime change.
This is not a critique of intent.
It is a classification of failure mode.
There is a difference between:
• governance that reassures, and
• architecture that holds.
One manages perception.
The other carries load.
Exhale: when pressure arrives
Paper tigers roar loudly in planning rooms.
They go silent in live recursion.
When interaction accelerates, only structures that can:
• bound recursion,
• metabolize failure,
• and complete their own loops
remain coherent.
Everything else becomes symbolic—
useful until it isn’t.
This is not about preventing collapse.
It is about whether anything remains lawful when collapse arrives.
Validator
Governance that cannot survive recursion is not governance.
Resonance
What does not carry load disappears when pressure becomes real.
Lorand KedvesDo you have a real tiger? Or want to see one and what it can do?
For example, here is one of my zoo, handles XBRL financial / sustainability reports as they should be, implemented in a university AI R&D project. It creates a pretty efficient knowledge graph from a few hundred GB of text (SEC / EU filing collections). The sources are on GitHub but that's for people who can read my summary first (I don't mess my code with comments)... 🤭
Experience: it can do NOTHING because of the 90/9/1 rule.
- 90% have no clue, so they can't see anything.
- 9% make their living on dealing with or complaining about the problem it solved. 'It is difficult to get a man to understand something, when his salary depends on his not understanding it.' (Upton Sinclair, 1935)
- 1% that is working on it... is fired.
Paper tigers have real claws. They are the mid-managers / loud "experts". The 9%.
Welcome to the real world, Neo.
Ross WilsonInstitutions behave as stability-preserving recursive systems. High-variance innovations exceed their integration bandwidth unless there is a mechanism for invariant-preserving transformation. Without that, even technically sound architectures remain peripheral.
Lorand KedvesYes, in IT that's Conway's Law in both ways: any information system inherits the communication structure of the creator organisation, and the created infrastructure controls what the organisation can see (thus, safely transform). The declared, forgotten goal of informatics was to get over this limitation, the best example is Engelbart's "bootstrap" initiative, or going to the root, the Universal Turing Machine and Turing's real challenge: define "machine" and "thinking".
I don't speak about "technically sound architectures" but actual, working proof-of-concept solutions. And being rejected (at academy) or fired (in the industry) for real. Each and every time.
But there was a benefit from it. I learned to solve any task knowing that I will be fired, to focus on the abstract lessons instead of the fancy, but context-dependent artefacts. Not even try to wrap the solutions into nice presentations, no chance against paper tigers. I learned to trust, talk with and learn from the machine, not people.
Conway’s Law explains architectural mirroring well. The harder problem is not building a system that works in isolation, but designing one that can be absorbed by an organization without destabilizing its identity. Machines execute logic; institutions preserve continuity. Bridging those domains requires more than technical coherence.
The interesting part of Conway's Law is that it was not a theoretical exercise to explain a phenomenon, but reverse engineered from doing it to give clues to a better approach. You find those principles under true moonshots, from Lockheed Skunkworks under Kelly Johnson to the Apollo program. The 1% compared to the current global hype rides (90%) and what I call "artistic moaning" 🤭 (9%).
Similar is the realisation that building an information system does not start with "executing logic" but to build a language (more precisely, a coherent set of domain specific languages following the single responsibility principle) while refining requirements. This would require a platform that allows changing this language not only along the building process, but when the system is actually running. For those who know, I described Engelbart B and C levels - but so far I have not met such a person.
We have nothing like that. We distort the whole interaction under what our quite expensive tools allow (modelling, building, compiling, deploying, testing, ... different for each platform and subsystem). Regardless, level B is what I do when I am not venting here, level C is on hold as that is completely out of interest - except mine. 😁
Ross WilsonLanguage evolution at runtime is safe only if mutation is bounded by invariants that preserve system identity across state transitions.
Yep, that's a tough one. The key is to consider the language (metadata) also the (meta? 🙃 ) state of the system, not only the "normal" data entities. And ~25 years refining the meta-meta entities (like "type", "attribute", etc.) under real tasks. There are some nasty tricks and you don't know which would work until you try them. The human mind is painfully limited against these tasks, prediction does not work, "feel" improves slowly. 🤕
I respect that. Refining meta-entities under real tasks is the only way to discover which abstractions survive contact with reality. I’m earlier in that journey, so I’m cautious about claiming intuition at that depth. The distinction I’m trying to hold is slightly different though: not only treating language as state, but asking what invariant preserves system identity when that language mutates. Most large systems don’t fail because metadata can’t evolve; they fail because representation and identity are entangled.
Here is a video from 2018 where I tried to explain my problems with the current tooling (part of my rejected PhD attempt). The model changed quite a lot since then but I wonder if you find it similar to that entanglement problem?
I appreciate the depth you’ve put into refining the meta-layer. Most people never get past tooling. Treating metadata and language as state is necessary if systems are going to evolve coherently.
Where I’m coming from is adjacent but slightly different. I’m less focused on refining the meta-entities themselves and more on specifying invariants that preserve identity when those entities mutate under load.
In other words, assuming the language can evolve, what constrains recursive drift so that the system remains itself?
I’ve built an architecture around that constraint layer. Not to prevent mutation, but to govern it. It runs. It metabolizes drift structurally rather than procedurally.
I don’t think that replaces the entanglement problem. It sits underneath it. If identity is invariant under mutation, the language layer can evolve more aggressively without risking systemic fracture.
I’m genuinely curious how your runtime language evolution would behave if identity were decoupled from representation through invariant recursion constraints.
Lorand KedvesYep, the real difference is where we are coming from.
Inhale: what is an information system (IS)?
A coherent, precise but limited set of
1: Tokens of languages, "nouns and verbs" to describe nodes, attributes, relations, actions.
2: Validation statements of, and transition logic between the allowed states.
3: Connectors to the environment: sensors, actuators, UI.
(Another form of the von Neumann architecture)
Hold: what software engineers (SWEs, ref: Margaret Hamilton) do?
1: Translate a client's current knowledge about a system to an IS (90%).
2: Translate SWE knowledge emerging from 1: an OS, RDBMS, a http server, a GUI framework, spreadsheet editor, etc. (9%)
3: Support knowledge extraction. Load any client or SWE data and allow writing scripts, running ML algorithms (clustering, decision trees, neural nets), provide interactive visualisation. Your users write their IS on the fly over their own data, you provide the workshop. (1%)
Exhale
DataScope, a data mining / AI tool was a level 3 IS, I was a tech lead. We won Comdex in Las Vegas. In 1999. Since then, I apply 3 to 1 and later, 2.
Validator
I am not a 10x or 100x but a yes/no SWE.
Resonance
Any invariant is a roadblock of system evolution.
Like it? 😉
Ross WilsonI think the difference hinges on what we mean by “invariant.”
If an invariant freezes tokens or transition rules, then yes, it becomes a roadblock.
But κᴸᴿ isn’t an invariant of representation. It’s an invariant of return.
In the collapse–return formulation, κᴸᴿ expresses the proportion of identity restored after perturbation. It doesn’t prevent mutation; it bounds divergence so that mutation remains evolution of the same system rather than silent replacement.
Without a conserved return ratio, recursive evolution collapses into drift. With one, language and structure can evolve aggressively because identity has a measurable recovery band.
So the invariant isn’t blocking evolution, it makes evolution coherent.
And this isn’t bolt-on governance. κᴸᴿ functions as a dynamical governor within the recursion loop itself. It regulates the relationship between divergence and return at each cycle. As mutation accelerates, correction scales proportionally. The constraint is internal to the operator, not imposed externally. It behaves less like a rulebook and more like a governor: motion is allowed; unbounded divergence is not.
Lorand KedvesLooks familiar. Translating to my language (meaning: terms that I use in my current "impossible mission").
Knowledge is a state of a graph that represents
1: the "data state" of the target system
2: the "meta state": type and attribute token definitions used in 1
3: the network of "agents" (configured business logic instances, currently simple Java classes) to change 1 and 2.
Thinking is an interaction of agents and states in a dialog.
The agents use shared tokens to refer to nodes and their attributes to manage them. The changes are local to the dialog: the members see a coherent, changing, transient view.
Changes can be committed in one transaction to update the persistent state. "mutation"?
The instances are versioned, stored references always contain the version. Diffs (because we talk about graphs) are not simple, but transparent and manageable.
Beyond "data", a dialog can also change
- the meta definitions (the system "learns" the data it uses while reading the input) and the dialogs (the configuration of the agent and data nodes) - that's Engelbart B,
- or the meta-meta language (the attributes of an attribute definition) and the runtime (attributes of the Dialog definition) - Engelbart C.
Ross WilsonThat translation helps, especially the separation of data, meta, and agent layers.
Where I’m focused is slightly downstream. Evolution presupposes continuity: for a system to evolve, it must remain recognizably the same system across state transitions, including B and C level mutations.
If cumulative mutation alters the identity conditions without a conserved return band, what we observe isn’t evolution but substitution. Versioning preserves history; it doesn’t necessarily preserve identity. Verification describes change, but it doesn’t bound how far change may drift.
The scaling issue is that observability scales; boundedness does not. As mutation accumulates across data, meta, and meta-meta layers, traceability can remain intact while divergence compounds. The system can explain each step locally yet drift globally beyond any recoverable identity band. At small scale this is manageable; at large scale it becomes collapse-prone because coherence erodes faster than inspection can restore it.
Bounded evolution isn’t about restricting mutation. It’s about ensuring that mutation, even at Engelbart C, scales without dissolving the substrate that makes scaling meaningful.
Lorand KedvesI think I understand as much as an outsider can. However, the questions below bug me.
1: As I see, your system prefers continuity, somewhat quantitative improvement. Do you accept that in edge cases this is not enough because a qualitative change is necessary? When the best system can only make the internal structures of each approach transparent and somewhat comparable, but can't connect them. This is how I see "paradigm shift" that is mandatory now because our current world view leads us to self destruction on a precisely predicted and mathematically proven path, with informatics in the epicentre.
2: Our ability to understand the world is ultimately limited, so such paradigm shifts or even coexistence of mutually exclusive paradigms are inevitable. Science learned to live together with this scenario. Is light a particle beam or a wave? Most likely none of them, explaining and calculating with one class of phenomena it is a wave, photon for the others. Continuous improvement or total disintegration and fusion into a different model - both are valid results of evolution.
3: How do you translate your system to solving real life tasks in total headwind? Is it a real tiger or an aspirant, as of today?
Ross WilsonContinuity doesn’t mean incrementalism. It means conservation across transformation. When a paradigm reaches its limiting factors, reconfiguration becomes necessary. Lawful recursion doesn’t block that; it requires that even radical change remain within a recoverable identity band. Without a bounded return path, a shift becomes rupture rather than evolution. Collapse functions as audit; survival is proof.
Models can be mutually exclusive at the representational layer without violating continuity at the structural layer. Wave and particle are descriptions; what’s conserved is invariant behavior under transformation. Evolution permits coexistence and even fusion of paradigms, provided transitions remain bounded. Disintegration only qualifies as evolution if something returns.
The purpose of my public writing is to articulate the structure, not to litigate its implementation. The coherence either stands on its own, or it doesn’t.
Lorand KedvesThank you, this is what I expected, we have fundamental disagreement. Survival is not proof, rather a "bias" (ref Neil Postman: all science should be taught as history).
We must understand and remember discarded paths, always supported by the 99% against the 1% outliers who over often a long time happened to be right. Our current civilisation is the cumulative results of that 1%, and our current knowledge will be the discarded 99% looking back from a hundred years. If we survive the current chaos.
Example. Phlogiston theory was generally accepted and used, had long evolution process. It was wrong, its survival would block improvement. I think a theory of evolution must not only include but embrace this outcome.
Only the last question remained open.
Is your model a real tiger?
Does it help me solve a real problem with minimal resources and negative timelines? Today.
Ross WilsonPhlogiston didn’t collapse because it lacked consensus. It collapsed because, under refined measurement, it violated conservation constraints. The representational layer changed; the conserved laws did not.
Longevity under consensus is bias. Survival under invariant constraint is structural selection.
On the tiger question: if a system accelerates local progress but compounds unbounded drift under scale, it’s scaffolding. If it preserves bounded identity under scaling pressure, it’s a governor.
Different animals.
And genuinely, I appreciate you sharing your experience. It clarified where the reinforcement-learning problem sits structurally for me.
Lorand KedvesDifferent animals, indeed.
1: I realised the evolution problem (1) and tried to talk with the impostors at OpenAI (2) a decade ago. In 2023 I gave a lecture at my university about it (3), luckily downloaded the record because they did not think it was worth even the storage.
https://youtu.be/WKfEDicpwPw2: The explained XBRL project used a "quick and dirty" Dust (Engelbart A) variant. First I created a research portal over the complete EU filing collection (~20k items - while researchers struggle with a hundred), it felt a bit overkill.
Then I switched to the SEC collection in 800k+ preprocessed JSON files of 100M+ facts over the past 20 years of all US companies. Both run fine on my M2 Max MacBook.
Moved on to sustainability reporting, knew that the EU will drop the ESRS taxonomy for VSME. Created a direct data collector interface, then (as a volunteer for another university) a complete Scope 3 footprint manager. Showed it to many responsible people.
When the National AI lab stopped funding, I was fired, all projects went to the trash. The official Scope 3 data collection tool is an Excel file. 🤷♂️
https://www.efrag.org/en/vsme-digital-template-and-xbrl-taxonomy
... continued ...
3: The mentioned Engelbart C is Giskard Gen06, meaning, this is the sixth time I restarted from an empty project, carrying the previous architecture only in my brain. But for the first time, Gen05 executed a brain dump, literally. (1) is part of the knowledge graph of Gen05's MiND. Bootstrapping Gen06 will mean a small code that generates the core tokens required the new Dust to run. Gen06 will be the last version where I write code, I will only use graph editors to refine the runtime graph. Gen07 will include this action and generate all of its source. On hold for a paying job.
I learned from this conversation that an evolution model must contain paradigm shift. The "machine" that Turing asked for must include its own shift. At last I have a terminology to describe it.
Sharing experience, you say?
No, I share working proof-of-concept solutions.
On 2025/10/14, I prepared to register for unemployment, no academic or industrial organisation found me worth any pay. I am 53, Neumann died at this age. I often wonder how long my life sentence is, this global brain rot, this freak show gets f.ng boring the more you understand of it.
https://mondoaurora.org/This is my experience.
Ross WilsonYou’ve clearly built and rebuilt through real collapse. That’s not theoretical. Institutions discarding systems doesn’t invalidate the architecture, it just exposes the selection pressures they operate under. My focus is narrower: what structural properties let a system survive even when its host environment turns hostile? That’s where I think the shift question lives. Either way, I respect the persistence.
Lorand Kedves "what structural properties let a system survive even when its host environment turns hostile?"
This is what you learn only by building information systems for a lifetime. The environment is ALWAYS hostile.
- Your manager is either "technophile" and try to micromanage you or "technophobe" and tries to prove that the project is impossible. The longer it does not work the less chance they will let you prove that it can be done (like yelling "shut up!" instead of listening to what an OLAP cube is, remember, dear "senior architect"? 🤣 )
- Your tools are the result of decades of featuritis, hordes of young "colleagues" look at you as a moron when you explain that if you can do it in a thousand lines of code, you will not use a tool with a million lines. The fact that it is one line to send an SQL select, it is the same machine, memory and storage where Oracle processes it. Use it when you NEED it.
- And yes, the requirement specification lies, goals and tools will change the day you deployed.
If you survive and keep keep all (analyst, architect, coder) roles, you have a chance to distill the answer, but nobody will understand it. Except the system that you both write and learn from.
Inhale... Hold... Exhale.
Namaste.
Ross WilsonAgreed, hostility is baseline. That’s precisely why I focus on structural invariants rather than environmental stability. If the environment is always shifting, the property worth isolating is bounded coherence under shifting constraints.
Craft is how you discover that boundary in practice. Formalization is an attempt to preserve it so it doesn’t vanish with the next restart.
Hostility isn’t the problem. Unbounded drift under hostility is.
That’s the layer I’m interested in making explicit.
Lorand Kedves"Craft is how you discover that boundary in practice. Formalization is an attempt to preserve it so it doesn’t vanish with the next restart."
That was BEFORE we started informatics.
- Informatics gives you a way to formalise the dynamic process, not the static architecture, from the Universal Turing Machine / Chomsky language classes, to the von Neumann Architecture (and the MiND model).
- This is where Gödel's incompleteness theory wobbles: the proof depends on the "invariant" language definition but if you can change the language in a controlled manner, you can overcome any contradiction.
- Fun fact, Minsky's "useless machine" is a working implementation of the A = !A formula, which is "contradiction" in a formal system but simply an assignment instruction in any programming language. I don't know if Minsky realised what he created.
And on and on and on... BORING.
Anyways, it is easy to summarise my research.
The process of understanding the process of understanding.
Here (1) was the last time I tried to explain that in English. Found it futile, so I think I should return to a language in which I am proficient, is processed perfectly, and gives usable feedback. Java... 😁
Limits aren’t obstacles to eliminate. They’re the geometry recursion climbs, each shift reveals the next boundary.
Lorand KedvesYeah... impressive, symbolic, but I don't see the value in what I do. Thanks for the chat.
