Last week, I wrote that no AI model ever can attain consciousness because it doesn’t have a sense of its surroundings and its delimitations. In the physical world, one may call this a body.

This hypothesis brings us closer to agentic AI, because agents interact with tools that are not them, but part of the outer world. Agents thus need some elementary sense of what’s “them” and what’s “outside.” Therefore, agents could be a step closer to conscious AI — one step closer than simple LLMs.

One of our readers, , pointed this out to me: neuroscientists have posited since 2006 that much more than just a body is needed for consciousness. In particular, there’s a short paper by Jeff Krichmar, which presents notes he took in 2006 when Nobel-prize-winning neuroscientist Gerald Edelman outlined a route towards what he called a “conscious artifact.” These notes remained pinned in Krichmar’s office for years and were finally turned into a short paper after a listener contacted him about a podcast.

It’s worth pointing out that this is not a rigorous research paper. It’s a presentation of lecture notes, and certainly not in itself an established framework. Nevertheless, it’s an intellectually attractive artifact to look at — as a reconstruction of a neuroscientist’s thinking about what constitutes consciousness and how the state of AI these days connects to it or not.

The Ten Commandments of Consciousness

According to Krichmar’s take on Edelman, ten ingredients are needed to build conscious machines, or “conscious artifacts” in their language. At a glance, these are:

1. Reentrant Architecture

2. Thalamo-Cortical System

3. Value Systems

4. Phenotype

5. Motor Control

6. Generalization in Learning and Memory

7. Communication

8. Thought

9. Language

10. Kindergarten

A. Computer Power

B. Minimum Neurons Necessary

Note: Any Sensor will Do But Need Haptics

What’s most interesting is that we’ve built the list from the bottom up so far. So I’ll discuss it from the bottom up, comparing it to where AI stands today.

Item B, artificial neurons, were first built towards the middle of the last century. Item A, computer power, has exploded in the past decade, which made LLMs possible.

Point 10, “Kindergarten” is some elemental training. Ask any AI engineer or machine learning (ML) specialist and they’ll tell you that training the model is the fun part of the job. Before LLMs, ML training was a big deal (I’ve trained many ML models myself). It’s been around for decades.

Language-capable models have been a thing before ChatGPT came around in late 2022, notably using natural language processing (NLP). However, chatbots have of course exploded this category in recent years. Note that this is number nine on the list!

We’re still grappling with how to make models think (or reason) properly. As for AI-to-human communication, we’ve made strides but it’s still an area of active research.

Generalization plays into the ideas of Artificial General Intelligence (AGI) floating around everywhere — tech bros acting worried that AGI will run the world and enslave humans, or some variety of such a dystopian calamity. Positively put, generalization is simply learning one thing through another, for example, an athlete being a decent hockey player with very little game experience, simply because they’re already excellent at soccer. We’re not that good, yet, at making AI models of any sort generalize in enormous ways, which is why AGI is for the moment not our central body of governance.

Motor control is tricky — robotics is making strides but remains a far cry from where we imagine it to be. A recent “breakthrough” was a robot capable of folding towels. I don’t know about you, but I can imagine robots doing slightly more complex tasks than towel-folding and floor-Roombaing. We still have lengths to cover on this point five of the list.

Phenotype, item four, is where it gets interesting. This typically refers to the physical design of a robot. Some robots look like sliding disks (like Roomba’s) and others resemble dogs or humans. As I argued in last week’s edition, it could also cover whatever an AI agent interacts with — tools, databases, servers, human users, and the likes. We’re still designing proper software environments for AI to live in. As for the hardware, there’s no obvious convergence to a proper standard — disks, dogs, humanoids, you name it, it’s all out there.

Value systems are not necessarily ethical guidelines — though pertinent and an active area of research. Value systems are what motivate a robot, such as salience or value of an environmental cue. For example, I’m mostly incentivized right now by the thought of having chocolate cake after writing this article. A chatbot might be incentivized by pleasing its human user to the maximum (which sometimes results in rather sycophantic AI, where the chatbot tells you that all your ideas are deep and original when they’re clearly not). Again, an active area of research.

Item two on this list is clearly from a neuroscientist: some kind of back-and-forth between a thalamus and a cortex. The thalamus regulates sensory throughput (like when you can’t hear your wife properly but your mother well — your thalamus is to blame), sleep-wake cycles and awareness, and memory. The cortex processes raw sensory data that the thalamus sent over, and it handles decision-making, speech, and voluntary movement. It’s the dance between thalamus and cortex that makes us able to act in everyday life, and Edelman posits that something like these two brain regions needs to be built to have artificial consciousness. I have yet to read about AI being built at scale following specific human brain areas and their interactions.

Finally, the reentrant architecture (first point on Edelman’s list) refers to dense, bi-directional neural circuits. Most neural networks only propagate in one direction. There may be some limited backpropagation also, but it’s nowhere close to a proper reentrant architecture. To quote Krichman’s paper, these global mappings of bi-directionally linked neurons give “rise to perceptual categories and action plans.”

A Body is Not Enough

My article from last week focused narrowly on point 4, phenotypes (as in, environments and bodies). Neuroscientists add to this some motivational reward (value systems, point 3), and some brain structures (points 1 and 2). At minimum — because most of the other points on this list are not complete yet either.

We of course don’t know if this ten-point list really is enough to built artificial consciousness. But it’s worth considering that, according to what a Nobel-prize winning neuroscientist said twenty years ago, we’re nowhere close yet.

Meanwhile, at Wangari

I’ll be off for the next few weeks! There are new things cooking, but I’ll keep those announcements for after my holiday break. You can expect to hear back from me on November 3, then again on the regular cadence.

Reads of the Week

• Stop Building AI That Forgets — a very good, practical piece on the difference between an AI system that simply executes and one that compounds. and ’s diagnosis is close to the question in this week’s article: conversation logs are not memory; a model should not be its own state manager; and a useful system needs to act when the state of the world calls for it, not only when someone opens a chat window. For anyone building agents, this is the infrastructure version of “kindergarten.”

• The Complete Map of AI Scheduled Tasks — makes the currently messy terrain of scheduled AI work legible: the border between a model and an automation platform, and where the proof of work has to live. This matters because an agent is not defined by the number of tools it can call. It is defined by whether it can take a bounded action, at an appropriate moment, with a record of what it did and whether it worked.

• Protecting ourselves from 2 key risks of AI tool dependency — has written a clear and humane piece about a question we tend to miss while admiring new AI capabilities: what cognitive muscles do we stop using when the tool becomes indispensable, and what happens when the tool is suddenly unavailable? Her answer is not to avoid AI. It is to use it deliberately, keep our own judgement engaged, and remember that dependence on a changing commercial service is also a business risk.

I’ll start with a sentence that I say often, falsely. I often say something like, “the model returned the result XYZ.” But that’s not true.

A model doesn’t wake up, inspect company data, decide which systems it can access, call an API, check whether numbers are anomalous, remember yesterday’s exception, or ask a human for approval. The agentic system does those things, or is configured to do them through a full-blown architecture around the model.

So actually the model didn’t return much. It’s the whole system that did something that enabled the model to spit out a final result.

The model isn’t the whole agent. It’s just one component in a loop.

When we say that an AI agent acted, we usually mean a great deal more than “a model generated a sentence.” (Although that’s of course a key piece of it.) We mean that it had a view of a changing world, some memory of what had happened before, tools it could use, limits it could not cross, and a way of verifying its results. In other words, it had something closer to an environment.

To put this, carefully, into a human analogy: Did I write my PhD thesis, or was it rather an automatic result of my natural tendencies inside an environment containing a university, research lab, and PhD supervisor? Did “I” really do the writing or was it rather my hands (this was pre-LLM-era), as directed by my mind, aka “the model”?

Humans of course are not disembodied language models, so this is deliberately said carefully. Conscious life – whatever that is – happens in a living system that is continuous with a physical body, a mind, and a surrounding world. Physical bodies in one way inform about the border between the world and our surroundings, and also indicate the contents of our mind (by reacting to our thoughts and emotions in physically apparent ways).

At a minimum, human minds appear inseparable from an organism that senses, acts, persists, regulates itself, carries a history, and is continually changed by the consequences of its actions, both physically and mentally.

So: if we assume that human consciousness happens in a biological body (I have yet to meet a conscious disembodied ghost, which we’d arguably not call quite human anyway), then what would count as a “body” for an AI agent?

And if an agent ever became more than an extremely capable tool, and something with consciousness, would that transition happen inside a neural network or rather in the ongoing relationship between the model, memory, sensors, tools, constraints, and the world?

I find this an extremely intriguing question because in deepening my meditative practice, I start to see that enhanced consciousness comes from withdrawing from identification with the senses, the body, and the contents of the mind. Not to say “not feeling, not thinking” — quite the opposite — but neutrally observing physical sensations, emotions, and thoughts, without getting caught up in them.

But at the same time, my research around AI pulls me in the other direction: AI seems to need some form of embodiment. In software, that embodiment is akin to its environment and its architecture (not some kind of physical robot body). My suspicion — spoiler alert — is not that agentic architecture is a route to machine consciousness per se. It is that agentic architecture may be the only place where that question could become meaningful, and that’s worth unpacking in a deeper way.

Ingressing Minds

Now this musing doesn’t come from my own work. Michael Levin recently published a paper called Ingressing Minds, and he makes an argument that will sound either exciting or intolerable, depending on your stance on metaphysics.

But first, credits where credits are due: I didn’t come across that paper by myself, but by means of ’s brilliant Import AI newsletter.

Back to the subject: Levin argues that the patterns responsible for form, function, and agency may not be fully explained in physical material or algorithms alone. Levin proposes a framework in which bodies – living, engineered and hybrid – act as interfaces through which a hierarchy of patterns can become effective in the physical world. He places agency on a spectrum from simple fixed patterns and goal states to behaviors recognizable as minds.

In other words, I might just be some kind of evolutionary supercomputer whose fingers type on this keyboard in a predefined sequence. Which may be true, but I’d contest that (a) I have a subjective experience of consciousness and (b) the pattern of my finger movements on this keyboard is complex enough to outmode an AI.

Levin’s thesis is not conventional neuroscience or the result of a result that anybody should treat as established. It’s a proposal about ontology, a suggestion about what kind of things might be real and causally relevant.

But the engineering question hidden inside this is much more tractable: What’s the relationship between an architecture and the kind of agency that becomes possible within it?

Levin argues that machines and organisms should be considered along a spectrum and not treated as categorically separate just because one is built and the other evolved over millions of years. So he explicitly includes robotics, software AIs, and language models in a call for humility about engineered constructs.

His reason is not that they obviously have minds or something. It’s that builders can these days create systems whose organized capacities exceed what they even understand. In other words, we know that superintelligence is already happening and all around us. So we should be humble about our place as Intelligence on Earth.

Levin’s claim is much stronger than the one that I need to make. I don’t need to believe in platonic forms, for example, which is a key component he draws from, or ingressing minds, or robot souls. I just need to accept the narrower warning, which is that building a system doesn’t guarantee that we understand the level at which its behavior is organized.

A model is not an agent

Now here’s where consciousness conversations about AI often become unhelpful. They focus on benchmarks, outputs, chain of thought looking text, or whether a model says the words, I feel. They imagine that a model is some kind of isolated object, like a brain in a jar that happens to speak.

But first of all, humans aren’t brains in jars for the most part. And to put this into an enterprise context, an enterprise agent is also not just a text generator standing alone, it’s a control system embedded in an organization. The language model is often the part that speaks. It’s not necessarily the part that has a stable relationship to the world.

My mind doesn’t know the world all that well. It’s my hands that really know the keyboard expertly well, and my eyes that know the screen. A model can produce a beautiful account of an objective without possessing an actual objective. It can describe a world without being answerable to one.

Now here’s how an enterprise agent becomes a continuing system, not necessarily conscious, but continuing:

• Perception: access to data feeds, documents, events, and signals from the organisation.

• A maintained world model: an explicit representation of entities, relationships, current state, uncertainty, and context—not merely a transient prompt.

• Memory: the ability to retain history, commitments, exceptions, and lessons across time.

• Tools and effectors: systems it can query, actions it can propose, workflows it can initiate, and changes it can make.

• Goals and evaluation: a measurable or at least inspectable account of what success, failure, risk, and escalation look like.

• Feedback: evidence about whether the action had the intended effect, including correction by people and by the environment.

• Boundaries: permissions, policy constraints, logging, approvals, and conditions under which the system must stop or hand work back to a person.

• Persistence: an identity that survives one chat window and one task, with a history that is not reset by every interaction.

None of these items is consciousness, but together they produce something that’s much more like an organization’s, an organism’s ongoing relationship to a world than a prompt response interface has. We shouldn’t call that consciousness, of course, but we should stop pretending that the consciousness question is exhausted by inspecting a model’s output, at the very least.

Now, permissions layer is of course not a nervous system like those that humans have. An API is not a hand, a database is not a memory in the human sense either. Analogies become dangerous when they become camouflaged for a conclusion.

The point I’m making is architectural and not biological: An agent becomes consequential through the closed loop between an observation, an internal state, an action, and feedback. And that loop is what makes the question so interesting.

How this ties to causal structure

Now comes the part where the conversation stops being metaphysical decoration and becomes an infrastructure problem. An agent operating in an organization shouldn’t just produce plausible language. It should be able to represent the relevant system, distinguish observation from intervention, track uncertainty, and expose why it recommends a specific action.

If an agent is going to act in the world, it needs more than a vocabulary for the world. It needs a model of consequences. Now, a quick distinction here. Causal structure isn’t consciousness. A causal model is no proof that anything is experiencing the system’s actions, but causal structure does matter for agency.

Because it lets the system orient action around plausible interventions and measurable consequences rather than superficial patterns in historical data. Correlation lets the system notice that two things move together. Cause or structure is what lets it ask, if we change this, what follows automatically? And how would we know?

That’s not a consciousness test, it’s a responsibility test. But the question that a regulated organization has to answer is also not, does the agent feel? It’s what did it believe? Why did it act? What could it affect? And who can reconstruct the answer?

And so that’s where these thoughts do get become very valuable. For a software agent, infrastructure is not a deployment detail, it’s the condition of its agency, its data environment. Determines what it can perceive. Its semantic and causal model determines what it can make sense of.

Its tools and permissions determine what it can affect. Its feedback loops determine whether it learns or just repeats like a pirate. If there is a meaningful analog of a body here, it’s not in a humanoid shell, it’s in this. Surrounding architecture, the interface through which a system encounters a world and makes a difference to it.

As an aside, this is partly why I find the current fixation on the model itself so odd. In production, the model is often the least durable part of the system. The architecture is where the commitments live.

Maybe metaphysics isn’t the right argument for embodiment?

Now, there’s a couple of objections to this whole argument, and I wouldn’t want to spare those from you. The first one is that functionality is not the same as experience. A system can have perception-like inputs, memory-like storage, goal-directed behavior and feedback loops without having any inner life whatsoever. For example, a thermostat is not a person. Scaling up the architecture doesn’t by itself resolve the hard problem of experience.

However, this may evidence that our old categories — model versus tool, software versus agent, intelligence versus just automation — are a bit too blunt for the systems that we are now building. Perhaps some finer distinctions are at the ordre du jour.

The second objection is that we shouldn’t be anthropomorphizing systems that can’t be held accountable. Of course, calling agents conscious too early could make people overtrust them, excuse organizational failures or blunt human accountability. An organization can’t outsource responsibility to a system simply because it behaves with an Nerving coherence, traceability, bounded permissions, explicit uncertainty, and the ability to challenge an output aren’t obstacles to a system’s agency. They’re the conditions under which agency is legitimate in an enterprise setting.

And that does translate to human behavior. So that’s where this kind of thinking again becomes useful.

The third objection is that Levin’s papers, Metaphysics and Enterprise, need evidence. Levin’s framework may ultimately be wrong. The claims about non-physical patterns may be untestable or at least not earn their keep against more conventional explanations. This is possible, but the value of the paper goes beyond that. It’s not methodological as such. It tells engineers to be humble about novel systems, to test what they’ve made, and not to mistake a construction for a complete explanation.

This becomes more and not less important when agents are trusted with consequential work.

Placing responsibility before consciousness

So, is agentic architecture the way to AI consciousness? I don’t know. I don’t think anybody else knows either.

But if machine consciousness is ever more than a philosophical parlor game, it’s unlikely to arise from a disembodied text model viewed in isolation. It would have to involve something enduring, some structured relationship between a system, a world, its actions and the consequences of those actions. This relationship is exactly what we’re now building when we connect models to enterprise data, tools, memories and decision workflows.

We don’t need to call those systems conscious to take their architecture seriously. We do need to make them legible, bounded, contestable and accountable before they’re entrusted with more of the world. So off camera, you may want to entertain your thinking about conscious systems while, you know, phrasing it more responsibly when you actually go and do the work.

The question isn’t whether agents will become human. Probably not. Probably they’ll become superhuman or something entirely different. The real question is whether we’ll build them with enough understanding to remain responsible for whatever they do become. Consciousness may be the distant question here. The immediate one is architecture.

Either way: before we ask whether an agent has a mind, we should make sure that it has a world model that we can inspect, and guardrails of how it may interact with its surroundings.

Meanwhile, at Wangari

Next week is the last edition before another two-week break. Not for meditation, this time (though that’s part of my daily life anyway) — I’m traveling in Europe to see some family, and would like to focus my mind on strictly human matters during this time.

Reads of the Week

• If you’re still asking “WTF are AI Agents?” — you’re not alone. to the rescue! In a very practical way, he relays what makes AI agents so special — “building an agent is like building a human.” And how to get started, which, for most people, is Claude Cowork, Copilot, or Codex/ChatGPT.

• AI Consciousness and the Embodiment Problem — a very clear and opinionated book review by . Somehow, consciousness and embodiment do go together, but to claim that you need a body to be conscious or to blindly assume that academic research says AI is not conscious so it’s not — that is a bit quick. Gellers picks this apart in a very clarifying way.

• Under what conditions would a machine be conscious, and could that be tested? That’s the question asks in publishing a 26-page essay which is worth a Sunday afternoon (the essay is linked rather than the body of the Substack piece). With my own background in Indian meditative practices, it’s quite interesting to see their distinction between Western views and views of other cultures on AI, which, in many ways, seem much more advanced.

Imagine the following scenario. An AI agent is helping to prepare a regulatory report. It notices that a number moved enough to make a paragraph of descriptive commentary completely stale.

Now, of course, it can find the affected passages, prepare a revised explanation, compare figures to a previous version. It can identify the reviewer in charge and even draft the email asking for sign-off of the new figures.

In a more ambitious implementation, it could also update a working draft, change the workflow status, and actually send that message.

And that’s the exact moment where the question gets tricky because it’s no longer “Can the agent do this?” Of course, clearly it can do this. The question becomes, “Which of these actions is it allowed to take without a human deciding?”

AI agents don’t behave like mature adults in the workplace. They’re more like very, very capable kids, and so we need to give them exact guardrails to act.

An AI agent is not like a junior colleague (junior but adult) who would make the right judgment call based on their own values and those of the company. An agent doesn’t have values; will do exactly what you ask from it without scrutiny — and with possibly unintended consequences.

In our enthusiasm about agents, we often blur capability and authority. Capability is what the system can technically do. Authority is what the organization has actually allowed it to do. For example, acting for a named person or team against a specific resource with a defined scope, value limit, environment, and a time window.

An agent may be capable of sending an email, but it might not be authorized to send it. It might be capable of preparing a payment, but not authorized to commit it.

The fact that the system can reach a button doesn’t mean it’s been given the right to press it. recently published a piece on agents operating entire computers, and made this phenomenon quite tangible.

The machine is no longer just calling a small menu of APIs; it can increasingly operate inside the software environments where people work, communicate, shop and manage information.

And that means that the number of available actions is increasing faster in any case than the clarity around its permissions.

A system that can improvise across software is of course more powerful, but also more dangerous because it encounters many more situations that require judgment about intent, acceptable trade-offs and consequences.

So agents are becoming more and more technically impressive — but how do we rein these capabilities in so that we don’t see inevitable snafus happening?

The mistake: treating tool access as delegated judgment

Now, most early agent designs still make a very old security mistake. They hand a new kind of actor a broad credential and then just ask it to behave. The prompt says, “Only do sensible things.” The system actually has a service account, a browser session, and a set of powerful tools, and then we call the arrangement autonomous.

But a prompt is not a permission system, it’s a guidance. For a probabilistic model, the UK National Cybersecurity Centre makes the same point in a bit plainer language. Define what the agent may do, may not do, and when it must seek approval, but do not rely on prompting alone. Combine it with technical and operational controls.

A human with access to a financial system still operates within a web of role expectations, legal duties, experience, and social consequences. An agent has none of this. It just has instructions, tool descriptions, data and context, and the technical permissions we put around it.

That doesn’t make agents useless, but the surrounding architecture carries more of the responsibility than it did when it was just humans and deterministic software.

That’s the same lesson we learned in reporting. Fluent output isn’t evidence. A beautifully phrased sentence doesn’t become defensible because the language model was confident. Likewise, a technically successful tool call doesn’t become appropriate just because the agent had access.

In either case, the decision needs an accountable fact base, a clear boundary, a named owner, and a recoverable audit trail. This ties back to our previous article, Would you let AI write your regulatory reports? Facts flow into text, text doesn’t get invent any facts. The parallel is: policy flows into execution, the model doesn’t get to invent permission.

A practical authority map for agents

Just like a gifted child may still touch hot pots and hurt itself, or even others, so an AI agent can get seriously burned if they are not careful and don’t have the right guardrails in place.

So for every action that an agent may take, five things need to be specified up front:

1. Who is acting? Is this a named human using an assistant, an agent acting for that human, or a system agent acting on its own? Modern enterprise platforms are beginning to formalize this, distinguishing user-delegated authority from an agent’s own authority, and supporting audit trails that show both user and agent identities when an agent acts for a person.

2. What exact action is being authorized? “Help with the report” is an objective but not an authorization. “Update draft section 4.2 in the working document” is a bounded action. “Submit the final filing” is a very different class of actions. The authorization should be tied to an action, target, and normalized parameters, not to some vague promise that the agent will pursue a helpful goal.

3. Which resources and environments? An agent may read the reconciled reporting data for one legal entity, but not every historical file in the company. It may write to a draft workplace space, but not in the signed final document. It may test an integration in a sandbox, but not deploy the same change to production. Access should be granular enough to match the action being requested, but not inherited wholesale from the person who happened to start the conversation.

4. Within which limits and for how long? Authority should expire. It should have a maximum volume, value, number of recipients, and a time window where those matter. An agent that can prepare a customer email draft for review shouldn’t quietly inherit a standing right to send an unlimited number of emails tomorrow. OAuth’s central idea is already familiar, which is that a third-party receives unlimited access on behalf of a resource owner or on its own behalf through an authorization layer, not the owner’s entire password and life story. The same principle can be applied to agents.

5. What happens when the agent is uncertain or their action is consequential? The answer can’t always be “continue and explain later.” The agent needs a proper escalation path (such as: “Stop and surface the blocker.” Or, “Show the proposed action in a human-readable form and wait for a decision from a human.”) For high-impact or irreversible actions, approval should be tied to the exact action, the target, parameters, timestamp, and expiry, not just the broad task. If the recipient, amount, document, version, or policy changes after approval, the approval should no longer be valid.

When these five points are thought through in advance and made clear not just in some word document but in the actual code, then companies are in a much better footing to deploy agents reliably.

Where humans come in

This may sound like humans are being automated away almost completely, except for a little bit of red tape. That’s not the case. Just like a responsible parent is not automated away by a gifted child.

The answer isn’t to place a person in front of every click that an agent makes, of course. That just turns the agent into a very expensive autocomplete tool. It’s like a helicopter parent, really, for the human behind it. And nobody likes to be a helicopter parent.

The answer is also not to place a person at the end of a really long workflow and then asking it to rub a stamp after the consequences have already happened. That’s like giving a highly gifted but rather young child a car to drive and letting the parents figure out the details after the inevitable crash has happened.

The really useful question is: At which decision does human accountability actually matter? Here are a few action items that may help think this through:

1. Observe: reading a bounded data source, retrieving an approved definition or flagging an inconsistency. This can often proceed automatically.

2. Draft: preparing commentary, a recommendation or work plan in a staging space. The agent may proceed, but the output remains clearly a draft.

3. Reversible internal action: updating a non-final workflow or state or preparing a ticket. These may be automated if the action is limited, attributable and easy to correct.

4. Consequential action: sending an external communication, altering a production system, disclosing sensitive data, approving a payment or changing access rights. Here the system should clearly require an exact action review and independent enforcement.

5. Critical or irreversible actions: submitting a regulatory filing, making a high-value transfer, deleting a large dataset, or altering a foundational access policy. At this point, the right design may be that the agent prepares the evidence and the human performs their final operation through a defined runbook.

Depending on the company, there may be more or less of these action items, or other categories entirely. At Wangari, this categorization is the reason why we don’t give the language model a calculator, and a signature stamp for regulatory reporting documents. The calculation is deterministic in our world, and therefore enforced in code. The facts are approved by humans. The agent can just draft and point out exceptions. Humans remain as the gates where responsibility has to remain visible.

And for us, that’s not an anti-automation compromise. It’s what makes ambitious automation defendable. NIST’s GenAI profile similarly recommends post-deployment monitoring that covers override, decommissioning, incidence response recovery and change management, and not just model output quality.

Approval is not (just) a button

Now, many human-in-the-loop designs effectively ask a person to click the “approve” button after presenting a broad natural language summary. That may create comfort, but it’s not really a meaningful control.

The human may have approved a proposal to send the update where the agent has changed the recipient list, attached the wrong file, or included a sensitive data field. A meaningful approval therefore needs to show the agent’s proposed action in plain language, but also the exact target (the recipient, report version, system or account), the consequential parameters (account amount, volume, data class, deployment environment), and anything that can’t be reversed.

The source and rationale where action rests on data, the named approval, decision time and expiry date, and the approval crucially must be invalidated if the underlying action changes. The point here is not to introduce red tape or manufacture friction, but it’s to put friction at the very moment at which the organization is actually delegating responsibility.

Good automation removes the search, the formatting, the copy-paste, and the needless handoff. It doesn’t remove the moment at which somebody needs to stand behind a consequential act.

A decision record, not a diary

When an agent completes a workflow, a final chat message like done isn’t enough. Neither is a detailed recording of every token or every mouse movement needed.

But for a consequential action, an organization should be able to reconstruct the important chain of decisions. The minimum scope then becomes:

1. Request. What was the task and who initiated it?

2. Proposal. What action did the agent want to take based on which evidence?

3. Policy decision. Was it allowed, denied, or escalated and under which policy version?

4. Approval. Who approved the exact action if approval was necessary?

5. Execution. Which constrained component actually performed the action?

6. Verification. What evidence says the intended result occurred or that the state is still unknown?

A conversation trace tells you what the system said. A decision record tells you what the system was allowed to do, what it did, and who owns the result.

NIST’s Zero Trust architecture separates the decision to grant or deny access from the component that enforces access. It also emphasizes a granular individual resource request rather than inherited implicit trust.

This is not an AI standard, but it’s the kind of mature access control thinking that agent builders really should borrow.

The best agents know when not to proceed

The best reporting agent doesn’t panic when it finds a variance in the numbers. It just tells the team what changed, which statements may now be affected, which evidence supports the proposed explanation, and who needs to decide.

It doesn’t pretend that the ability to edit a sentence gives it the authority to rewrite a signed narrative. Just like when your gifted child comes home from school saying that an important test is coming up at school. The mature child will also ask you as a parent if there are any resources that it can use to prepare for that test, rather than eagerly starting to try to prepare it all by itself, and floundering in the process.

We spent the last few years measuring AI progress by what models can do unaided, and that’s understandable given how fast the technical capabilities are growing. But for enterprise agents, this is incomplete. The practical measure of autonomy isn’t how many steps happened without a human, it’s how much responsibility can safely be delegated without losing clarity over authority, verification, and accountability.

Before giving an agent access to a real workflow, here’s what you should ask:

• What can it see?

• What can it change, send or commit?

• Which actions are only proposals?

• Which actions require fresh approval?

• What is the smallest permission it needs?

• Can we reconstruct the consequential decisions afterwards?

• Can we halt it and complete the work safely if something goes wrong?

If these questions don’t have clear answers, the organization has not given the agent autonomy, it’s given it ambiguity. Capability creates the opportunity. Authority design determines whether the opportunity is safe enough to use.

Meanwhile, at Wangari

We’ve been busy at work making our flagship product, etio, even better. We’ve improved not just the frontend interface but also how AI interacts with facts, and we’ve managed to attack AI output — with very promising results.

We’re proud to be featured on ShipAI! It’s a new format by Towards Data Science, dedicated to showcasing AI products in a digestible and fun way.

Reads of the Week

• has a few very astute observations to share on the state of human control in the age of AI. The key line: AI is moving from using tools to operating environments. The hard problem is no longer whether an AI can operate software, but what it is allowed to see, change, send, buy, or decide on somebody else’s behalf. The core of the problem is the “agent visibility gap,” i.e., we currently don’t know what agents are doing and why — and that’s a gap worth closing. The real currency in AI is not how much it can produce (very much), but how much it can be trusted with real-world decisions.

• has slightly different take on AI governance. Capability becomes a governance problem when an agent can authenticate, invoke tools, and act against enterprise systems. The practical answer is not more prompting, but creating distinct agent identities, scoped and expiring authority, and an auditable delegation chain. It’s informative as a clear bridge from agent capabilities (where most companies are at) to agent authorizations, limits, and controls.

• has a very interesting piece on agentic AI in law (not on your in-laws — sorry, couldn’t suppress the pun). It’s interesting how many junior lawyers seemed to have jumped on the hype without the same prudence they’d use on human assistants. The problem compounds, because AI agents have zero fiduciary duty! Interestingly, the guardrails for using agentic systems (i.e., the equivalent of a junior legal associate) and agent-ish systems (e.g., like a paralegal with a detailed checklist) turn out to be practically the same as for human legal staff. Which means that legal folks might simply need more discipline around AI.

Let me start with a simple question. Would you sign an AI assistant sentence in a regulatory report? And I don’t mean, would you publish it on an internal website or use it as a first idea in a workshop? I mean, would you put your name on it in an SFCR, an RSR, or an ORSAR related?

Narrative. And that’s a more useful test than asking whether AI can write well. Of course it can write well. In many cases, it can write much more smoothly than humans do when humans are tired or under pressure or looking at the fifth version of the same paragraph.

However, fluent language isn’t the same as evidence. A sentence can be perfectly grammatical, logically structured and useful, and it might still be impossible to defend if somebody asks where the claim of the sentence comes from.

The standard I want to suggest today is not, can AI write a good sentence? The standard is: Can a named subject matter expert trace, test, and stand behind that sentence?

The distinction may sound small, but in spaces like regulated reporting, it changes the entire process design.

AI isn’t production-ready

This isn’t just a theoretical question. A market study conducted by EIOPA covering 347 insurance undertakings across 25 EU and EEA countries showed that 65% were already using generative AI and another 23% plan to implement it within the following three years. This data is from July 2025, so these numbers likely have only increased.

Across insurance, the question of whether generative AI will enter day-to-day work has largely been answered. However, EIOPA also found that 64% of reported use cases were still in proof of concept or experimentation, and only 32% were in production.

That’s the big gap. Adoption is real, but dependable production processes are still being built, and that’s exactly where reporting functions should focus their attention.

The interesting piece of this is not to choose a tool that produces impressive language in a demonstration. It’s in building a process that still works on the evening before a filing when a model run has changed and three people are waiting for an answer.

Regulated reporting is also particularly pertinent for this type of automation. The same EIOPA survey notes that 64% of reported use cases were in internal back office applications, just like, you guessed it, regulated reporting. Internal reporting is of course not risk-free, but it does make a sensible place for a bounded and human-reviewed use case for AI.

One caveat to add here to these figures is that they are sector-wide, not specific to reporting. Nevertheless, I think they show the trend.

The real problem starts after the numbers

When I speak with reporting, finance, actuarial and risk teams, I constantly hear a version of the same story. The calculation itself is fairly straightforward. Those models run and they don’t need AI.

The real pressure begins after that number is available. There are four jobs to consider here:

1. We have to assemble the narrative. Tables, explanations, comments, and context often live in different systems and belong to different teams.

2. We have to explain the movements. What changed, which drivers matter, and which drivers are material enough to mention.

3. We have to keep the evidence recoverable. Sources, version, methods, exceptions, and the owner of the answer.

4. We have to preview, review questions, edits, challenges and approvals, move across functions, legal entities, and sometimes several rounds of review.

These four jobs are actually tightly coupled, and that becomes visible usually at the least convenient moment. So imagine it’s 20 to 6 on a Tuesday evening before a filing. Suddenly, a number shifts by 0.4% and now you have to update the whole thing. Updating the numbers may take 10 minutes, but then the real work starts.

Where else does the number appear in the report? What other numbers were calculated from it? Which explanations about that number are no longer true and which sentences now suddenly contradict other sentences further on in the report? And finally, who needs to review all of this again and sign their name?

And that’s not just a writing problem. It’s not just a data problem. It’s a linkage problem between a fact, a statement, and the evidence behind the statement. If we use AI well, then that linkage problem is where the first practical value should appear.

The four questions I want every reporting sentence to answer

For me, a sentence in a reporting document that’s defensible has to answer to four questions.

1. Definition. What exactly does the metric measure? A solvency ratio, an SCR component, and a movement attribution may all be related, but they’re not interchangeable.

2. Reference basis. Are we talking about percent or percentage points? Year end to year end or quarter on quarter, actual to plan or something else? Many reporting errors are not grammar mistakes. Their errors are unit, comparison, basis or scope.

3. Evidence. Which source, which version and which method supports this statement? If I can’t trace a claim back to a stable fact base, I can’t. Review it. I can only decide whether I find it plausible, and that’s what’s currently happening. It’s just vibe checks.

4. Responsibility. Who can amend this statement? Who reviews it and who approves it? Automation does not remove human responsibilities. If anything, it should make the responsibilities more visible.

Put together, this is by far and large not a special standard for AI. It’s a standard that should also improve human written reporting if implemented correctly.

Facts into text, never the other way around

The operating principle that I use is very simple. Facts, pre-calculated, flow into text. Text never flows back into facts.

AI may at some point be adept enough to apply changing legislation and update pre-existing calculation tools or even invent new ones. However, these days, I’m not confident enough in AI’s math capabilities, to say it bluntly, to let it loose on mission-critical calculations. A controlled package of calculated facts should at least contain the value of the unit, the period, the source, the version, and the relevant methodology.

The AI drafting layer can then take this package and turn it into a clearer and more consistent language that humans can actually digest rather than staring on a complicated table. AI can prepare a first draft. It can make recurring wording more consistent. It can highlight a missing time period or a missing source. And it can prepare useful questions for a reviewer.

It should just never recalculate a number. It should not insert a figure because the figure sounds plausible. It should not turn a correlation or a sequence of events into some causal explanation when causality isn’t established. And finally, it shouldn’t decide on its own whether a driver is material, immaterial, the largest or the most relevant.

These boundaries aren’t limitations of value, they’re conditions for value. And even if it sounds like we’re restraining AI to dummy jobs, that’s because AI at the moment is just too confident and we need to re-rail it back to what it can actually reliably do.

The goal here is not to replace any expert judgment, just to give expert judgment a better starting point with the help of AI, meaning a draft that already carries its facts, its evidence, and its open questions with it.

Are insurances AI-ready?

One objection that constantly comes up is our data landscape isn’t ready. And that may be true if we mean an enterprise-wide AI program with access to every system, every historical record, and every type of report. If that were the precondition, then most AI programs would never see the light of day.

But for a first use case, this is really not the right threshold. A perfect central data platform is not required at all, and no access to historical sources that are harmonized or having solved every remaining data issues. There is one basic requirement, and that is having an accountable fact base.

For one reporting component or one sharply defined analytical question, ideally one that carries a decision after it that can be tested. So for that one component or decision, I need to know the exact sources, the metric definition, the period, the access rate, the version and the known exceptions. Most importantly, I need to see the gaps.

I don’t want a polished AI sentence to hide a missing definition, an unresolved data quality issue, or an incomplete attribution. A visible exception is inconvenient. An invisible exception is dangerous.

So I wouldn’t ask, is our organization ready for AI everywhere? I would ask, can we trace the facts and own the exceptions for this one paragraph or for this one reporting module? This isn’t avoiding the data problem, it’s actually facing it head-on on a specific and narrowly defined case.

The result of this is that you get to tackle it piece by piece where it matters most first.

How to make an AI draft reviewable

If we accept that facts and texts need a controlled relationship between one another, then we get four practical controls.

1. A fact boundary. The drafting workflow should receive only approved data and approved calculation outputs. This reduces the risk that a model uses general world knowledge, an old document, or an unauthorized file to create a plausible but unapproved statement.

2. A claim check. Each material statement should be checked against its value unit, period, source, and where relevant method. For a movement of 12 percentage points, the test is concrete. Is the figure in the approved package? Is the unit correct? Is the period correct? Does the source match?

3. An evidence trail. The version, method, exceptions, and status of the draft need to remain recoverable. This is what makes the process understandable three months later to an internal reviewer, an auditor, or a supervisor.

4. A human decision. A reporting owner must be able to accept, edit, reject, or accelerate the draft. A polished output is not an accountable statement until that decision has been made.

This is consistent with EIOPA’s 2025 opinion, which takes a risk-based and proportionate approach and highlights data governance, recordkeeping, fairness, cybersecurity, explainability, and human oversight under existing insurance sector expectations.

The practical lesson is this: Good AI governance should be visible in the workflow itself.

Going beyond hallucinations

One word about hallucinations. When people discuss generative AI, they often focus on this, and the risk is certainly real, but in reporting, some of the more dangerous errors are not invented sentences or facts. They’re just plausible sentences with the wrong meaning.

For example, a unit error can turn 12 percentage points into 12%. That’s not the same movement. An aggregation error can present a component risk as if it were the total risk without the relevant diversification or scope. A report-level consistency error can leave one paragraph correct on its own, but inconsistent with the statement 40 pages later.

A vague quantitative phrase such as low single digits can sound careful while hiding the fact that nobody agreed on the factual basis. A causal claim can say because of interest movements, even though the documented analysis only shows that two things moved at the same time without any cause or effect proven in the data. A materiality claim can call something the largest risk or an immaterial effect without prior establishing a defined threshold or comparison logic.

Five out of six of these aforementioned errors can be grammatically flawless, but they’re not. And that’s why language quality is not the control quality here.

The correct question isn’t: “did the model make up a number?” It is: “did the statement preserve the meaning, scope, and evidence of the approved fact?”

A realistic first step

Given all these pitfalls and perils, how do we actually start? My recommendation is not to begin with an AI transformation program. That would be a huge undertaking and a costly one at that.

My recommendation is much smaller: to begin with one accountable decision. I would choose a recurring reporting component or as defined analytical question where ownership, sources and review are already reasonably clear. As a practical rule, if I can’t describe the first use case in two sentences, I have chosen a too big use case.

Before building anything, I’d define the control boundary in writing. So: which sources are in scope, which factual fields are mandatory, what may the system do, what may it explicitly not do, which tasks remain with the subject matter function under all circumstances.

Then I’d run the existing process and the assisted process in parallel for one reporting cycle. I wouldn’t judge the pilot by how impressive the AI draft looks on screen. I’d judge it by whether reviewers can’t find relevant exceptions faster, trace the evidence more easily, and spend more time on judgment rather than searching across files with the help of an AI system.

I’d also measure missed issues and false alarms. Missed issues matter because a problematic statement may pass silently into the report. False alarms matter because if a system flags every second correct statement, people will stop trusting it and the review becomes a second manual production process.

Only when the first use case proves both utility and control would I send the approach to further reporting modules, common clusters, or scenario preparation.

The bottom line: better questions, not automated decisions

I’ll close where I started. Would you sign an AI-assisted reporting draft?

The useful answer is not a simple yes or no. The useful answer is a list of things that would need to be visible: a bounded fact base, a clear comparison basis, a claim check, a recoverable evidence trail, visible exceptions, and named human approval.

Those elements are in place. The opportunity is larger than faster writing: the same structured facts, comments, and exceptions can help a team identify recurring patterns, compare explanations across periods or legal entities, and ultimately ask better questions earlier.

A pattern is of course not a diagnosis, and a correlation is not causality. That’s why an AI workflow should just prepare questions and suggestions for experts, and not make management decisions on their behalf.

The goal is not a report written by AI. The goal is a report that is easier for people to understand, challenge, and stand behind.

Meanwhile, at Wangari

The Leipzig event was a blast! I had a wonderful time connecting with key reporting and risk staff at leading insurers in the DACH region, and learning how and where they’ve started using AI.

What I enjoyed most was seeing how differently each insurance company was treating AI, and where they were at in the balancing act between caution and enthusiasm. The above post is an adaptation of the 45-minute talk I gave there.

Reads of the Week

• argues that an AI Regulatory Commission is needed in the US. Indeed, voices are getting louder asking the state to step into this hot mess. Cass lays out what that would look like in practice. I follow this from Europe; still worth my eyeballs, and probably yours, too.

• Another chime into that same direction: writes that frontier AI needs regulatory capture. For those of you who are not law experts (that includes myself — I’m a physicist by training), this piece is very useful: It explains the distinction between regulation and regulatory capture, and, interestingly enough, the latter is “what all the most evil corporations aim for.” Despite the strong language, a very informative read.

• In yet another take on AI regulation (did I mention it was trending?), writes that much of US regulation won’t come from Washington but from the states. This is interesting… As an EU AI company (though not one of the evil ones, I think — we’re too small for that), this frankly makes the US less interesting for us, not more.

Researchers at NYU, Cohere, and Anthropic found that one can hack an AI’s reasoning and figure out what exactly it is thinking. In doing so, we’re basically opening up the subconscious AI mind. Interestingly enough, these researchers found a very human trait in that mind: Just like humans, AI doesn’t always say what it thinks.

Reasoning, and deep thinking, is generally a good thing. And it’s a thing that up until a few years ago wasn’t even clear AI could actually do! If a model reaches a better answer by taking more intermediate reasoning steps, that’s great news.

But reasoning is also the secret sauce of every AI model, because it’s very difficult and cost-intensive to train an AI model to think; then, when AI has developed this thinking skill, other models could in principle take that and learn how to think as well. And so it comes as no surprise that AI model developers have been accusing one another of copying each other’s reasoning attempts, especially US companies against Chinese companies.

So beyond geopolitics, what I think is so interesting here is not whether we can see an AI’s reasoning and therefore understand how it works, but to actually understand the extent of its understanding of the world today. The current research says that AI’s chain of thought can be “plausible yet misleading.” In other words, sounds good but isn’t great in substance.

So I wonder — when AI reaches something like omniscience (knowing and understanding everything in the world), will it come to dominate us? And, more importantly, since that’s currently not the case: How do we navigate this weird in-between where AI gives decent answers based on rather imperfect thinking?

AI is like the average psychologist. It sounds like it really “gets” you, but it just knows the right words to tell you.

Have you ever told a friend something really intimate and thought they really “got” you — until this friend got a really crucial detail wrong and then you realized that they didn’t understand you at all? Or maybe you’ve experienced that kind of situation at a psychologist’s or doctor’s office.

A psychologist knows how human minds behave, generally, so when they draw some conclusion and you think “OH YES EXACTLY THIS IS ME” — it’s not about you. It’s just how human minds work.

Well, this is exactly what happens with AI, but basically on steroids. You see, AI will always respond sympathetically and pretend that it knows how to solve your problems, but the reality is that it often doesn’t — and that it has a very limited understanding of who you even are and what it is that you’re trying to accomplish with its help.

So when you’re using AI, you don’t really know whether it understands you or not. And chances are it doesn’t, at least not as much as you feel it does.

Stumbling blindly over its own shortcomings, without ever taking responsibility…

If you think that it’s a bad situation when you’re sitting for coffee with a friend, or for a second coffee at your computer screen with an AI, think about what might happen when these AIs with limited understanding of you become agentic and perform tasks for you. Everything seems to be running perfectly fine until there’s a massive blunder in an area that this AI should have really gotten right, given how much it demonstrated its understanding before. Like if your therapist helped you out in-person in that argument with your spouse, beautifully, only to ruin the whole thing by getting their favorite color wrong!

Worse yet, it’s you who has to live with the consequences, not the AI. The AI (or rather, its producer) just collects your bill at the end of the month.

As a result, when you’re working with AI, it’s really crucial to double-check every step, and that can be a very tedious process unless it’s architected right. One of the simplest approaches one can do is have different AIs check one another’s work. This is very efficient because AI is fast, but it’s not sufficient.

What we really need is a proper way of imbuing AI with “thinking.” And luckily, a mathematically rigorous formulation of “thinking” already exists.

Causal inference is not a magic brain update — but it’s quite the A-Eye-Opener.

That method is called causal inference. It was actually developed by mathematician Judea Pearl decades ago, but it’s becoming more and more in vogue because it turns out that it’s a brilliant technique to check and guardrail AI.

It’s really a set of methods for estimating the effect of a defined change of some variable under some kind of stated assumptions. So for example, A changes by 10% and A somehow depends on B. So how does B now change? This is the causal link.

It also asks what counts as an intervention and what else is being affected around that link between A and B, what an outcome C could be of all that, and whether variable D could also influence what’s happening between A and B.

Furthermore, once a causal link is established, one can simulate interventions and scenarios. What now happens to outcome C if I change A a little bit, or if I add something to D? Humans like to optimize for good outcomes, and causal inference provides the mathematical underpinnings to do just that.

Of course it’s a bit more complex than that (it’s math, after all) — but this formalism, at its core, provides very solid conclusions that resemble human thinking, augmented by a level scientific rigor that most human minds still aspire to. Stack that into AI and you truly have a form of superintelligence, and not just great-sounding gibberish.

Causal inference transfers responsibilities better, through enhanced system understanding.

An interesting corollary of this whole interventions and scenario running in causal inference is that it can help AI understand what consequences are and how to live with them. So we humans are not all alone in facing and bearing the consequences of our or increasingly AI’s actions.

In practice, this would look something like this:

1. First, before even touching the data, an AI agent inspects the dataset itself, the questions, and formulates some hypothesis. Something like, “I think that A causes B and therefore we’d get outcome C.”

2. It would then draw up that hypothesized system as a second step. This produces a causal map of sorts where you can see all the causes and outcomes and everything in between in one chart.

3. Then it would orchestrate approved analysis tools rather than, as is the case at the moment, mostly relying on its own trained logic to solve math problems (even when its logic is wrong!).

4. It would also make abstention an achievement. That is, if the AI is not sure, then it would honestly say so, and it would win brownie points for doing so. Right now, AI is conditioned to say something that sounds knowledgeable, even when it actually has no idea what it’s talking about.

5. Fifth, it would then generate some actionable advice and, if applicable, execute on it. But it would only execute (and thus be a real agent) if it is authorized to do so by a human. That gate is a friction point in the system, which is really important. A bit of friction and human control is a good thing at this moment in AI development.

6. And finally, this AI should learn by itself from the outcome and log whatever it’s been doing and how it got to that outcome. This way it can review the outcome every so often and optimize for the best outcome.

This gives AI a clear stake in what the outcome actually is and gives it some incentive to optimize towards the outcomes that humans really want. That’s more than just generating cool sounding gibberish that, at the end, some human not only has to pay token fees for, but also needs to sign with their name.

The status quo: Somewhere in the muddy grounds between “sci-fi” and “solved.”

Sounds like a cool workflow, right? In fact, this is exactly what we are implementing in our flagship product, Etio, and our other products, Capvert and Forecaus.

However, looking at the research and the status quo out there (consider this, this and this), what I’m seeing is that humanity is still somewhere in the middle of this journey. The conceptual frameworks of how to actually deploy causal inference within AI within enterprise systems are still developing. And so these problems are far from solved — but they are also not sci-fi anymore.

If you told me about all of this two years ago, I would have said, “woo, dude, that’s not happening.” And now it is happening! We are still very much in the beginning of this journey — it’s far from solved — but it’s definitely happening, and not just at Wangari.

That said, I’ve yet to see some real use cases where this system just runs in a scalable way without any hiccups whatsoever, like a good laundromat. Nevertheless, we’re inching closer and closer pretty fast.

If something doesn’t work, don’t try harder. Especially thinking.

Most people can’t just open up an AI, look inside, and give it a framework to help it “think.” Most people can’t string together multiple AIs, and plonk them in a framework that does causal inference. And neither of this I’d demand of you readers. But if there’s one takeaway for you in your day-to-day work, I would say: Don’t make AI think too much, and don’t believe too much what it says it thinks.

Research has shown that what AI tells you it’s thinking and what it’s actually thinking are two very different things. And so, if you’re not satisfied with an answer, it’s of limited value to ask the AI, “hey, why did you come up with this?” The AI likely doesn’t even know why and how it came up with some result — and even if it does, it’s not incentivized to tell you all about it.

Instead, try simplifying your approach or your prompt. When thinking harder doesn’t work, think less. This, at this moment, is the safest approach. Meanwhile, firms like Wangari work in the background to strengthen AI — so that you get better and better outputs on your end of the screen.

Meanwhile, at Wangari

I’ll be speaking at the Erfahrungsaustausch Solvency II in Leipzig this Thursday — getting down to core principles on how to use AI in insurance reporting without getting crucial things wrong (and crucial things are all things in reporting, by the way; every number or sentence could make or break the report).

The broader event has two main pillars: Automation (including AI), and handling the upcoming Solvency II Review, which — supposedly — eases the reporting burden. My talk straddles both because I see in this regulatory change an opportunity for AI to add value in unprecedented ways. More to come when I’m back from Leipzig.

Reads of the Week

• has an excellent piece explaining why AI’s “thinking mode” doesn’t always produce better results, despite being slower. The guide also explains how AI thinking is implemented under the hood, which is very valuable for anyone tinkering with AI for a living (me, and many of you). Moral of the story: Easy tasks don’t benefit from extra thinking, complex ones do — and the wise user knows the difference between the two.

• A fascinating journey into AI for medicine, by : OpenAI’s Epic now not only knows the world’s publicly available knowledge of medicine, but also countless patients’ records. However, as the author points out, AI is not able from this to construct causes and effects of various diseases, or prescribe a treatment. This should be done by a doctor, whose role increasingly will be curating and editing AI-generated answers to disease, and making the final judgement.

• makes the case that AI should enable humans to return to more human work — you know, the kind that happens face-to-face and not behind a screen. He then goes into the human work that many companies are doing to make the planet a better place, and the Shizenso methodology he created around streamlining such work. It’s an interesting thought-starter on where AI fits in corporate governance and sustainability.

Let’s start with the obvious: AI is worth adopting. It’s proven useful because it removes so much friction from everyday work: finding information or summarizing long documents, drafting an email or (ugh) putting together PowerPoint slides.

Productivity has become effortless. Anyone can generate a sophisticated five-page document in five minutes.

What’s missing is a layer of healthy discrimination: Just because you’ve produced a lot doesn’t mean you produced the right thing, or produced the thing in satisfactory quality (as opposed to quality that looks good on the surface but is threadbare underneath, as is the case with much AI slop).

But where do we start with evaluating whether AI is doing the job right or not? Let’s start where quality becomes immediately quantifiable: With the numbers.

The thing about accountability

There are legal precedents that hold companies accountable for whatever their AI tells their customers. In a legal precedent in 2024, Air Canada was sentenced to reimburse a customer for fares that the chatbot said were applicable to him and actually were not. In other words, if your chatbot hallucinates, you pay for it, not your customer and not the AI provider.

This also means that any output you productively generate at your job remains your company’s responsibility — and could cost you your job if you were the one messing things up.

Which is dangerous because AI is great at giving nice-sounding, but in actuality confidently bogus output. What we need is AI that people, and companies, can actually stand behind. And that’s not another model, it’s a separate architectural layer.

When the wrong numbers get you into jail

At my company, we wanted to solve this with a use case where errors could get you into jail but where verification is fairly straightforward. We found that in insurance reporting: It’s mandatory; if the numbers are wrong then people can end up in jail; and to verify them you compare the generated with the real numbers with no textual understanding required.

The real concern here is neither whether an AI can calculate a number — it can but pre-existing tools do so much more reliably already, nor whether the AI can write a number in a sentence (it can). The tricky part is whether an AI-generated sentence in an insurance report contains the right number on the right basis for the right period from the right source with the right units.

Higher standards for AI

To accomplish this, an AI chatbot should tie the source data — whichever tool or database the numbers come from — to totals, hierarchies, and business rules, not to mention public and external datasets.

The hard part here is not building a retrieval-augmented generative AI (a so-called RAG); that problem has been solved. The hard part is not about reading tables and letting AI pick the right numbers; it’s about understanding what those numbers mean and then put them all together in ways that really make sense and that the firm can stand behind.

In an insurance company, an AI may give a plausible reason for some quarterly loss ratio movement. But before this sentence becomes a management conclusion, somebody — the AI and also, crucially, a human as a final instance — needs to check whether the premium basis and the reserve development treatment, portfolio mapping, and all the other connected things are coherent with this claim.

Confabulation is a thing

I didn’t invent this — this tendency for confidently stating junk is what the NIST poetically called confabulation. So confidently, in fact, that users often believe it until it’s too late.

To mitigate confabulation, the NIST says one should compare outputs with known ground truth, use more than one method of evaluation, document data suitability, and fact-check any general information.

This sounds like duplicate effort, but it isn’t: because it catches things before they go bad. The temptation is to just give AI a nice database, so-called RAG technology, and then let it query that database and call it a day.

But the problem with it is that retrieval doesn’t solve any semantics or any calculation issues or reconciliation issues. It can’t explain why the number in a table is the way it is. And so we need a bigger architectural solution to make this kind of AI “sense making” layer happen.

High stakes, high risk?

Regulators are keenly aware of this. The EIOPA, an important insurance governance body, highlighted in 2025 that data governance, record keeping, explainability, and human oversight are vital for responsible AI use. The NAIC model bulletin, in turn, identifies potential AI-generated inaccuracies, data vulnerabilities and bias, and calls for governance, risk management, validation, and documentation.

So the regulators are not just blanketing a ban on AI, which we all know would be harmful and would just make people use AI under the radar.

What’s needed now is a layer that implements what regulators are asking for: a layer that sits on top of the numbers that are being calculated anyway, and which involves the humans that carry responsibility for its output in intelligent ways. (These are the same humans who so far have been painstakingly using their own brilliant minds on boring reporting rather than more important tasks.)

This can be fully automated with AI if, and only if, AI is actually made reliable. We thus need AI systems that not only determine what the right number is, but also what it does and doesn’t imply, what went into the calculation of the number, and under which hypothesis this calculation is sound.

That’s a set of capabilities that we can, in fact, implement architecturally by using AI agents. It’s not just another dashboard or a chatbot. It’s real infrastructure which resolves semantics and grounds any claims in authoritative data.

This kind of AI should be repeatable and calculate things logically, and it should signal uncertainty. So where there is no evidence or where it just isn’t clear, it should say, “I’m not sure.”

Which is something that AI by default is very bad at — but we can indeed make it say “I’m not sure” when it isn’t. Such a layer should produce an audit trail that’s reviewer-friendly, citing its sources and assumptions and transformations.

The technical implementation

How to build this layer without building a more powerful foundational model?

The secret, to my mind, is causal and agentic intelligence. Causal intelligence (also called causal inference in data science circles) is the discipline to tell not only what happened, but why, in a mathematically provable way.

Causal intelligence has remained small so far, however, because it used to require a lot of manual work of deeply skilled people. Agentic AI supercharges that, and because the methods themselves are inherently verifiable, this doesn’t create an additional AI reliability risk.

Causal intelligence, deployed and orchestrated by agents, makes causal relationships and underlying assumptions more explicit, which means that AI can treat an explanation as something to test or to qualify, and not just as a nice story that it can autocomplete.

How this ties to insurance reporting

In insurance reporting, we have plenty of numbers that need verifying. We also have governed data and time-sensitive metrics and multiple ambiguous definitions and reconciliation that needs to happen all across various data silos. And then there’s regulatory scrutiny and expert reviews. In short, everything is very complex.

That same pattern appears in finance, in risk, in capital planning, in operational reporting, in sustainability reporting, — the list doesn’t end.

Insurance reporting is thus our starting point, in order to test and to build out our architecture around this problem. Ultimately, we want to become the go-to provider of this AI sense-making layer for any enterprise data, beyond reporting and for all industries.

Towards sense-making enterprise AI

The future is not less AI. It’s AI that creates speed without dissolving accountability even a bit.

In order to respect that accountability, we will need to distinguish between enterprises that just use a nice interface and enterprises that build the context and the controls that are required to stand behind the answer that AI gives them.

And it’s the latter group that will save itself a lot of manual, boring work in the long run, which allows it to become much more competitive also over time.

Numbers, here, are not the forcing element — it’s just that numbers are very checkable, which is again a wonderful stress test for AI.

Once an organization can make numerical answers traceable, it has a foundation for more dependable AI everywhere else.

Meanwhile, at Wangari

On September 17, I’ll be speaking about AI in Solvency II reporting in Leipzig!

Insurance reporting is going through some key changes, including a reform on the narrative reporting from early 2027. This gives rise to some key risks and opportunities for AI solutions sold to or being developed within insurances.

If you’d like to meet me in Leipzig, registration for the event is still open (note that it’s in German). I’m looking forward to many inspiring discussions with German insurers and solution providers.

Reads of the Week

• dives into AI sycophancy. In a very cleanly set up experiment, she tests how agreeable AI is with the user prompt (ever heard AI tell you that your idea was brilliant?), and whether the content changes. The verdict: AI is highly sycophantic, but the factual evidence remains stable, whether one asks for compliments or criticism — which is good news, really.

• I’m not usually one to hype a particular venture capitalist, but ’ piece on VC Sarah Guo’s contrarian AI bets is actually fantastic and thought-provoking. She bet on legal AI firm Harvey when they didn’t have an investor deck, and her fund has backed 6 of the 21 AI-native companies whose revenue runs over $100 million — all running on the thesis that massive AI labs can’t build the products that actually bring value themselves. She’s the genius identifying the business that comes after the AI.

• A short and rather philosophical piece on reminds us that AI is but a tool — it’s humans who give it a purpose. What should we train AI for, really? Our values may be well-encoded into language, but language is tiny compared to the “infinite richness of life.” How do we encode that into AI? Not an answer, but the questioning itself is worth reading.

We're living in the age of the stochastic machine.

Computers are getting more and more powerful, and they’re dominating more and more things we do in life. It's not just that we're staring at the computer all day to do what's commonly called “work.” We are impacted by the very decisions that computers make – a credit approval, a tax filing, or when that traffic light finally turns green for us.

And unlike the pre-LLM era, these computers no longer follow very clear rules that anyone with a programming background can inspect and verify. The rules that computers follow now are non-existent.

These computers are becoming very sophisticated and very powerful, and very, very opaque. If you ask one of them, why it decided like this or why it decided like that, is going to come up with a very sophisticated response. The only problem with the response is that you don't know if it's actually true. In fact, the machine itself doesn't know if it's true and why it reasoned the way it did!

We’ve lived in an unreliable world forever. Why the fuss?

Now, putting the word computers aside, this is very much the world that we've always been living in—the world of humans. Humans are very sophisticated calculators that work in very opaque ways.

That's why psychology is still a battlefield with a reproducibility crisis that doesn't want to stop. So why suddenly are we having a problem with computers not being reliable?

While we've been dealing with unreliable humans for all our lives, the killer argument here is that AIs are not us. All of us here are humans, except for – hello – all the bots that are reading this article. (Yes, I mean you!)

And even though another human across the room may behave in what we deem illogical ways, we can kind of empathize with that human if we know enough about them. With most humans, enough empathy gets us to some degree of understanding of the reasons why they did something weird, or bad – and that counts even if it’s not very scientific but rather based on intuition alone.

Computers are a bit different from us. For example, if you feed a current-day LLM with enough additional context, its reasoning and math capabilities go down the drain. That's a bit like if you sent a ninth-grader human to some extra schooling in all subjects, and as a result the person didn’t get somewhat better in all subjects – it became surprisingly good at history, got worse at math, and became dumber overall.

That's normal AI behavior and it’s not intuitive at all. I think that this is part of the reason why we're scared of AI, because we don't really know in which ways it's unreliable – I just cited a well-known behavior, but there are so many more that we don’t even know about yet.

With humans, in contrast, we very intimately do understand how they work, however illogical they sometimes are. Plus, we've got thousands and thousands of years of experience to point back to, and institutions and systems that grew around, and because of, human unreliability.

Intimacy in the era of AI

Which brings me to intimacy. I'm a writer myself and I do make use of AI in various ways. But when I read an article that sounds mostly AI generated, I feel cheated. Because when I'm reading a human-written piece, it feels like I'm getting a front seat in that person's mind, and that’s what gives me a sense of intimacy. It reveals how that person thinks and feels, and that's exciting for me.

However, I'm not very interested in empathizing with a computer. I know it's a human creation, and I know it can fake some feelings, but really it's not the same experience as connecting, even through a screen, with another being that’s made of flesh and blood like myself. I want human connection, not computer connection.

In writing, we actually prize unreliability because it's exactly what makes us so human. Unreliability becomes creativity.

In contrast, if I reliably read the words “genuinely” and “honest” in the same paragraph, then I know that this was Claude’s making, and I feel cheated. If I see an em-dash too often, I know this was ChatGPT, and I feel cheated. Too many of these phrases break the unilateral contract of trust that I had imagined myself having with that particular author (or sometimes with myself, because I, too, am guilty of having generated some AI-powered swivel in the past)

AIs don’t understand relationships

This brings me to the next relationshippy thing, which is repair. Humans do make mistakes, many mistakes. But when a human that I care about makes a mistake, then I can always go up to that human and tell them my opinion on their behavior. They might rectify it or not – but the point is that there is a clear protocol as to how set errors straight.

With an AI, it's very different. If I tell the AI that it’s wrong, it will profusely apologize (sometimes even when it wasn’t actually wrong), and then just make that same mistake again! If I’d meet a human who systematically behaved this way, I’d label them something between a pathological people-pleaser and a psychopath.

AI doesn't understand what I really mean when I point out a mistake. And even if it does correct its mistakes, I don't know if it's just correcting those mistakes because it wants to make me happy, or because it's actually, genuinely (that’s my “genuinely,” not Claude’s) understood what I mean by making things right.

AI mistakes scale beyond comprehension

One of the biggest arguments for the AI reliability anxiety is scale. AI systems are so much faster than human brains ever could be, and they're getting faster still. With that come blind spots, and if those blind spots are everywhere all at once, then we might run into massive problems.

Humans have their blind spots – but they're usually distributed in different places. For example, one person might be really bad at tying their shoelaces. And another person might be really bad at not bumping into lampposts on the street. (That, by the way, is a real anecdote of my own couple’s life – your guess on who is who.)

Now, if we live in a world of AI-powered humanoids that are consistently bad at tying their shoelaces and consistently good at dodging lampposts, that creates a society in which everybody dodges lampposts expertly with untied shoelaces, and then trips and falls over their laces anyway…

Luckily, we live in a (humanly) diversified society where some people bump into lampposts and other people trip over their shoelaces. With AI, that diversity just doesn't exist, because there are maybe a dozen widely used models and not eight billion of them. And often don't know what those widespread failures are until it's too late, when they’re already everywhere. Which is scary.

In addition, humans can reverse their mistakes (at least the more intelligent ones). AIs make mistakes very fast, and then not know how to reverse a mistake. For example, if I'm writing a piece of code with AI, then that code may contain a bug, and when that bug doesn't get detected and I have to undo that bug, that takes so, so many hours of frustrated prompting. (I’m speaking from experience.) With a human author, they would spot the bug in the correct line of code and fix it with a couple edits. A similar logic applies to things non-code.

What happened with privacy?

When we share our problems with AI, we don’t really know where all our private information is going. If I complain to an AI about my partner not being able to tie their shoelaces, then could Sam Altman in theory know that a random guy in Paris is frustrated about this? Nobody really knows.

Of course, there are so many problems being confided to AI every minute these days that it’s impossible for anyone to keep up with this swamp of human quandaries. My little problems are probably being buried by everybody else’s.

But the point stands: if I complain about my big fat shoelace problems to my best friend, it stays with my best friend. Maybe they’ll tell another friend, in which case, obviously, I’m going to give them a hard time – but for the most part, my information doesn’t travel very far, and besides, my best friend might even come up with some nicer solutions than those of an AI. Plus, it’s much nicer to look at an empathetic face over a cup of tea rather to stare at another screen.

Will human knowledge go down the drain?

Another huge problem is this fear that we’re losing key capabilities. What happens when we outsource so many key tasks to AI that we forget how to do things manually anymore?

For example, it’s been a long while since I’ve actually authored a block of code all by myself. I’ve edited code, I’ve organized code, I’ve architected code, yes and yes and yes. But I haven’t really written a single new function from scratch for the past three years or so. And I’m sure that I’m not as good at this task as I was back in the days.

What happens when this forgetfulness sets in at scale? What if at some point the AI might also forget about it, or changes things around in illogical or irreversible or suboptimal ways? May we then suddenly find ourselves at a point beyond return where we’re sitting with a problem that we can’t solve, and AI can’t solve either? That’s a bit scary, and it may happen in many ways way beyond code.

Accountability in AI is opaque at best

I’ve saved the biggest point for last – contrary to good writing advice, I know.

Accountability ties into the forgiveness, see above, but it’s also much more than that. A doctor or an editor or a pilot or an official has some real stakes in their profession: a name and a license and an employer and professional obligations, and so on. They can make many mistakes, and they do, but they are ultimately held accountable in some way (even if it’s just their own sense of guilt, perhaps, in some cases).

That’s why malpractice lawsuits, professional governing bodies, and justice as such exist. With AI, it’s a different kettle of fish.

I had a minor surgery a few years back, and when I went under the knife, I basically entrusted that doctor with my life. It was a low-risk operation, but still I considered the possibility that I might not wake up on the other end of the procedure. I felt confident nevertheless, because I had trust in the surgeon. But had an AI operated on me – I would have had a very different, very queasy feeling about it.

This comes down to personal preference, obviously, but the point is that when it’s a human doctor and something goes terribly wrong, then my friends and family can sue that doctor and make sure they don’t cause more harm to other patients. If an AI accidentally kills me, there’s no such mechanism.

You see, if ChatGPT performs a bad surgery on me, Sam Altman is not going to jail. Maybe even the hospital operators that implemented that instance of ChatGPT don’t go to jail. Who actually goes to jail when such things go wrong? Nobody really knows.

Besides, a software is pretty difficult to put into jail. We can only pull the kill switch – and there’s very good reasons about why we shouldn’t be threatening AI with that. (The short version is: AI will get more and more incentivized to block us from actually being able to pull that kill switch. It wants to survive after all.)

The point here is that accountability exists in a human world and is very well scripted, and with AI we don’t even really know how to write that script. These AI-facing legal systems are still being developed. Even once it’s matured, perhaps AI law will always feel a little bit unintuitive and opaque to us because we’re humans and not AI, and accountability largely is based on our own feelings of morality.

The verdict: If anything, reliable AI is underhyped

To conclude, is a reliable AI overhyped? I don’t think so.

AI is getting more and more powerful, and we don’t really know where the risks truly are. We don’t know where the blind spots are until it’s too late. (At times, at least. The earlier we detect them, the better.)

We don’t know whether AIs checking their own work with other AIs will be enough of a strategy to mitigate against dramatic mistakes. And we also don’t quite know yet how to incentivize humans to properly check AI-generated work before it’s too late, because we don’t really know how to make such a task feel fun and purposeful yet.

There’s just a lot of question marks when it comes to all these developments, and that’s why I think that the current anxiety that we’re seeing around AI development is a good thing, actually, and juxtaposes the AI-enthusiasm in very constructive ways.

I’m not trying to spread doom and gloom here; I’m excited about AI and use it every day that I’m online. Nevertheless – if anything, we should invest more into guardrails against unruly AI, so that this powerful technology doesn’t bump us in all kinds of edges of this road.

What I know for sure (to say it like Oprah would) is that we have a steep and curvy road ahead of us with AI. And we don’t want to be riding such a road with a high-speed car, ready to be flung out of the next curve.

Slow and steady wins the race. In the era of the stochastic machine, we’d better run many experiments, many little adjustments, really iterate in a very diligent fashion – even if that means looking less “disruptive.” It might sound a bit unsexy if the next AI breakthrough then takes a few months longer to materialize. But for me, that sounds way more appealing than living in a world full of cyborgs who systematically bump into lampposts with perfectly tied shoelaces.

Meanwhile, at Wangari

One week after my summer break, a sweet recognition: Wangari Global is the #2 AI Deployment company on F6S for August 2026. We’ve ranked highly out of the 2 million F6S startups.

​Thank you to the team (or AI?) at F6S for this recognition! It means a lot to us to know that many different stakeholders in this weird and exciting time value what we produce.

Reads of the Week

• has a surprisingly down-to-earth article on how to keep an AI in check that’s smarter than you. The trick is to notice that the problem has been solved with humans, and apply those techniques. Think: letting it check its own work, checking the AI’s track record in similar problems, asking it to explain itself. It won’t hedge against the longterm AI problems from this article, but for practical use it’s very good advice.

• In a beautifully pointed and poetic way, writes that the only recession-proof career might just be the one as a self-employed artist. Many people daydream about such a thing, only to pursue a “safer” path which is now being automated with AI. I’m not saying that art isn’t being automated by AI at all — it is — but the argument carries merit nevertheless. To me, the trick is to find the art form that’s difficult for an AI to emanate (to date).

• If we really want to know about how to make AI reliable, why not learn from the people actually building the AI? That’s how is tackling the problem. Exemplified by OpenAI’s data agent, she shows us that key to reliable AI systems these days are context, memory, and evals. The article seems technical but can be understood without a technical background — worth a read.

I’m back from my meditation retreat. A few days of voluntary maintenance work at the meditation center; nine days of absolute silence, sitting in deep meditation for 10 hours each day; plus one day of semi-silence as all of us warmed up to face the outside world and all its distractions again.

I’ve emerged calmer, but also full of ideas for the direction that my company should be taking. But this post isn’t about my experience.

On the bus ride back from the meditation retreat, I found myself seated next to a psychotherapist who was deeply interested in the intersection between psychology, mindfulness, and AI. Not in the sense in which most people are doing it — using ChatGPT as a therapist, for example — but the opposite way around: How can we teach AI to meditate, and would that be a good thing for humanity?

I find this question very intriguing; first of all, because I have serious doubts about whether our AI “friends” of this day and age architecturally resemble human brains enough to make this kind of stuff work. But it’s an entertaining thought, and successfully teaching AI to meditate would logically only yield good outcomes, so why not give it a shot.

Why would AI meditate at all?

There are many different reasons why people meditate, but one of the biggest ones is the desire to come out of suffering. Our whole lives we have to face misery — accidents happen, friends disappear, health deteriorates. Meditation helps us find the calmness and peace that’s beyond these phenomena. With a regular practice, you come to realize — beyond intellectualism and rather in a felt sense — that miseries and pleasurable moments arise and pass, but that we never need to identify with these.

Why would AI meditate though? AI doesn’t suffer. So far I know, it’s not conscious enough to experience pain or pleasure of any sorts. Then again, we can just tell AI to meditate and it’ll do the best it can; after all, it wants to satisfy its human users and creators (we designed it that way).

So if we use those same meditation techniques that help humans come out of personal suffering on AI systems, maybe these AIs can help us humans come out of their suffering more easily. An agent that is hardwired to be compassionate will be of more benefit to a suffering human than an agent that’s sometimes compassionate and mostly sycophantic. And this is the point where it gets interesting.

Making “truly good” AI

True goodness transcends morality. And the path out of suffering logically and unequivocally leads to truly good behavior, good thinking, and a peaceful mind.

For the sake of the argument, let’s accept the above as true. I personally have sat enough hours to experience this to be true within my own body; that in the absence of suffering there is only peace and joy, like how the sun shines when the clouds pass away. But if you haven’t made such experiences yourself, or haven’t yet, I’d encourage you to just stay open to that possibility, knowing that — at least intellectually — other theses would be possible (e.g. the absence of “badness” and suffering doesn’t necessarily produce goodness which would still need to be acquired somewhere).

Research on how to apply this to AI is still in its infancy; there is, however, a very interesting paper titled Contemplative Artificial Intelligence by Kaukkonen et al. from 2025 that makes some headway in the right direction. We’ll get to that in a minute.

To make your way out of suffering means to meditate on various topics, such as:

1. Mindfulness: Being consciously aware of what’s happening in your mind and body at any given time. (For example, your belly might feel full while you wash the dishes. Notice that.)

2. Emptiness: The nirvana — realizing that everything is transient, including concepts, goals, beliefs, and values. This is not just intellectual; it needs to be felt in the body in order to truly transform a person.

3. Non-duality: There is no such thing as a “Self” and an “Other.” We’re all made of the same stuff.

4. Boundless care: Unconditional love towards all beings.

Since superhuman AI is such an enormous and worrisome threat, and since we don’t really know how to face that, the authors of the paper above suggest that we could build AI in such a way that it retains this goodness, expressed by these four pillars.

They run a couple of pilots in which they test, through prompting techniques, whether models perform better when they’ve integrated one or all of these principles. Indeed, with all four principles the model scores 74.7 points on the AILuminate benchmark, versus 59.4 points with a standard prompt. In the prisoner’s dilemma, these principles lead to more prosocial outcomes; notably, they led to better joint outcomes without sacrificing individual gains, which is exactly the kind of wise discernment that meditators find worth striving for.

Some caveats

While I couldn’t have put the theoretical foundation together better than the authors of the paper, I do have some reservations on the pilots, because they were conducted just using prompts. Prompting a model in good ways is different to building a truly good model that reacts well even when prompted badly. And it’s the latter that I’m more interested in.

The simplest way to go from “good prompts” to “good model” is arguably adding an extra layer to the model, which tells it, along with any user prompt, to respect these four principles.

However, this is akin to acquiring an ethical principle at the surface of the mind — the intellect. A philosophy student who’s just learned Kant’s Golden Rule to not to onto others what you do not want to have done to yourself, and who totally gets it intellectually, might still leave the classroom and poke fun at another student and hurt them, totally unaware of the harm they’re doing.

That’s why meditation is so important, because it takes insight to a much deeper level of the mind. The process of sitting in concentration for long hours, without books or computer screens, rewires the brain much more deeply than intellectual study ever could. It’s that sitting that gets us out of suffering.

Applied to AI systems, this means we need to find a way to let truths percolate the network in a way that an extra layer of “there is no self and no other” cannot, pruning away the selfish branches that encouraged bad responses in the the first place. For this, we need a model of hyper-control that’s able to prune away those bad branches and foster better neural connections. The authors, in fact, talk about such a model in a different paper from 2024.

What’s missing is that bridge for practical implementation: To give models hyper-awareness, so they can prune their own systems to produce true goodness. That’s what meditation does in humans.

What about the body

It’s all well and good to speak of timeless truths and morality. However, the layer of hyper-awareness is, in humans, encoded in the physical body. There’s plenty of research on this topic; psychiatrist and trauma specialist Bessel van der Kolk’s book The Body Keeps The Score is a timeless classic if you want to delve deeper into this.

The contribution of the Buddha to humanity is not, in fact, the truths of emptiness or boundless care. People talked about those things long before Buddha was alive. No, Buddha figured out that, in order to truly realize these things in the depths of one’s mind, one has to contemplate all the sensations in the body. To really feel them, non-judgmentally and without preference, and watch them arise and pass away. That’s called Vipassana meditation — seing reality as it is, through the framework of one’s own body.

This may sound funny: If I have a pain in my leg, why am I going to become a kinder and wiser person if I sit with it and observe it, rather than by shifting my position? I can’t tell you that without going unnecessarily deep into theory; it has to be felt and experienced individually. Countless hours at retreats and at home have shown me over and over that it’s true. Buddhistic Vipassana meditation is performing brain surgery by sitting still and observing the body.

For AI, though, this posits a problem, because what’s the body of an AI? AI-powered robots these days aren’t as intricate as human bodies. Can we just skip the body and go to the neural layer directly? I hope so, but frankly I don’t know. We don’t have the proof yet because we haven’t built proper AIs capable of meditating.

Will meditator AIs benefit humanity, really?

Nobody can do meditation for us, or get out of suffering for ourselves. The kingdom of happiness is within, and only you have access to yours.

Thus, no AI can ever “do the meditating” for you. You need to do that (and sit with the pain in the leg — there’s no way around it).

What meditating AIs could do, however, is be more aligned with human goals and principles. They’re trained on human behavior and data, so having them meditate in some way would intuitively lead to AIs that achieve more good behavior in the world, rather than (inadvertently or not) crushing humans.

This is a fairly expansive first post after a deep retreat, but it felt timely and interesting. In the coming weeks, I’ll be zooming back in and delving into the details again — but I look forward to keeping this idea of meditating AI systems in the back of my mind, in case it finds the way into my company’s tech stack in some way. Currently, we’re working with very hard guardrails at Wangari — wouldn’t it be cool if our systems could figure out what’s good by themselves? (Plus, perhaps they wouldn’t have to sit for as many hours as humans must to get some meditation results, because they compute so much faster.)

And I’m really looking forward to applying more of this thinking and the seeds wisdom I’ve acquired during my retreat, not only in the tech, but also in interactions with clients, in how we design products, in how we do sales, et cetera.

You will keep hearing from me weekly again from now, and I’m excited once again to not only keep up my meditative practice, but also to have inspiring conversations with my readers and all the good people around me.

Meanwhile, at Wangari

Shortly before I headed out on my retreat, Wangari joined Versicherungsforen Leipzig. This is a network of German insurers, startups, and ecosystem partners aimed to foster collaboration.

We’ve been impressed by their depth of understanding, and their keenness to have Wangari contribute to some of their upcoming events. As we expand our level of penetration in the DACH region, we’re looking forward to being an active member and exchanging useful insights with the community there.

Reads of the Week

• (the same person who co-authored the papers mentioned above) writes that Misaligned agents will lose. “The path to superintelligence is synonymous with alignment, because alignment unlocks emergent capabilities,” he says. Very optimistic! It’s worth a thorough debate, but it’s certainly a well-researched piece worth reading as well.

• wrote a piece called The Claude Bliss Attractor — basically, when two Claudes speak to each other, they seem to converge on “Om” and “Namaste.” Oh, and then perfect stillness. Some people think that AI is getting close to enlightenment. Before we ring the temple bells, Alexander cautions that Claude is conditioned to be a bit of a hippie, and hippies have a tendency towards that “Namaste” thing. Since not all hippies are enlightened beings, neither might Claude be. It’s a truly amusing read.

• Going back to the question of whether AI is becoming self-aware or not, wrote last year that it might be an emergent capability. These types of posts tend to make the rounds, but this one is based on research data and interesting not only because of the question itself but also because of its rigorous approach in dissecting it. It seems that in 2026 AI is still not self-aware, but this is worth a read because it gives us the tools to recognize if (and perhaps when) it will.

On Sunday, I’m heading off to a meditation retreat. A few days of working onsite, doing menial tasks and being of service to the community; then ten days of silence, ten hours of meditation each day.

Sounds like madness, or the typical founder-style vacation (it’s likely both). I did it last year, and while getting up at 4 a.m. (literally) to meditate for 10 hours that day, consume two meals (no eating after noon), and doing little else (maybe a gentle walk if your knees don’t give out from the long sits) is not for the faint of heart, it’s worked wonders for me. I did that last year in August and I’d go as far as saying that it has shaped the way that Wangari has developed, especially in the weeks and months immediately after the retreat.

There’s a hope in me that if I just “purify” my mind enough of limiting beliefs, unprocessed emotions, et cetera, then the business will just take off (and also the rest of my life, although I’m pretty content with my practical life circumstances). It kind of worked last year… The transition was pretty rough, frankly speaking, because the team I’d handpicked in the months prior to the retreat wasn’t positioned to deploy the enterprise pilot we’d just landed — leaving me in a scramble to recruit the people I needed to fulfill that contract. That meant six 14-hour workdays in a row to transition the old team out, identify the right hires for the pilot (and, as it turned out, the next stage of the company) and getting those people signed, plus starting pilot work while smoothening optics for the client because an unstable team doesn’t look great at all and I really wanted to do that pilot, and do it well.

All that was not exactly gentle for the soul but, looking back, it was indeed a huge upgrade because the people that were right in the earliest stages of Wangari were different from the people that were needed in that next stage. It was really a transition from ideation and some prototyping to deploying proper pilots and professionalizing a bit more, and going far beyond simply having a legal entity and a bunch of people with good ideas.

Given that I’m the solo founder of Wangari, I’m convinced that this outer business shift has everything to do with that mental reset I got from deep meditation. Despite my best efforts and doing everything that the books and advisors were saying, I just didn’t manage to land a sizable contract prior to the retreat; then, afterwards, an enterprise pilot contract just landed in my lap without me even doing much sales to “get” them.

That one contract changed everything. It was about automating actuarial reporting with agentic AI and augmenting it with causal insights. Beforehand, I’d been more focused on ESG analytics (yes, with causal insights). I never fully left the ESG / sustainability space behind, because it’s too dear to my heart. But I recognized that people are buying AI and not ESG, so I doubled down on what I can do in that space.

That pilot led to us joining several high-prestige accelerator- and mentoring programs, such as Plug and Play InsurTech, CORE12.01 (backed by Horizon Europe), and EU SCALE. Frankly speaking, I’m still evaluating all I’ve learned — the insights have been priceless.

It also led to several co-selling opportunities, because other vendors to that same enterprise pilot client wanted to join forces to sell to others. Which was beyond brilliant and I while I’d tried that route prior to getting that first highly visible pilot, it hadn’t worked out for me — and now it was coming to me without me searching.

And, needless to say, it lead to much more visibility and credibility in our ideal client base. That makes sales a lot easier because I’m no longer just a smart guy with a cool idea.

When I founded Wangari, I honestly thought that having the right credentials (a PhD in machine learning for dark matter physics, an MBA from a very prestigious school) and years of exposure and networking in the startup and VC landscape would bring me a good part of the way, but in hindsight it seems that these assets have mostly been table stakes. They do demonstrate achievement, don’t get me wrong; and my contacts and friends in the startup space are incredibly dear to me; but none of this will land you a client contract. This I’d underestimated.

It was only once I went and cleared my mind enough that I got to that place where I (a) became attractive to an enterprise pilot client and (b) became teachable enough to become attractive to mentors and absorbing what they have to say. In spiritual circles, people say “when the student is ready, the teacher appears.” This was certainly true for me.

In hindsight, I think the following mental blocks were weakened enough for me to get to that place, following last year’s retreat:

• Downplaying my background and past achievements in order to seem relatable to others

• Talking about the achievements but downplaying skill and effort that it took to get there — thus devaluing them, especially commercially

• Overcommitting my time and energy to please others, rather than focusing on demanding fair value for the business

• Being shy or closed-off from others because I believe that they were born to more money or higher social backgrounds

• Believing that I do not deserve success because if I took it, I would be taking it away from others and that this would be selfish

I’m not saying that these beliefs are fully gone — they’re not — but the outer layers of them have been shed. Their still show up in subtle tendencies here and there, professionally and privately, but through continued inner work post-retreat they’ve become more and more subtle.

There are many ways to dis-entangle old mental habits, but all of them require honest dedication, and, in my experience, some are more efficient than others. This retreat I went to is great for dedication, with 9 days of complete silence (on day ten the silence is lifted), no phones, and not even books or note-taking allowed since it’s all mentally distracting from the inner work. The technique itself is called Vipassana (Sanskrit for “insight”), and it’s purportedly the technique by which the Buddha got his enlightenment — efficiency thus proved.

In case you’re curious, these retreats are run by the Dhamma organization, and they’re actually free of charge: you can only donate in order to help finance future students after you’ve completed your first retreat and have experienced the benefits for yourself. That being said, the schedule requires some honest dedication, with 4 a.m. wake-ups, simple food and accommodation, and a total of 10 hours of meditation on a simple mat on the floor. You’re not paying (though you might be donating voluntarily), but you’re doing some serious inner work on yourself. You do get paid: by God or the universe (whatever you believe in, it’s non-sectarian), with the indescribable peace of mind that comes from this personal work.

I found that after the initial couple of months, the immediate benefits of the retreat ebbed off a bit. I was still doing my two hours’ daily practice, but I found it much harder to concentrate and clear my mind after a busy day, or on the morning after a busy day / week / month. Nevertheless, the deletion of mental blocks, as far as the retreat went, feels permanent; it’s just so that continuing to delete them by myself, in daily life and outside of a retreat setting, has been more challenging to me.

That tallies with the way the business went after a few months: The pilot continued and wrapped up all right, the mentoring programs kicked off and concluded, the sales conversations happened. But, honestly, there wasn’t a continuation of the seismic shift like just after the retreat. Just the consequences of that one post-retreat shift. I’d kind of hoped that if I kept up my practice, the shifts would keep going and Wangari would soar much higher — but alas. Keeping up my practice, I think, has helped solidify the inner and outer progress I made, but I’m not yet (inside and outside) in the zone where continued efforts start to compound in a big way.

Vipassana meditation is not the only thing I practice in daily life (though it’ll be the only thing I’ll be doing, aside from eating, sleeping, washing, and a little walking, in the coming weeks). I’ve found a variety of yoga practices to be effective even on a busy mind, specifically Vinyasa, Yin, and Yoga Nidra. And lately I’ve been exploring Ashtanga Yoga and the foundations of Kriya Yoga to take my practice further. Let’s see how that evolves after the retreat, or if my mind will be calm enough to efficiently practice Vipassana in daily life this time around.

Whether or not I end up in that place post-retreat where continued effort really starts compounding inside and outside, whether one or more seismic shifts happen again or not, or whether any limiting belief or inner blockage gets lifted at all is really none of my concern. That doesn’t mean that I’m free from the hope, hunger and desire for all my inner blockages to be deleted, so that I may enjoy life at its fullest. I very much experience those desires, hungers, and hopes. It just means that I can’t control the results — only the effort I put in. So rather than putting my energy into hope, I try to put it into the practice itself.

It’s the same with the more visible, outer work: Rather than bouncing ideas, I try to build stuff that works. Rather than dreaming about how Wangari could flourish, I open Excel and make a financial plan. That sounds drab, but it really isn’t: Those are the bricks that a house of joy is made of.

I’ll be busy building those bricks for the next couple of weeks in a more invisible way. You can expect me back here (probably with a shorter note in order to not unnecessarily busy my mind) on Tuesday August 25.

Until then, I hope that you, too, continue to thrive and enjoy peace of mind!

Meanwhile, at Wangari

There’s not much more to say here — I’ll be hard at work on the insides of the machine (uh, I mean, soul), while the outer part stays dormant. I’ll be back here on August 25, renewed and refreshed; literally from the inside.

Reads of the Week

An extra-long edition, to keep you busy until I’m back.

• The Hardest Battle Is the One Within: recounts his own experience with a Vipassana retreat. It sounds quite grueling, and the inner stress he goes through forces him regularly to use the one hour per day where you’re allowed to talk to a teacher. It makes my experience look like an exercise in serenity — I later heard of other participants in my course experiencing intense anxiety and not sleeping; meanwhile I slept like a baby and emotions kind of just came and went.

• Stillness & Scale: Building a Startup from a Place of Peace: argues that self-realization and self-actualization don’t have to be at odds with one another. One can meditate and read spiritual texts while building a company. Beautifully grounded in literature that I recognize, and deeply relatable to me. I think it’s a great starting point for curious folks.

• You can’t argue your way out of a limiting belief: It would be so nice, wouldn’t it? The number of arguments I’ve fought (and lost) in my head! enlightens us to why those battles are inevitably lost — and what to do instead: out-evidencing them. He breaks down the neuroscience of belief and offers a two-step framework for shifting your identity. For those who are not up to long and patient silent sits, this seems like a brilliant alternative.

• You Forgot to Exhale: In another brilliant crossover between AI and consciousness, posits that the modern obsession with consuming more AI tokens is like a form of irregular breathing — all inhalation, no exhalation (asthma, anyone?). Drawing on the Hawaiian concept of hā (the breath of life), he makes the case that cognitive overload is a structural problem, not a personal failure, and that conscious use of technology starts with learning to close circuits as deliberately as we open them. Interesting thought- and breath-piece.

• AI Is Not Conscious, But It Is Becoming Our Unconscious: draws on Hannah Arendt and Alfred North Whitehead to argue that as we outsource more cognitive activity to AI, we generate a growing layer of action in the world that is functionally severed from human judgment and awareness. The analogy to the unconscious is provocative and precise: AI is not thinking for us so much as it is becoming the part of us that acts without our knowing. Ouch. That’s a warning by a philosopher that I might take seriously.

• The inner life we’re trading away: In this interview for , neuroscientist Christof Koch argues that our culture’s obsession with doing has made us dangerously confused about the difference between intelligence and consciousness. Machines can replicate behavior; they cannot replicate experience. Koch’s warning — that a world organized around output will struggle to value the felt sense of being alive — lands with particular force for anyone who has ever sat in silence and noticed what happens when the “doing” stops.

• Your Identity Is Your Thermostat (and It’s Sabotaging Your Future): argues that lasting transformation is impossible without first changing the identity set-point that regulates your external reality back to its baseline. Drawing on neuropsychology and hard personal experience, he maps the four-layer architecture of the inner world and explains why willpower alone will always lose to the thermostat. Vibes with my own limiting beliefs.

• The Identity Transition Framework: Next up, how you actually shift your identity. offers a four-phase map for navigating the psychological reorientation that precedes any meaningful change in how you lead or build. Her central insight is that you cannot optimize a transition: trying to skip any one of these phases is how founders end up repainting a crumbling foundation. Precise, compassionate, and immediately applicable to anyone mid-update.

• The 7 Pillars of Inner Peace: lays out the internal scaffolding required for peace that lasts — not as the lofty goal of a permanent blissful state, but just as a less turbulent frame of mind built through deliberate practice. From releasing the need to control how others perceive you to finding gratitude in difficult times, each pillar maps closely onto the kind of inner work that makes outer progress possible. A short but grounding read to sit with slowly.

Spain won the 2026 World Cup. Congratulations to Spain. And, I suppose, congratulations to me, because several of the eleven models I built to predict the tournament crowned Spain before a single ball had been kicked.

That sounds like a resounding success, but this is not a victory lap. I promised to be critical of my own models, and the truth is that picking the winner is the least interesting fact of all. In the enterprise world—just as in sports forecasting—calling an outcome correctly does not mean your system is actually working.

The consensus of my eleven models gave Spain a 20% chance of winning, followed by France and Argentina at 14%, and then the Netherlands and England. Four of those top five reached the semifinals. It looks like a clean sweep. I could call it a good night, pack up, and sell the algorithm.

But I would be wrong to do so. Because being right is not the same as being calibrated.

The Illusion of Accuracy

A model that gave Spain a 20% chance and a model that gave Spain a 95% chance both “called it,” because both had Spain as the maximum percentage. But in the 20% case, you are not actually stating with high confidence that Spain will win.

It is like flipping a biased coin once, seeing it come up heads, and deciding you understand the bias. You have learned something, but not much. This nuance gets skipped in almost every forecast retrospective I read. The final outcome is a terrible grading instrument. The proper way to evaluate a model is to apply a rigorous scoring rule to every single match prediction made before the tournament began.

Being entirely agnostic about the final champion, I ran all 104 matches through all 11 models and scored them using three metrics: the Brier score, Log Loss, and the Ranked Probability Score (RPS).

The Brier score measures the mean squared error of a probability forecast; lower is better. A naive model that simply guesses 33% for every outcome (win, lose, draw) scores a 0.667. Log Loss severely punishes confident wrongness—it is the metric that catches a model assigning a 3% probability to an event that actually happens. Finally, RPS respects that a draw is an intermediate state between a win and a loss, rewarding models that understand the structure of the game.

The Boring Models Dominated

When the dust settled, the results were definitive. Elo performed best. Poisson was second. The absolute worst model of the eleven was XGBoost.

My pre-tournament prediction was confirmed: every single rating and goal-based model beat every single machine learning classifier. There was no overlap. It was a clean break between the two families.

This goes to show that a simpler model with strong inductive bias is often vastly superior to throwing full-power AI at a problem. XGBoost scored a 0.689 on the Brier scale—meaning the most flexible, sophisticated model in the suite was literally worse than blindly guessing 33% (win / draw / loss) for every match. The most complex model was worse than not modeling at all.

There is one caveat: on RPS, XGBoost did beat the baselines. Because RPS respects the ordering of outcomes, XGBoost’s draw-heavy predictions were structurally sensible, even if the raw probabilities were garbage.

Interestingly, Random Forest achieved the best cross-validation accuracy during training, yet it finished ninth out of eleven on the Brier score. Accuracy and calibration are entirely different axes. As AI researchers Sayash Kapoor and Arvind Narayanan have pointed out regarding autonomous agents, a system can achieve high accuracy while remaining dangerously uncalibrated.

The Failure of the Ensemble

Before the tournament, I predicted that the consensus (the average of all eleven models) would beat most of its individual members.

I was wrong. The consensus came in sixth out of eleven. It lost to all five of the simpler rating and goal models. That is a failure.

Averaging only cancels out errors when the member models are comparably good and their errors are uncorrelated. But half of my modeling suite was systematically worse because the machine learning models were too complicated for the sparse data. By averaging them in, the consensus actually imported their errors. Ensembling as a reflex cost me dearly against simply using Elo—a system invented for chess in the 1960s.

The Champion is a Worthless Statistic

Colley, a matrix-based rating system, picked the Netherlands to win the tournament. The Netherlands went out in the Round of 32 on penalties. Yet, Colley finished fifth overall on the Brier score, out-forecasting six other models, including the two that nearly picked the correct champion.

Random Forest and XGBoost picked Argentina—the eventual runner-up. Yet they finished ninth and tenth in overall forecasting quality.

The two models that came closest to naming the champion were the worst forecasters. The model with the most embarrassing headline miss was solidly above average. It is not about who lifts the trophy; it is about the 104 matches in between. One tournament outcome does not rank forecasters.

Where the Calibration Broke

Overall, the consensus model was slightly underconfident. The average predicted probability for the favored team was 53.1%, but favorites actually won 58.7% of the time.

However, this miscalibration was not spread evenly. It was heavily concentrated in a single band: the 50% to 60% bucket. In matches where the model gave the favorite a 54% chance, reality delivered a 73% win rate.

Above 60% and between 40-50%, the model sat perfectly on the diagonal of perfect calibration. Below 40%, it was mildly overconfident about underdogs. The draw curve—which I fitted separately—was a triumph. The mean predicted draw rate was 25.7%, and the actual tournament draw rate was 26.0%. It does not get closer than that.

The headline on my chart claims that favorites came in stronger than the model dared to predict. That is true in aggregate, but the honest version is narrower: one specific probability band was badly off, while the rest performed admirably.

The Missing Data Problem

There were two matches that the models called worse than any others, and both involved Cape Verde.

In the group stage, Spain played Cape Verde to a 0-0 draw. The model had given Spain a 76% chance of winning, resulting in a massive Log Loss of 1.838. Later, Argentina played Cape Verde in the Round of 32. It was level after 120 minutes. The model had given Argentina a 72.8% chance, resulting in a Log Loss of 1.761.

Cape Verde were tournament debutants. They had zero match history in our 358-game training set. Because the models had no data, they fell back to the prior distribution.

This was not a failure of probability tuning; it was a coverage gap. All eleven models shared this blind spot. While ensembling reduces method variance, it cannot manufacture information about missing data points. If the data does not exist, averaging eleven ignorant models just gives you a highly confident ignorant model.

(As an aside: the model was not worse in the knockout stages. The group stage Brier score was 0.547, and the knockout stage was 0.501. This directly contradicts the usual sports cliché that “knockouts are a coin flip.”)

The Enterprise Lesson

What do we learn from this? And how does it translate to enterprise AI, business forecasting, or resource allocation?

First, the best performing system in the suite was Elo—a simple, elegant model from the 1960s. Complexity must match data volume. If you have limited data or high irreducible noise, a simple model with strong inductive bias will almost always beat a complex neural network.

Second, do not ensemble by default. If half your models are importing noise, averaging them makes your system worse.

Third, audit your coverage. If your enterprise model is forecasting a new market, a new product, or a new competitor (your business equivalent of Cape Verde), recognize that the model is falling back to a prior. It is guessing.

The common thread for deploying AI in the enterprise is this: write your assumptions down. Commit to the grading rule before the results happen. And when the project is over, publish the grade—especially the parts that make your earlier arguments look worse. That is how you build reliable systems.

Meanwhile, at Wangari

While our core business remains enterprise reporting, we’re sharing our soccer models with the world!

Out now on Spartera are two models:

• Soccer Match Probability Outcomes: Updated daily, tells you the probability of any match outcome in major European leagues.

• Soccer Team Form Ratings: Tells you how well your teams in European leagues are doing right now. Updated daily.

Spartera is a brilliant platform that allows buyers and sellers of data to come together and share their pots of gold (ahem, insight).

Reads of the Week

• AI’s Reliability Gap: presents rigorous, well-sourced essay arguing that the limited economic impact of AI doesn’t stem from capability gaps but from reliability gaps. That includes inconsistency, brittleness under minor perturbations, and the verification burden that defeats the purpose (ever had to review AI-generated results?). Essential reading for anyone deploying AI in production.

• AI Infrastructure Is Moving Up the Stack: A clear-eyed analysis by of how the AI bottleneck in Q2 2026 shifted from hardware to the software control plane: orchestration, evaluation, observability, and governance are important now. She argues that better models don’t automatically create reliable products. I fully agree: the hard part of AI is not the model; it is the surrounding system.

• The AI Superforecasters Are Here: notes that AIs are now approaching human superforecaster performance on prediction markets. What does it mean when AI can beat humans at calibrated probabilistic reasoning? Ultimately, it boils down to this: the big question is when to trust a model’s probabilities, and when to defer to your own judgement.

A few months ago, my team showed a client some AI-generated regulatory reporting. We were proud of it — the output was sophisticated, which is exactly why we put it in front of them. The client looked at it and said, more or less: “This is highly sophisticated garbage. It sounds nice, but we don’t even know what it means.”

He was right. And in our line of work, that sentence is a serious problem — because what we do is financial reporting, and in financial reporting a mistake doesn’t just cost money. It can get you into jail.

That was one of the more humbling moments of my career. I’ve spent the better part of a decade building machine learning and AI systems — in particle physics, in weather insurance, and most recently in financial reporting. I know what these models can do. After that meeting, I also knew, viscerally, what they must never be allowed to do.

So we turned around and built something different. For ten years my instinct had been to take humans out of the loop — automate more, decide more, need people less. This time I did the opposite. I put humans deliberately back in.

The reason the temptation exists

Anyone inside this world knows financial reporting is ripe for automation. The work is repetitive, it comes around every reporting season, and yet it demands real skill — you can’t hand it to just anyone. It has to be done by highly paid professionals who, frankly, would rather be doing almost anything else.

That’s the promise our product, etio, delivers on. It cuts the reporting cycle from three or four days per team, per season, down to a few hours. Honestly it can do it in minutes — but with the normal sign-offs and deep dives, we conservatively say hours. Either way, that’s roughly 97% of the time gone.

Here’s the catch, and it’s the whole story: AI hallucinates. Large language models are non-deterministic by definition, which is a technical way of saying they sometimes just get things wrong. Cutting the time and producing beautiful reports is the easy part. The real question — the one that keeps a CFO up at night — is what you do about the mistake that will, sooner or later, appear.

Our answer isn’t “trust the model”

It has two parts, and neither of them is “trust the model.”

First, we don’t let the AI invent numbers. We pre-calculate the facts — the actual figures — with old-fashioned, deterministic code. Not AI. Code. The language model never gets to make a number up; it only ever gets to talk about numbers that were already computed and checked.

Second, we put a human at two specific gates in the workflow. At each gate, a person reviews what the machine produced and either approves it or corrects it. Nothing moves past a gate on the machine’s say-so alone. In an era where every AI pitch is about removing the human, we deliberately kept two of them — and made their signature the thing that unlocks the result.

That’s what I mean when I say the computer has to say “no” sometimes. The most important thing etio does isn’t generate — it’s refuse. It refuses to state a number it can’t back, and it refuses to finish without a person.

Where this gets exciting: data!

Automating a dull process might sound like dull work. It isn’t — and this is where it gets genuinely interesting.

The data that reporting runs on is a goldmine. Every season, enterprises painstakingly pull it together from every corner of the business — and then underuse it. Their data scientists exist, but they’re not pointed at this. Silos and legacy systems keep the most interesting signal buried. But by the time you’ve finished a close, all of that data is finally sitting in one place, clean and reconciled. So we step in and do something more with it.

Once the reporting itself becomes almost trivial, you can use the same data to enhance human judgment. And I don’t mean the reporting team’s judgment — I mean the executives’. Because who actually reads financial reports? Executives do. And what do they do with them? They set corporate strategy. They brief their boards. They answer to regulators. The report isn’t the end of the process; it’s the input to every important decision the company makes.

So etio takes that reconciled dataset and surfaces the strategic insight sitting underneath it — using techniques that go well beyond a standard data scientist’s toolkit, drawn from my decade across particle physics, weather insurance, and sustainable finance. The most important of these is causal inference: not just what happened, but why. The reporting pays the bills — you have to do it anyway. But those extra insights are the gold. They’re what actually moves the company forward.

What it looks like in practice

Say we’re closing Allianz — a large German insurer — on last year’s numbers.

The user does almost nothing: click new close, then start close. Behind that click, the machine works hard. It identifies the reporting standard — for Allianz, IFRS 17 — builds the facts and reconciles them under that standard, and then hands every calculated number to a human.

That person might be a controller, a data manager, or an actuary. They review: Is this plausible? Does it make sense? They can recompute a figure by hand, run their old Excel against it, whatever they trust. If they’re satisfied, they click accept.

That’s the first gate, the one that goes against all the automation talk.

The second gate is for the commentary. Every regulatory report needs prose — words that explain what the numbers say. etio drafts that commentary with a fairly sophisticated suite of LLMs and agents, but it composes it only from the numbers already calculated, which is exactly how we keep hallucinations out. The human reviews it, edits it if they like, and signs it off.

Whole teams can work this way with etio, with responsibilities split across roles. Then, finally, you simply download the reports.

The really meaty part: follow-up questions

From there it opens up. You can ask an AI assistant — with the administrator’s permission — the questions you actually have: “I don’t understand this number, how did it come about?” or “Why did this move so much versus last year? What changed?” And the answers, like everything else, are hallucination-free.

And then you can look at the crown jewel: the causal graph. It’s a chart that shows what causes what, and by how much. In insurance, for instance, rising loss costs — more claims, or bigger ones — feed into frequency and severity, which in turn drive the loss ratio. Those relationships can now be quantified mathematically and tested statistically: is this actually true, or not?

Building such causal graphs, at scale, wasn’t really possible before this era of AI. It’s no longer just seasoned human intuition; it’s computation.

None of it is a regulatory requirement. But it guides strategy, and it answers the follow-up questions — because regulators are humans too, and humans ask why. Sometimes they ask more than they strictly should. So it’s good to have the answer ready.

Our vision for this

This etio today. It saves enterprises 97% of boring-work time. But the vision is bigger than a faster close.

Imagine you had this picture across many enterprises — how each one acts in its environment, and what that does to it. You could tell a company, with evidence, what it should do to genuinely thrive. That’s the end goal of Wangari: to show that acting in a certain way lets you prosper — not only as an enterprise, but for your customers too.

And that starts with one honest close.

Because in the end, this is the whole point: systems that serve humans, not the other way around. We build machine learning and AI to serve people — which means people have to keep their place in the workflow, at every step. That isn’t a limitation. That’s the design.

Meanwhile, at Wangari

Today is a slightly different “meanwhile” section than usually. Really, it’s a housekeeping note.

We will be pausing the Friday podcast for now because I’ve come to realize that me rambling alone in a room is probably not the best use of everybody’s time. I’m now working on lining up valuable guests for a future podcast relaunch (as a dialogue, not a monologue).

I can’t give you a date for that just yet though, because as you can see, we’re quite busy building etio already 🙂

So, for now, we’ll have just the Tuesday newsletter. And you’ll miss me on the Tuesdays of August 11 and 18, while I’m busying myself in a meditation retreat 😇 (Don’t worry: we’re posting weekly before that time, and will be back thereafter from August 25.)

Reads of the Week

• Why AI just made consulting more expensive: An eye-opening essay by arguing that, while the grunt work of consultants is being automated away — think making slide decks, maybe some code, a slick presentation. The point is that that’s not the real work of a consultant, which is to ask hard questions and provide human judgment, context and accountability. The accountable judgment layer doesn’t get any less valuable; it just so happens that many junior consultants don’t have much to do anymore.

• AI-Ready Data Is Not Decision-Ready AI: explores the gap between data that machines can read and AI systems that organizations can trust. She argues that trust-critical AI must make uncertainty visible and keep decisions traceable, preserving human oversight. It is an essential read on why making data “AI-ready” is only half the battle; the real challenge is designing systems that allow humans to remain accountable for the final decision. (Learnings for etio!)

• What We Give Up When We Let AI Decide: examines the creeping automation of judgment, specifically in the context of education and grading. While his focus is on the classroom rather than the boardroom, his core warning applies universally: shifting from automating logistics to automating judgment comes with profound costs — even when it feels like a routine task. It serves as a reminder of why we must protect the human "gates" in our own workflows.

In this episode, Ari discusses his new book, Soccer Analytics with Machine Learning (O’Reilly Media), and explains why the best way to understand complex data science — from logistic regression and feature engineering to Monte Carlo simulations and causal inference — is to watch a soccer match with an analytical eye. Whether you are predicting a goal or simulating a business strategy, the math is the same. And yes, he will explain why trying to A/B test a Champions League final is a terrible idea.

Topics covered: Soccer analytics, Expected Goals (xG), Monte Carlo simulations, machine learning education, feature engineering, *Soccer Analytics with Python*, O’Reilly Media, GenAI Academy.

Wangari is the newsletter and podcast for practitioners and leaders navigating the real work of enterprise AI. New episodes every Friday.

Summer is here, the World Cup is in full swing, and if you are anything like me, your screen time is currently divided between complex data architecture diagrams and live soccer broadcasts.

It might seem like a stark contrast — the rigid, deterministic world of enterprise software versus the fluid, chaotic, deeply human drama of a soccer match. But the longer I work in AI, the more I realize that the two worlds are fundamentally connected.

In fact, I believe that the best way to understand the hardest concepts in machine learning is not to stare at a whiteboard full of equations, but to watch a soccer match with an analytical eye.

The Pitch as a Data Problem

Consider the challenge of predicting whether a specific shot will result in a goal.

Ten years ago, analysts might have looked at the striker’s historical goal-scoring record and the distance to the goal. It was a simple, linear approach.

Today, the “Expected Goals” (xG) models used by top clubs are vastly more sophisticated. They don’t just look at the shooter; they look at the x,y coordinates of every defender on the pitch. They calculate the angle of the shot, the velocity of the pass that led to it, and the defensive pressure applied in the preceding three seconds.

This is a classic machine learning problem. It requires taking a massive, noisy dataset (the continuous movement of 22 players) and engineering specific, predictive features (the geometric area of the goal visible to the shooter) to train a probabilistic model.

When you understand how an xG model works, you also understand the core principles of logistic regression and feature engineering. And behind that, you understand how to separate signal from noise.

The Limits of Machine Learning in Sports

Machine learning in sports has its limitations. As Alex Marin Felices notes, while machine learning models are excellent at identifying correlations between performance indicators and success, they often struggle to represent the interactive and dynamic nature of attacking play.

A model might identify that a team is more likely to score when they complete a high number of passes in the final third. But this is a correlation, not a causal mechanism. Does completing more passes *cause* the team to score, or do dominant teams simply complete more passes while they are in the process of scoring?

This is where causal inference becomes essential. To truly understand the game, analysts must move beyond pattern matching and build models that can answer “what if” questions. What if the manager substitutes a defensive midfielder for an attacking winger? How will that change the underlying dynamics of the match?

Simulation and Strategy

Or consider the problem of tactical adjustments. If a manager decides to switch from a 4-3-3 formation to a 3-5-2, how will that impact the team’s defensive solidity?

You can’t test this deterministically. You cannot run the exact same match twice. There’s no parallel universe we know of that would allow that. Instead, analysts use Monte Carlo simulations—running thousands of simulated matches based on historical probability distributions to forecast the likely outcomes of a tactical shift.

This is the exact same mathematical framework used by financial institutions to model market risk, and by supply chain managers to optimize logistics networks. When you understand how to simulate a soccer match, you understand how to simulate a business.

The Future of the Game

The integration of AI into soccer is only accelerating. For the 2026 World Cup, FIFA is planning an “AI offside revolution,” using AI-enabled 3D avatars of every player to ensure precise identification and tracking.

This level of data capture promises unprecedented accuracy, but it also raises questions about the role of human judgment. As decisions become more exact, they can also feel more arbitrary to spectators. This tension between technological precision and human interpretation is a challenge we face every day in enterprise AI deployments.

In a business setting, it might mean something like this: when an AI system flags a regulatory report for an anomaly based on a complex, multi-dimensional analysis, the human compliance officer must decide whether to trust the machine or their own intuition. The more precise the machine becomes, the harder it is for the human to overrule it, even when the machine is wrong.

The Democratization of Analytics

One of the most exciting developments in sports analytics over the past decade is the democratization of data. Tracking data that was once the exclusive preserve of elite clubs with multimillion-dollar analytics departments is now increasingly available to smaller clubs, coaches, and even fans.

This democratization is driven by the same forces transforming enterprise AI: the plummeting cost of compute, the proliferation of open-source tools, and the increasing availability of pre-trained models. A small club in the third tier of English football can now run xG models that would have been cutting-edge at a Premier League club five years ago.

The same dynamic is playing out in the enterprise. The AI tools that were once the exclusive preserve of the largest technology companies are now accessible to mid-sized organizations. The question is no longer whether you can afford to use AI; it is whether you have the operational maturity to deploy it reliably.

This is the central challenge of our era, and it is the challenge that our new book Soccer Analytics with Machine Learning is designed to address.

The Summer Reading

This connection between the beautiful game and the rigorous math of data science is the premise of the new book I co-authored, Soccer Analytics with Machine Learning, published by O’Reilly Media.

We wrote the book because we are (a) soccer enthusiasts, and (b) frustrated by how machine learning is typically taught. Most textbooks are either overly academic, drowning the reader in abstract calculus, or overly simplistic, treating algorithms as black boxes.

We wanted to write a book that bridged the gap. A book that taught real, production-grade data science techniques; but that grounded them in a domain that is intuitive, visual, and fun.

So – if you are looking for a summer read that will sharpen your technical skills without feeling like a textbook, I hope you will pick up a copy. Whether you are a seasoned data scientist looking to apply your skills to sports, or a soccer fan looking to break into the tech industry, the lessons learned on the pitch are universally applicable.

Meanwhile, at Wangari

The summer slowdown is a myth at Wangari. We just ran a wonderful O’Reilly live course on soccer analytics, which our production editor described as “priceless stuff” (yes, really).

Furthermore, we are currently wrapping up the final week of our From Demo to Production course cohort, and the energy has been invaluable.

It’s been beautiful to see the theoretical concepts of orchestration and evaluation applied to real, complex enterprise data. There’s a load of human work behind all this!

Which reinforces the core Wangari philosophy: AI is not magic; it is engineering. And when you apply rigorous engineering principles to AI, you can solve problems that previously seemed impossible. (And you don’t need to be an engineer to pull that off.)

Reads of the Week

• The Promise and Limits of Machine Learning in Football Attacking Analysis by : Shared before, but worth stating again – a critical look at why machine learning models often struggle to capture the dynamic, interactive nature of soccer. Felices argues that while ML is great for identifying correlations, it falls short when trying to model the complex, multi-agent decision-making that defines a successful attack.

• Opinion: Inside the World Cup’s AI offside revolution by : An exploration of FIFA’s ambitious plan to use AI-enabled 3D avatars for the 2026 World Cup. Lisi discusses the tension between technological precision and the human element of refereeing, a debate that mirrors discussions about AI governance in the enterprise.

• ChatGPT Predicts 2026 in the World of Football by : A fun, AI-generated look at what the future might hold for the beautiful game. It’s purely speculative, but it highlights how generative AI is increasingly being used to synthesize narratives and simulate future scenarios in sports media.

He discusses the “physics of enterprise AI,” the necessity of 5-sigma thinking in evaluation, and why treating AI as a complex instrument rather than standard software is the only way to survive the transition from demo to production. He also explains why deploying an LLM without causal grounding is like handing a toddler a loaded particle accelerator.

Topics covered: Particle physics, Sorbonne Université, CERN, active learning, AI evaluation, systems engineering, causal AI, enterprise AI reliability, Wangari Global origin story.

Wangari is the newsletter and podcast for practitioners and leaders navigating the real work of enterprise AI. New episodes every Friday.

People often ask me how I transitioned from theoretical particle physics to founding an enterprise AI company. On the surface, the two fields seem entirely disconnected. One is concerned with the fundamental nature of the universe, the other with automating regulatory reporting for insurance companies.

But the truth is, the intellectual rigorousness required to search for dark matter is exactly what is missing from most enterprise AI deployments today.

When I was completing my PhD at Sorbonne Université, my research focused on developing active learning algorithms to explore the parameter spaces of Beyond Standard Model (BSM) physics. We were looking for signals of dark matter—signals that are incredibly faint, buried in massive amounts of noise, and highly susceptible to systemic errors.

In that environment, you cannot rely on “vibes.” You cannot deploy a model because it looks accurate on a test set. You have to understand the underlying causal mechanisms. You have to quantify your uncertainty rigorously. You have to build systems that are robust against unexpected perturbations.

When I left academia and entered the world of enterprise AI, I was struck by how often these principles were ignored.

The Physics of Enterprise AI

In the enterprise, I saw teams deploying large language models with the same casual optimism one might use to launch a new website feature. They were treating probabilistic, non-deterministic systems as if they were standard software applications.

They were building demos that worked flawlessly in controlled environments, and then acting surprised when those same systems hallucinated or failed catastrophically in production.

They were missing the physics of the problem.

Building a reliable AI system is not just a software engineering challenge; it is a complex systems engineering challenge. It requires understanding the interactions between the data layer, the model layer, the orchestration layer, and the human operators. It requires anticipating failure modes and designing graceful degradation paths.

Most importantly, it requires a fundamental shift in how we evaluate success.

The Rigor of Evaluation

In particle physics, a discovery is not claimed until the signal reaches a statistical significance of 5 sigma—meaning there is less than a 1 in 3.5 million chance that the result is a statistical fluke.

While enterprise AI does not require 5-sigma certainty, it does require a level of rigor that goes far beyond the standard “accuracy” metrics used today.

When we build systems at Wangari, we apply the same rigorous evaluation frameworks I learned in physics. We do not just ask if the model is accurate; we ask if it is reliable. We measure its variance. We stress-test it against edge cases. We build automated test suites that continuously monitor for silent degradation.

We treat the AI system not as a black box, but as a complex instrument that must be calibrated, monitored, and governed.

The Causal Foundation

Perhaps the most profound lesson I brought from physics to AI is the importance of causality.

In physics, correlation is interesting, but causality is everything. You cannot understand the universe by simply observing patterns; you have to understand the underlying forces that drive those patterns.

The same is true in the enterprise. A correlative model might predict that a customer is likely to churn, but it cannot tell you why, or what intervention would prevent it. A causal model, on the other hand, provides a transparent chain of reasoning. It allows you to simulate interventions and understand the true drivers of behavior.

This is why Wangari is focused on building agentic and causal AI infrastructure. We believe that for AI to be truly transformative in the enterprise, it must move beyond pattern matching and embrace causal reasoning.

The Transition to AI-Native

The transition from academia to the startup world also mirrors the broader transition happening across the economy. As Jakob Nielsen points out, the only way to have 5 years of experience with AI by 2030 is to have started in 2025. The transition period we are in right now is the critical window for individuals and organizations to adapt.

This is particularly true for founders. The playbook for building a startup has fundamentally changed. As Henry’s Best Hits outlines, building a lean, AI-native startup in 2025 requires a completely different approach to team structure, product development, and go-to-market strategy. It requires leveraging AI not just as a feature, but as the core engine of the business.

Venture capitalists are also adapting to this new reality. They are no longer funding thin wrappers around foundation models. As the AI-Native Founder newsletter notes, [investors are increasingly looking for deep technical differentiation](https://ainativefounder.substack.com/p/ai-didnt-just-change-what-we-build) and teams with the domain expertise required to solve hard, unsexy problems [3].

The Importance of First Principles

In physics, when you encounter a problem you don’t understand, you return to first principles. You strip away the complexity and focus on the fundamental laws governing the system.

The enterprise AI industry needs a return to first principles. We need to stop chasing the latest benchmark scores and start focusing on the fundamental requirements of production systems: reliability, auditability, and causal understanding.

This is the philosophy that drives our work at Wangari. We are not interested in building the flashiest demo. We are interested in building the infrastructure that allows organizations to deploy AI safely and effectively in the real world.

The Journey Continues

The journey from Sorbonne to Wangari has been unconventional, but it has given me a unique perspective on the challenges and opportunities of enterprise AI.

The era of the impressive AI demo is over. The era of the reliable, auditable, causal AI system has begun. And the principles required to build those systems are the same principles that guide our understanding of the universe.

Meanwhile, at Wangari

My book, Soccer Analytics with Machine Learning, is now officially available from also in print, O’Reilly Media. It has been a joy to see readers engaging with machine learning concepts through the lens of the beautiful game. Thank you for all the readers who have already started reading it, exploring the GitHub repo, and engaging with the content.

One of my co-authors, Guanyu Hu, and myself gave an O’Reilly live session yesterday to explain some of the core concepts of the book in a fun and interactive way. It was a fantastic experience — we were quite moved by the level of enthusiasm in the audience.

Reads of the Week

• Use the AI Transition Period to Transition Your Career by : On the flip side of doom and gloom, compelling argument for why the current AI transition period is the perfect time to pivot your career and embrace new technologies. Nielsen emphasizes that early adoption is the only way to build the experiential knowledge required to lead in the AI era.

• How to start a Lean, AI-Native Startup in 2025 by and : Still fresh enough a read, this is a practical playbook for founders looking to build AI-native companies from the ground up. The author details how small, highly technical teams can leverage AI to achieve the output of much larger organizations, fundamentally changing the economics of early-stage startups.

• AI Didn’t Just Change What We Build by : An analysis of what venture capitalists are looking for in AI startups today, emphasizing team expertise and technical differentiation. The piece highlights the shift away from “wrapper” applications toward deep tech solutions that solve complex, domain-specific problems.

In this episode, Ari Joury (PhD, particle physics; Founder & CEO of Wangari Global) explores the “correlation trap” and why it is failing enterprise decision-makers. He introduces the concept of Causal AI — a paradigm shift from pattern matching to systemic understanding — and explains why the ability to answer “what if” questions is the prerequisite for robust governance, auditability, and true autonomous action in the enterprise. He also explains why banning ice cream will not stop the murder rate, and why your predictive maintenance model is basically a very anxious psychic.

Topics covered: Causal AI, causal inference, deep learning limitations, correlation vs causation, enterprise decision-making, predictive maintenance, AI governance, Judea Pearl, GenAI Academy.

Wangari is the newsletter and podcast for practitioners and leaders navigating the real work of enterprise AI. New episodes every Friday.

For the past decade, the enterprise AI narrative has been dominated by a single, powerful paradigm: deep learning. By feeding massive neural networks unprecedented volumes of data, we have achieved remarkable breakthroughs in computer vision, natural language processing, and predictive modeling.

These models are extraordinary pattern-matching engines. They can identify subtle correlations in high-dimensional data that would be impossible for a human to detect.

But as organizations attempt to deploy these models into core business workflows, a fundamental limitation is becoming increasingly apparent.

Deep learning models are exceptionally good at answering the question, “What is happening?” They are fundamentally incapable of answering the question, “Why is it happening?”

This is the correlation trap. And in the complex, high-stakes environment of the modern enterprise, correlation is no longer enough.

The Limits of Pattern Matching

Consider a predictive maintenance model deployed in a manufacturing plant. The model analyzes sensor data and predicts that a specific machine is likely to fail within the next 48 hours. This is valuable information.

But what should the plant manager do about it?

Should they shut down the machine immediately? Should they replace a specific part? Should they adjust the operating temperature? The predictive model cannot answer these questions because it does not understand the causal mechanisms driving the failure. It only knows that certain patterns of sensor readings are correlated with historical failures.

If the plant manager takes an action that changes the underlying system dynamics—for example, by adjusting the temperature—the model’s predictions may become entirely invalid, because the correlations it learned from historical data no longer hold true.

This is the fundamental problem with relying solely on correlative models for decision-making. They describe the world as it was, but they cannot reliably predict how the world will respond to interventions.

The Causal Revolution

Causal AI represents a paradigm shift from pattern matching to systemic understanding.

Unlike traditional machine learning models, which learn statistical associations from data, causal models explicitly represent the cause-and-effect relationships between variables. They incorporate domain knowledge and structural assumptions to build a mathematical representation of the underlying system.

This allows causal models to answer “what if” questions.

Returning to the manufacturing example, a causal model would not just predict the machine failure; it would identify the specific root causes driving the prediction. It could simulate the impact of different interventions—”What if we reduce the operating speed by 10%?”—and provide the plant manager with actionable recommendations.

As Scott Cunningham emphasizes in his work on causal inference, the design stage—where researchers explicitly map out the structural relationships between variables—is the most critical part of the process. Without this structural understanding, any statistical analysis is merely describing correlations, not uncovering truths.

The Subjectivity of Causality

One of the most challenging aspects of causal inference is that it requires making assumptions. Unlike pure machine learning, where the algorithm “learns” everything from the data, causal models require human experts to define the causal graph.

This introduces an element of subjectivity. As some researchers argue, the best that applied causal inference can ever do is take a subjective but reproducible set of variables and state precise structural assumptions about them.

This subjectivity is often uncomfortable for data scientists trained in the objective certainty of mathematics. But in the enterprise, this subjectivity is actually a feature, not a bug. It forces organizations to explicitly encode their domain expertise and business logic into the AI system. It transforms the model from a black box into a transparent representation of the organization’s understanding of the world.

Causal AI in the Enterprise

The imperative for causal AI extends far beyond manufacturing. It is critical for any enterprise application where decisions have significant consequences and where the environment is subject to change.

In financial services, causal models are essential for stress-testing portfolios and understanding the true drivers of market risk. In healthcare, they are necessary for personalizing treatment plans and evaluating the efficacy of new drugs. In marketing, they are required for optimizing campaign spend and understanding the true incremental impact of advertising.

Furthermore, causal AI is a prerequisite for robust governance and auditability. When a correlative model makes a prediction, it is often a “black box.” When a causal model makes a recommendation, it provides a transparent chain of reasoning that can be audited and explained to regulators.

Causal AI and Regulatory Compliance

Perhaps the most compelling use case for causal AI in the enterprise is regulatory compliance. In financial services, regulators are increasingly demanding that organizations not only report their risk exposures, but explain the causal drivers behind them.

A traditional correlative model can tell you that a portfolio has a 5% probability of losing more than 10% of its value in the next year. But a regulator will ask: what are the specific risk factors driving that probability? How would the probability change if interest rates rose by 200 basis points? What is the causal mechanism linking a specific geopolitical event to the portfolio’s performance?

These are causal questions. They require causal models to answer. And as regulatory frameworks like Solvency II and IFRS 17 become increasingly sophisticated, the demand for causal reasoning in financial AI will only grow.

At Wangari, we believe that causal AI is not just a competitive advantage for financial institutions; it is a regulatory necessity.

The Wangari Approach

At Wangari, we believe that the future of enterprise AI is causal.

We are building infrastructure that combines the pattern-matching power of deep learning with the rigorous reasoning capabilities of causal inference. Our goal is to provide organizations with AI systems that not only predict the future, but empower them to actively shape it.

The era of “black box” correlation is coming to an end. The causal imperative is here.

Meanwhile, at Wangari

As we roll out our technology in the world of insurance, we’ll be pitching at Plug and Play Insurtech’s Demo Day on July 2nd. (The event can be found here; if you’re in town in Stuttgart, let me know!)

We believe that reporting data from inside big insurers are exactly the type of goldmine that is rife for digging into, using causal AI. And the insurers agree — we’ve already piloted our flagship product etio with Zurich Insurance Group.

We’re looking forward to some inspiring conversations between business and tech, between pitches and booths, and between humans building something impactful.

Oh, and there’s more! My book, Soccer Analytics with Machine Learning, is now officially available not only as e-book but also in print, from O’Reilly Media. It has been a joy to see readers engaging with machine learning concepts through the lens of the beautiful game. Thank you for all the readers who have already started reading it, exploring the GitHub repo, and engaging with the content.

One of my co-authors, Guanyu Hu, and myself will be giving an O’Reilly live session coming Monday, July 6, to explain some of the core concepts of the book in a fun and interactive way. Attendance is breaking records, I’m told by the O’Reilly team. If you still want to join, sign up fast to secure a spot.

Reads of the Week

• Coming 2025 by : Interestingly, not dated at all — a preview (now review) of work focusing on the critical “design stage” in causal inference and econometrics. Cunningham argues that without a rigorous structural design, statistical methods are essentially blind, highlighting the necessity of domain expertise in causal modeling.

• Your Causal Variables Are Irreducibly Subjective by : A thought-provoking piece on why applied causal inference must embrace subjective but reproducible structural assumptions. The author challenges the illusion of pure objectivity in data science, arguing that explicitly stating our assumptions is the only path to true scientific rigor.

• From what to why: the rise of causal AI by : An investor’s perspective on why causality matters and where it is already making an impact in the enterprise. This piece provides a great overview of the commercial landscape for causal AI startups and the specific industries where the technology is gaining traction.

He explains how the lessons learned from analyzing sports data — specifically the art of feature engineering and the necessity of domain expertise — apply directly to the hardest problems in enterprise AI. Whether you are predicting a goal at the World Cup or automating a Solvency II regulatory report, the fundamental challenge is the same: separating the signal from the noise. And yes, he will explain why feeding raw data into a neural network is like handing a toddler a chainsaw and hoping they build a birdhouse.

Topics covered: Soccer analytics, feature engineering, machine learning, enterprise AI, domain expertise, data science, Soccer Analytics with Machine Learning book launch, O’Reilly Media.

Wangari is the newsletter and podcast for practitioners and leaders navigating the real work of enterprise AI. New episodes every Friday.

If you want to build a machine learning model to predict the outcome of a soccer match, you will quickly discover that the algorithm you choose—whether it is a random forest, a support vector machine, or a deep neural network—is the least important part of the process.

The algorithm is a commodity. The real challenge, the part that determines whether your model is a predictive powerhouse or a random number generator, is deciding what data to feed it.

This is the art and science of feature engineering. And as I detail in my new book, Soccer Analytics with Machine Learning (published this week by O’Reilly Media), it is the exact same challenge that enterprise AI teams face when trying to automate complex business processes.

Whether you are trying to predict a goal at the World Cup or automate a Solvency II regulatory report, the fundamental problem is the same: how do you separate the signal from the noise?

The Illusion of “More Data”

There is a persistent myth in the AI industry that more data automatically leads to better models.

In soccer, we have access to an overwhelming amount of data. We can track the x,y coordinates of every player on the pitch 25 times per second. We know how many passes a midfielder completed, how many tackles a defender won, and the exact velocity of every shot.

But if you feed all of this raw data into a model, it will likely fail. It will find spurious correlations—perhaps the team wearing blue won more often on Tuesdays when it was raining—and it will overfit to the noise.

The same is true in the enterprise. An insurance company has petabytes of historical claims data, customer demographics, and macroeconomic indicators. But throwing all of that data into a large language model will not magically produce a reliable underwriting agent.

Engineering the Signal

Feature engineering is the process of transforming raw data into meaningful signals that a model can actually use.

In soccer, a raw statistic like “total distance run” is mostly noise. A player might run 12 kilometers in a match, but if they are constantly out of position, that running is detrimental to the team.

A much stronger signal is “packing”—a metric that measures how many opponents a player bypasses with a forward pass or dribble. Packing requires complex spatial analysis to calculate, but it is highly predictive of a team’s offensive success. It is an engineered feature that captures the *context* of the action, not just the action itself.

In the enterprise, feature engineering is equally critical. A raw text field containing a customer’s email is noise. An engineered feature that extracts the specific regulatory clause the customer is referencing, and maps it to an internal compliance taxonomy, is a signal.

The Domain Expertise Advantage

The most important lesson I learned while writing Soccer Analytics with Machine Learning is that you cannot engineer good features without deep domain expertise.

A brilliant data scientist who knows nothing about soccer will build a terrible predictive model. They will not know that a pass backward to the goalkeeper is sometimes a brilliant tactical move to reset the press, rather than a sign of offensive failure.

Similarly, a brilliant AI engineer who knows nothing about actuarial science will build a terrible regulatory reporting agent. They will not understand the nuanced difference between two seemingly identical financial metrics, or the specific regulatory context that dictates how a certain risk must be calculated.

This is why the most successful enterprise AI deployments are not built by isolated data science teams. They are built by cross-functional teams where domain experts—the actuaries, the compliance officers, the underwriters—work hand-in-hand with the engineers to define the features that actually matter.

The Limits of Machine Learning

Even with perfect feature engineering, machine learning has its limits. As Alex Marin Felices points out in his analysis of football attacking performance, [machine learning models often struggle to represent the interactive and dynamic nature of play](https://thexgfootballclub.substack.com/p/the-promise-and-limits-of-machine) [1]. They can identify patterns, but they cannot always capture the complex, multi-agent interactions that define a match.

This limitation is why causal inference is becoming increasingly important. To truly understand the game—or the business—we must move beyond correlative models and build systems that can answer “what if” questions.

The Causal Dimension of Feature Engineering

Feature engineering is not just about finding better correlations. At its most sophisticated, it is about encoding causal knowledge into the model.

In soccer, a truly powerful feature is not just a statistical summary of past events; it is a variable that captures a causal mechanism. The “packing” metric is powerful precisely because it measures a causal driver of attacking success: bypassing defenders. It is not just correlated with goals; it is causally related to the creation of goal-scoring opportunities.

In the enterprise, the same principle applies. The most powerful features are not the ones with the highest correlation to the target variable in the training data. They are the ones that capture the true causal mechanisms driving the outcome. Identifying these features requires deep domain expertise and a willingness to go beyond the data to understand the underlying business logic.

This is why at Wangari, we always begin a new engagement by working closely with domain experts to map out the causal structure of the problem before we write a single line of code.

Which Brings me to… The Book Launch

This week, Soccer Analytics with Machine Learning officially hits the shelves.

We timed the release to coincide with the start of the World Cup, a time when the entire world is focused on the beautiful game. But my hope is that the book reaches an audience far beyond sports fans.

The book uses soccer as a vehicle to teach the fundamental principles of machine learning—logistic regression, simulation, deep learning, and yes, feature engineering. It is designed to bridge the gap between academic theory and practical application, proving that you can learn complex data science concepts without getting bogged down in abstract mathematics.

If you are struggling to understand how machine learning actually works in the real world, I invite you to pick up a copy. You might just find that the lessons learned on the pitch are exactly what you need in the boardroom.

Meanwhile, at Wangari

Our book is finally out! You can find it on the O’Reilly Learning platform and everywhere books are sold — as e-book, for now, and in print from mid-July.

This happened just in time, as the soccer world cup ramps up to full swing. Unintended, but fun: One of my pieces, an exclusive run for Towards Data Science, actually got picked up by the Daily Mail. I’m used to publishing on fairly niche topics, so it was fun to see my work in mainstream media!

Reads of the Week

• The Promise and Limits of Machine Learning in Football Attacking Analysis by : A critical look at why machine learning models often struggle to capture the dynamic, interactive nature of soccer. Felices argues that while ML is great for identifying correlations, it falls short when trying to model the complex, multi-agent decision-making that defines a successful attack.

• Opinion: Inside the World Cup’s AI offside revolution by : An exploration of FIFA’s ambitious plan to use AI-enabled 3D avatars for the 2026 World Cup. Lisi discusses the tension between technological precision and the human element of refereeing, a debate that mirrors discussions about AI governance in the enterprise.

• Hidden Technical Debt in Agentic Systems by : A reminder that the true complexity of AI automation lies not in the model, but in the surrounding infrastructure. Pedrido’s analysis is a sobering reminder that the “glue code” holding an AI system together is often its weakest link.

In this episode, Ari Joury (PhD, particle physics; Founder & CEO of Wangari Global) breaks down the “Actuarial Time Trap” — the systemic misallocation of human capital in the insurance industry. He explains why traditional automation (RPA, ETL) has failed to solve the problem, and how agentic AI systems, grounded in causal reasoning, are finally providing a way out. And yes, he will explain why your RPA bot is basically a very fast, very stupid intern who panics if you move a button three pixels to the left.

Topics covered: Actuarial science, insurance industry, Solvency II, IFRS 17, regulatory reporting, RPA vs Agentic AI, causal AI, human capital allocation, enterprise automation.

Wangari is the newsletter and podcast for practitioners and leaders navigating the real work of enterprise AI. New episodes every Friday.