• Friction is real and structural. It does not disappear — it reshapes decisions.
• Models remain valid. But without system context, they become incomplete.
• Risk-adjusted metrics can mislead. Structure changes even when metrics look stable.
• Heavy-tail environments amplify friction. Effects become multiplicative, not marginal.
• Admissibility matters. Not every acceptable risk can be executed.
• Diagnostics create clarity. Making friction explicit increases decision confidence.
• Options unlock capacity. Maintaining choice enables selecting the right strategy.

Nothing looked wrong in the model.

And yet, the system behaved differently.

That was the starting point for this piece.

I have been using the SoccerSim Lab as a controlled decision laboratory — a simple way to translate market constraints into portfolio decisions and observe what happens when a measurable edge meets real execution constraints.

What I expected was a cleaner translation from model to portfolio.

What I observed was more uncomfortable:
the edge remained, but the path changed.
The model was not wrong — but the system was more constrained than assumed.

The last mile matters

The first signals came from the last mile.

The optimal unconstrained allocation had to be adjusted to discrete stake sizes imposed by the counterparty. Some positions were simply cancelled. Performance did not disappear, but it emerged more slowly than expected. The P&L still revealed an edge — but the path was different.

This was the first step toward a more augmented view of actuarial work: not just looking at the model, but at the system the model has to survive in.

Friction is not theoretical

What looks like a technical detail in a model is very real in insurance.

Friction shows up in many forms:

• local capital and regulatory constraints
• globally diverging capital models
• underwriting realities such as line sizes, authority limits, and placement constraints

These are not edge cases. They are part of the system. They quietly cancel positions and reshape P&L in the background. They directly affect what can be written, how much, and when.

In the SoccerSim Lab, this becomes visible in a controlled setting:

• small budgets create strong distortion from minimum sizes
• larger budgets soften friction
• but friction remains a function of risk and never fully disappears

Efficient frontiers become distorted.
Sharpe ratios can still look attractive, while probability of total loss becomes real. The underlying system has already shifted.

In heavy-tail business, friction is not marginal

This was the harder part to accept.

I used to think of friction as a second-order effect — something that slightly reduces performance, but does not fundamentally change the outcome, maybe even diversifies away.

That assumption breaks in heavy-tailed and illiquid environments.

There, friction is not additive.
It is multiplicative.
It is systematic.

It interacts with:

• tail events
• timing
• capital lock-in

Losses are fully realized.
Gains are only partially captured.
Capital cannot be redeployed freely.

The result is subtle.

Risk-adjusted metrics can remain stable — while the system becomes less robust. In modern systems, risk-adjusted ratios can mislead. And if the model remains incomplete, concentrations that should normally live inside the model need to be monitored outside it.

Frictions obscure the boundary between what is acceptable — and what is actually admissible.

In practice, friction is often no longer treated as a first-class decision variable

Another uncomfortable realization followed.

We moved from a world where friction was priced to a world where it is assumed away.

Earlier frameworks made these effects explicit. Under Solvency II and IFRS 17, friction is no longer priced as a first-class quantity. At best, traces remain through proxies such as expenses, delayed profit emergence, and non-hedgeable uncertainty. But capital lock-in, deployment constraints, model divergence, and underwriting discreteness are not made explicit as decision variables.

These effects need to be made explicit in decisions.
Otherwise, the consequence is subtle — but structural.

Risk-adjusted metrics still look clean.
Portfolios still appear efficient.
But the boundary shifts.

Not every acceptable risk is an admissible strategy. In my case, both growth and careful review of the risk appetite beyond Sharpe stabilized the strategy — and ultimately compressed the signal.

If friction is not modeled explicitly, you risk remaining blind on one eye. Having an edge is not enough. Examining friction will tell whether growth, diversification, or shaping the market & underwriting discipline is the appropriate strategic option.

That is where the augmented actuary operates — not just on models, but on the system they live in.

If you don’t see friction, look here

A final observation from the SoccerSim Lab.

Friction is not something you “see” in a model.
It is something you recognize in the system.
And it usually shows up indirectly — only then can it be understood.

A few symptoms to look for:

• leakage in P&L
• underwriting diverges from plan
• stable capital optimization, but weak capital generation
• robust risk appetite — on paper
• concentration and risk model out of sync
• surprises in actual capital requirements
• value management becomes ambiguous
• models are not used for strategic options

These are not isolated issues. They are signals.

Signals that friction is present — but not explicitly modeled. And once you see them together, the implication is clear:

You are not optimizing your portfolio.
You are optimizing a simplified version of it.

I ran this diagnostic on my own setup.

Ultimately, it increased confidence in both growth in scale and higher risk appetite. I selected a portfolio where frictions are under control ex ante: the two worlds remain close, the KPIs coexist, and trust increases (see table).

That changed my perspective.

Once friction was made explicit, the decision became more robust — not less. The model did not lose relevance. It gained context, and capital can be deployed with confidence.

Ultimately, higher volume and risk appetite will also improve the financial outcome of the strategy in the long run.

Executive takeaway

The point is not that models fail.

The point is that friction changes the structure of decisions.

In a frictionless world, optimization is clean. In the real world, admissibility matters — risk appetite must hold in practice.

Careful analysis reveals the strategic options: growth, diversification, or shaping the market through market building and underwriting discipline.

What this case changed for me was not the model — but the confidence in the decision once friction had been made explicit.

For once, growth and increased risk appetite remunerate courage in the right place.

Confidence does not come from better models alone. It comes from making the system explicit.

Tags: risk, insurance, reinsurance, portfolio-thinking, decision-labs

• The structure of actuarial work is stable. It already operates across reasoning, modeling, and workflows.
• AI does not add a new layer. It augments each existing layer differently.
• Reasoning becomes hybrid. Judgment is extended, challenged, and made explicit.
• Modeling becomes computer-aided. Models become reusable and continuously applied.
• Workflows become agent-organized. Execution is structured into systems that carry the work.
• The shift is structural. From one-off analysis to persistent, reusable systems.
• Accountability remains human. Augmentation strengthens governance rather than replacing it.

Actuarial work hasn’t changed as much as we think. At its core, it has always operated across three layers:

1. Reasoning — reasoning about uncertainty
2. Modeling — modeling it quantitatively
3. Workflows — embedding it into workflows

What’s changing is not the structure, but how each layer is augmented.

1. Reasoning becomes hybrid
   → thinking is extended, challenged, and made explicit
2. Modeling becomes computer-aided
   → models are not one-off, but continuously applied
3. Workflows become agent-organized
   → execution is structured into systems that carry the work

Not autonomous. But no longer purely manual either.

What this creates is a shift: From work that is performed once to work that is captured, reused, and carried forward. From thinking about doing to thinking about how it should be done.

Where this becomes practical

Across these areas, the question is no longer whether AI can be used —
but how it is embedded into reasoning, modeling, and workflows in a controlled way.

This is the work I focus on: making these layers explicit, connected, and operational — without losing accountability.

This is not theoretical — it shows up in very concrete places:

• Reserving / valuation
  → assumptions, adjustments, and reviews become explicit and repeatable
  → less dependency on individual cycles
• Pricing & underwriting support
  → models become aware of state, trend, cycles, and experience
  → decision logic becomes transparent, reusable and well-timed
• Risk & exposure management
  → scenario thinking becomes repeatable decision workflows
  → capital stays stable while preserving risk awareness
• Reporting & governance
  → validation, accountability, and narratives are embedded
  → visuals and messages compound each reporting cycle

In all cases, the goal is the same: not more models —
but better structured work

The way this is currently realized in practice is through integrating a structured agent framework into my agent factory, providing a consistent way to build, apply, and evolve systems that carry the work.

Executive takeaway

The actuary does not need a new role — the structure of the work is already in place.

What changes is the operating model:

• reasoning becomes hybrid
• modeling becomes computer-aided
• workflows become agent-organized

The result is not faster work, but more durable work:

• decisions improve because reasoning is clearer
• analytics scale because models are reusable
• execution stabilizes because workflows persist

The opportunity is simple:
turn actuarial work from something that is performed into something that continues to work.

I’m happy to discuss how this can be implemented in practice — and where it already starts to create value.

Tags: systems, architecture, governance, ai, applied-ai-systems

Key Messages

• Directional effects matter. They tell you what influences what—a real decision signal.
• Trust is a separate layer. If assumptions fail, your conclusion can look precise while being unreliable.
• Stability is information, not noise. Clustering tells you how sensitive the system currently is.
• Business relevance is direct. Better trust and stability handling lead to safer and more profitable loss and capital decisions—especially in stressed regimes.

Why I reviewed it

I recently helped review a small time-series study on stress and physiology. The purpose was practical and personal: to understand the relationship between a psychological state and a physical stress marker over time. My role was limited and clear. I wasn’t there to redesign the study or to add a new modeling framework. I simply wanted to help within my competence and make sure the conclusions were defensible.

The question sounded simple: does one variable influence the other over time?

What we expected — and what actually happened

The initial hope was that the model would give a clean directional signal. Instead, the first pass produced contradictions:

• In one setup, the direction looked plausible—but the model assumptions behind the test were not met.
• In another setup, the direction disappeared—even though the coefficients looked “confident” in isolation.
• In a third setup, the direction flipped depending on what was included or left out.

This wasn’t a story of “the model is wrong.” It was a story of information loss and trust: the same data can appear to support direction, or not, depending on whether the system dynamics are represented and whether the test assumptions hold.

At that point, the main question changed from “Is there an effect?” to “Can we trust what the model is claiming?”

The hidden issue: the system was not equally stable over time

A simple diagnostic made the situation clearer. When we looked at the size of the errors over time, they did not look random and evenly spread. They came in clusters: calm phases with small swings, stressed phases with large swings, then calm again.

In other words, the system didn’t just have a level. It had a stress state that made it more or less sensitive. That is intuitive in human systems: when someone is calm, small triggers lead to small reactions; when someone is stressed, the same triggers lead to larger reactions. The stability of the system itself has memory, and the sensitivity state persists.

Many classical tests implicitly assume this is not happening. If that assumption is violated, the result can look crisp while the confidence is misleading.

A broader anchor: herding under stress—and the transfer to financial lines

This state-dependent sensitivity is not unique to physiology. Behavioral finance has long described herding: under stress, people react more strongly and start to follow each other’s behavior. Decisions become more synchronized, and volatility comes in waves.

Financial lines insurance has a close analogue. In calm periods, claims behavior can look stable. In stressed environments—economic downturns, litigation waves, or market shocks—defaults, lawsuits, and settlements can rise together. Reactions become aligned across many policies at once. Losses start to cluster.

So the volatility pattern in the study is not a technical nuisance. It is a signal of the system’s current sensitivity, and it has direct relevance for how we interpret directional results.

What we changed (and what we did not)

We did not redesign the model. Modeling a stress state explicitly would have gone beyond the task. But we did make one key move: we relaxed the “equally stable all the time” assumption and used a more robust, data-driven testing approach.

The directional story did not magically become significant. That wasn’t the goal. The goal was to make the inference valid, whichever way the result falls. A significant result from an invalid test or ignored signal is not evidence—it is bias disguised as confidence.

The three layers of value

In the end, the review produced three distinct layers of value.

1) Direction

The model provides a directional signal: what influences what over time. That is real value and often the starting point for decisions.

2) Trust

Assumption checking is not a formality. It is governance. It tells you whether the directional result is decision-grade, or merely “nice to look at.”

3) Stability (future improvement)

Volatility clustering hinted at something deeper: the system behaves differently in calm and stressed phases. If that state is modeled explicitly later, you gain better prediction in all states because you are no longer forcing one sensitivity level onto the entire history.

Business implications: why this matters for losses and capital

This is not just an academic point. In insurance and risk management, we routinely ask directional questions: what drives losses, and what drives capital needs?

Direction is valuable—but direction without trust leads to over-confident actions. Direction without stability awareness often breaks precisely in stressed regimes, when decisions matter most.

The practical implication is simple:

• Safer decisions: you avoid building capital and risk actions on fragile results.
• More profitable decisions: you stop paying for false precision and can deploy risk capacity where it is genuinely rewarded.

Stability awareness doesn’t reduce ambition. It reduces avoidable error.

Executive takeaway

Directional results are useful, but the decision value comes from the next two questions:

• Can we trust the result?
• How sensitive is the system right now?

When you add trust and stability awareness, you don’t just get a model that explains the past. You get one that remains defensible—and useful—when the system moves into a stressed state.

Tags: risk, insurance, exposure-management, capital-management, governance, analytics

• Risk must be taken in the right order. Growth constraints come before allocation decisions.
• Risk capacity is an economic boundary — softer than regulatory capital, but harder than portfolio preferences. It is defined by cash-flow funding, stress survivability, and avoidance of forced liquidation.
• Exposure management creates value only within constraints. Allocation matters only after admissible growth paths are established.
• Fragmentation destroys coherence. When balance-sheet steering and exposure decisions are disconnected, value erodes silently.

Why portfolios fail in practice

Most insurance portfolios do not fail because too much risk was taken.

They fail because risk was taken in the wrong order.

Some portfolios look diversified, yet struggle when inflation accelerates or liquidity tightens.
Others remain solvent for decades, but consume far more capital than their economics justify.

In almost every case, the underlying tension comes down to two questions that are too often blurred:

• How much risk can this system really carry over time?
• And where should that risk be deployed so it creates value rather than fragility?

These questions point to two different kinds of discipline.
They are not substitutes. They are orthogonal.

How much risk can the balance sheet really carry?

Every insurance system has a limit — not just a regulatory one, but an economic one.

Cash flows must be funded.
Assets must survive stress.
Capital must absorb volatility without forcing the wrong decisions at the wrong time.

That problem shows up in balance-sheet steering, i.e. Asset & Liability Management (ALM).

This is where thinking about risk capacity matters: whether asset cash flows can fund liability cash flows, whether financial market stress can be survived, and whether growth paths avoid ruin or forced liquidation. These constraints determine how aggressive the system can be, how much drawdown it can tolerate, and how close to the edge it can operate.

Risk capacity does not arise in isolation. It is the output of a coherent ALM system — one that integrates capital, liquidity, accounting, and funding into a single steering logic. Without this system, risk capacity becomes unstable, stale, or distorted, and exposure decisions lose their economic meaning. Only once the ALM engine defines admissible growth paths does exposure management become a value-creating discipline rather than a defensive one.

Where risk capacity actually creates value

Once risk capacity is understood, a different tension appears — and it is no longer a balance-sheet problem.

It is a portfolio problem.

Given a fixed risk budget:

• Which exposures deserve it?
• Which ones quietly dominate the loss distribution?
• Which ones add value because they diversify and pay for the risk they bring?

This is where exposure management lives — best understood as portfolio thinking applied to capital-relevant risk, not abstract return optimization.

Individual risks are allowed to be ugly.
Portfolios are not.

With risk capacity fixed, the question shifts from how much risk to take to where it should sit in the portfolio.

Why diversification alone is not enough

If exposure decisions were only about reducing risk, the optimal portfolio would be trivial:

• infinite diversification,
• minimal exposure,
• no economic relevance.

Real exposure decisions do the opposite.

They concentrate risk where it is paid for, and avoid it where it is not.

That requires looking at:

• marginal contribution to tail risk,
• interaction effects between exposures,
• value density per unit of scarce risk capacity.

This is why exposure management is uncomfortably close to value management — not because it ignores risk, but because it refuses to ignore where risk actually shows up in the distribution.

Why P&C and Life learned different lessons

Historically, insurance lines evolved under different dominant uncertainties.

Property & Casualty insurance grew around:

• short-term contracts,
• annual repricing,
• event-driven, heavy-tailed losses.

Aggregation was the problem. Exposure discipline matured naturally.

Life insurance grew around:

• long-term guarantees,
• locked-in economics,
• sensitivity to discounting and reinvestment.

Time was the problem. Balance-sheet steering matured naturally.

This split was not cultural. It was structural.

What breaks when one axis is ignored

Trouble starts when one dimension is managed in isolation.

P&C portfolios without strong balance-sheet discipline tend to discover:

• pricing that silently assumes benign inflation,
• liquidity stress after loss years,
• capital erosion driven by timing rather than aggregation.

Aggregation is controlled — but the trajectory is not.

Life portfolios without strong exposure discipline tend to suffer from:

• concentrated guarantees,
• capital locked into low-value risk,
• limited ability to reshape legacy books.

Time is controlled — but risk density remains opaque.

In practice, these failures rarely appear as dramatic breakdowns. They surface gradually — as pricing surprises, unexplained capital strain, or uncomfortable questions that never quite get resolved.

Organizational lens

What makes these failures persistent is rarely a lack of models.
More often, it is a lack of organizational coherence.

Exposure decisions, capital policy, pricing assumptions, and balance-sheet steering typically sit in different parts of the organization, each optimized locally and defended rationally. Aggregation is managed in one place, funding assumptions in another, and capital constraints somewhere else entirely.

The result is not reckless risk-taking, but structural incoherence: a portfolio that makes sense in pieces, yet fails to behave as a system when stress arrives. Each function is locally right — and the portfolio is globally wrong. In practice, insurance risk does not fail along a single dimension.

Across exposures, the question is how risks interact at a point in time.
Across time, the question is how the balance sheet evolves under stress.

Neither can substitute for the other.

What a complete risk system looks like

Exposure discipline without balance-sheet thinking creates hidden fragility.
Balance-sheet discipline without exposure thinking creates hidden capital inefficiency.

The only takeaway that matters

No individual risk needs to be safe.

But the portfolio must be survivable,
and risk capacity must be spent where it earns its keep.

In practice, improving insurance risk performance is less about better models, and more about aligning risk capacity, exposure decisions, and governance into a single, coherent system.

Tags: risk, insurance, alm, exposure-management, portfolio-thinking, capital-management

• Vibe coding optimizes for momentum. It’s powerful for exploration, learning, and prototyping.
• Agentic development optimizes for continuity. It turns work into reusable, owned capability.
• AI sticks when work compounds. If you expect reuse, correctness, or handover, design for structure — not just speed.

This piece grew out of a quieter stretch over the holidays, while reviewing my objectives and noticing which kinds of AI-assisted work actually carried forward — and which quietly reset.

Over the last year, vibe coding has become a popular way to describe working with AI. You prompt, the model responds, the code flows — and momentum feels high. And to be clear: vibe coding works, especially early on.

But after running cloud tools and a fully integrated, agent-oriented setup side by side, one difference kept showing up: vibe coding creates motion, while agentic development creates continuity. This post is about recognizing when each mode helps — and when it quietly starts to fail.

What I mean by vibe coding

Vibe coding is characterized by fast feedback loops, a strong sense of flow, and generalist models that can do a bit of everything. Context is rebuilt each session, and progress is driven by conversation rather than structure.

It’s excellent for exploration, learning, sketching ideas, and scripting or prototyping. In that sense, vibe coding increasingly plays a role similar to what Excel once did for professionals: a flexible, low-friction environment for thinking, exploring, and shaping ideas.

For many knowledge workers, it’s already starting to replace spreadsheets as the first place ideas take shape — essentially Excel plus specification: flexible, expressive, and closer to intent. Most positive first AI experiences live here, and that’s a good thing.

Where vibe coding breaks down

The limitations don’t appear immediately. They surface after repetition.

You notice yourself re-explaining the same architecture, dealing with subtle drift in assumptions, or getting outputs that are “almost right” but hard to trust. Manual steps start to pile up — steps that clearly should be automated.

The work moves, but it doesn’t accumulate.

A quick self-check

If any of these feel familiar, you’re already past pure vibe coding:

• “I already explained this once.”
• “This breaks something subtle.”
• “I don’t quite trust this output.”
• “Future-me won’t understand this.”

These aren’t tooling issues. They’re architecture signals.

What I mean by agentic development

Agentic development is not about autonomous AI. It’s about designing work so it survives contact with time.

In a sense, this wasn’t a surprise. I’ve always been skeptical of productivity gains driven purely by tools — not because tools don’t help, but because their benefits tend to decay unless they’re embedded in systems. Working with AI simply made that pattern visible again, at much higher speed.

That belief has shaped how I work in practice. Over time, it led me away from loosely coupled setups — moving from Spyder and standalone ChatGPT sessions toward an integrated environment built around VS Code, Continue, and local models like Qwen. Not because those tools are inherently better, but because they allow context, structure, and intent to live alongside the work itself.

Crucially, that shift didn’t reduce flexibility — it increased it. When context and artifacts are explicit, changing models, workflows, or levels of automation becomes easier, not harder.

What changes in practice

In practice, agentic development shows up as improved context that is explicit, stored, versioned, and reused. It brings more specificity through agents with clear roles and boundaries, and it encourages using the best model for the job, not simply the biggest one.

Performance and low latency start to matter because they change how you think. Ergonomics improve because the environment adapts to the workflow. Drift is minimized through schemas and constraints, architecture becomes more targeted, and outputs turn into actionable artifacts, not just answers. Most importantly, everything lives in a fully integrated environment, not scattered tools.

This isn’t about replacing the developer. It’s about compounding the developer’s work.

From vibe to agentic is a spectrum — not a switch

I find it useful to think of this as a gradual shift rather than a binary choice. Context moves from ephemeral to explicit, models from generalist to task-specific, drift from tolerated to constrained, and outputs from conversational to artifact-driven. The time horizon stretches from hours to months.

You don’t “graduate” from vibe coding. You move along the spectrum when reuse starts to matter.

A note on ownership and IP

There’s also an ownership aspect to this. When work happens primarily in chat sessions, the boundaries around context, reuse, and intellectual property are blurry by default. In an agentic setup, the opposite is true: prompts, logic, schemas, and outputs live as explicit artifacts alongside the code.

That makes ownership, reuse, and transition clearer — not as a legal statement, but as a practical one. The value isn’t in the model response; it’s in the structure that shapes it.

A simple mental model for compounding work

I find it helpful to think in three layers:

1. Foundation — LLM-integrated workstations that are reproducible, versioned, and deployable.
2. Execution — helpers and workers optimized for speed and ergonomics.
3. Compounding — artifacts, schemas, memory, and reuse that turn work into capability.

Most AI setups focus on the middle layer. AI only sticks when the top layer is designed deliberately.

When to use which

Use vibe coding when you’re exploring a new idea, when speed matters more than correctness, and when the output is meant to stay lightweight.

Switch to agentic development when you’ve rewritten the same prompt twice, when correctness matters downstream, when outputs feed other systems or decisions, or when you’re delegating to future-you.

If you expect reuse, design for compounding.

The takeaway

Vibe coding optimizes for momentum. Agentic development optimizes for continuity. One feels fast; the other stays fast.

The most effective setups use both: vibe coding for exploration, and agentic development for everything that should last. If work doesn’t compound, AI productivity resets every quarter. If it does, AI finally starts to stick.

Seen this way, the shift toward agentic development wasn’t a conversion, but a reinforcement. The hypothesis stayed the same — systems compound, tools decay — AI just made the feedback loop fast enough to act on.

Tags: agents, agentic-pipelines, systems, productivity

• Agents must be real, not demo artifacts. If they only work in private, they are hard to trust.
• Public operation creates accountability. Visibility forces clear boundaries and honest failure.
• Restraint matters more than capability. What an agent does not do defines its quality.
• The homepage agent is an interface, not the system. It makes the architecture visible, not complete.
• The next step is infrastructure, not intelligence. Action, privacy, and independence come before learning.

I hesitated to talk about AI agents. Not because they aren’t powerful, but because too many of them only exist in private prompts, demos, or slide decks. They sound impressive, but you never really see them operate under real conditions — with real users, real ambiguity, and real consequences.

So I made a rule for myself.

If I talk about an agent, it must be real. It must run in public. It must be allowed to fail in public. And it must help me at least as much as it helps others.

“Public” here doesn’t mean public infrastructure. It means public accountability: the agent’s behavior, boundaries, and failures are visible and testable, even if the system itself runs privately. Private agents can still support public interfaces — in fact, they often must. Agents are expected to work quietly and reliably in the background; accountability is about what can be observed, not where the code runs.

That rule isn’t about transparency for its own sake. It’s about credibility. If something only works in private, it’s hard to trust. If it never fails visibly, it’s impossible to learn from. And if it’s built only for others, it tends to drift away from reality very quickly.

When people talk about AI agents, a familiar set of expectations usually comes up: autonomy, context awareness, memory, tool use, the ability to act rather than just respond. Those expectations aren’t wrong. But they’re often discussed abstractly, without saying where they actually show up in a working system — and where they don’t.

Putting an agent on my homepage forced me to answer that question honestly.

In some important ways, the homepage agent clearly behaves like an agent. It has a concrete goal: helping visitors orient themselves in my work and decide what is relevant to them. It reasons over context instead of dumping information, and it makes decisions I don’t micro-prompt — how deep to go, when to summarize, and when to redirect back to me. When a question calls for depth, it hands off the drill-down on topics or posts to a dedicated worker instead of trying to do everything itself. That’s not just conversational polish; it’s goal-directed behavior within a defined scope.

Just as important are the ways it is deliberately constrained. The agent doesn’t invent authority or promise outcomes. It doesn’t compress complex topics into slogans just to be helpful, and it doesn’t “learn” invisibly in the background. Its memory is bounded by design. When it improves, it’s because I change the source — my writing, my structure, my thinking — not because something opaque adjusted itself overnight.

The most obvious gap becomes visible precisely because the agent runs in public: action. Today, it can reason and route, but it can’t yet take decisive steps beyond conversation. No scheduling, no coordination, no external effects. That gap isn’t accidental. It’s a boundary I want to cross explicitly, not by accident.

Making the agent public makes these boundaries impossible to ignore — and that’s exactly the point.

The next step isn’t “more intelligence”, and it isn’t primarily about improving the homepage agent itself. That agent already serves its purpose: it makes the system visible.

What comes next is about the underlying setup. In January, I want to formalize a personal agent and worker framework that runs at home, on my own infrastructure. The focus there is on structure rather than features: enabling decisive, auditable actions via MCPs; keeping sensitive context local for privacy and trust; and designing the system to be independent of any single model or vendor, so it can scale without lock-in. The homepage agent will simply remain one public interface to that system — not its center of gravity.

What I’m deliberately not adding yet is persistent state or autonomous learning. Those are powerful capabilities, and exactly the kind that deserve their own design phase, governance, and scrutiny. I see them as headroom, not omission.

The point isn’t that this agent is advanced. It’s that it’s visible, constrained, and accountable — including to me. That’s why I’m comfortable talking about it in public.

Tags: agents, governance, strategy, precision-ai

• Enterprise intelligence is no longer exclusive. Open-source and LLMs have collapsed the cost and capability gap once dominated by Palantir.
• Licensing and economics shape strategy. Open ecosystems provide sovereignty and adaptability; proprietary ones restrict it.
• Low-code tools promise simplicity but limit depth. Python + LLM + pipelines deliver real capability with low complexity.
• Skills are broadly attainable. Python, SQL, orchestration, lineage and LLMs now form a realistic stack for small teams.
• Small businesses can now build their own operating system. What once required enterprise budgets is now achievable on a single workstation.

For years, Palantir set the benchmark for connected data, modelling, and operational intelligence. I’ve worked with teams that used Palantir-style platforms, and I’ve built modern Python/LLM systems in insurance, finance, sports analytics and medical documentation. From this dual experience one conclusion is clear: what once required Palantir can now be built with open-source tools at a fraction of the cost — with far more strategic control. This shift is driven by open licensing, drastically lower compute costs, and the capability unlocked by LLMs, while low-code platforms still fail to deliver the depth and flexibility they promise.

1. Licenses & Costs: The Strategic Break

The difference between enterprise platforms and open source is primarily about ownership and economics, not features. Open-source components (MIT/Apache) provide:

• sovereignty and no lock-in,
• no proprietary friction around data or models,
• full control over logic, crucial for ALM, risk, medical or analytics IP.

Cost amplifies the shift. Enterprise platforms operate at CHF2,000–CHF8,000 per user/month, whereas a modern Python/LLM intelligence layer typically costs CHF30–CHF150 per user/month. The impact is not just savings — it expands option space: more users, more experimentation, and budget shifted back to modelling instead of licensing. Cost + LLMs have lowered the barrier dramatically.

2. Skills: Why the Discipline Is Now Replicable

Palantir’s real value is the discipline of connecting data → models → decisions → operations. Today, that discipline is replicable with accessible skills:

• Python for modelling and automation
• SQL for business logic
• LLMs for extraction, summarisation and agent workflows
• Airflow/Prefect for reliable pipelines
• Lineage tools for auditability
• Postgres + DuckDB as a compact analytical backbone
• FastAPI for operational services
• Superset/Metabase for dashboards
• GitHub/GitLab for CI/CD

These are standard modern data tools, not specialised vendor-only skills. The barrier to enterprise-grade capability has collapsed.

3. Strategy: Building Your Own Operating System

Having worked with both proprietary and open architectures, the strategic distinction is sharp. Palantir offers:

• fast integration,
• embedded teams,
• governed workflows,
• and a strong opinionated operating model.

Open source offers something different:

• differentiation — your models reflect your worldview,
• replaceability — every layer can evolve independently,
• sovereignty — essential for regulated or sensitive environments,
• compounding internal expertise, not outsourced dependency.

For ALM, reinsurance, pensions, healthcare, or sports analytics this is decisive: your modelling IP is your competitive edge — you cannot outsource your edge.

4. Entry Level: Why Even a Small Team Can Do This

The most dramatic change is how accessible these systems have become. LLMs and open-source tooling have removed the entry barrier entirely. A single engineer can build a functional intelligence layer using:

• Python + SQL,
• Postgres + DuckDB,
• Airflow or Prefect,
• Pandas/dbt,
• FastAPI,
• Superset,
• GitHub,
• local or cloud LLMs (Mistral, LLaMA).

With this, any business can automate:

• reporting, documentation and reconciliation,
• ALM, capital or pricing projections,
• underwriting workflows,
• portfolio and customer analytics,
• sports simulations,
• medical case processing.

I’ve built on setups as small as a single workstation with a mid-range CPU/GPU (and can be leased or owned). This is not big-tech territory — it is hands on data science within reach of small teams. Also, in stanard software you pay for all layers immediately, despite in practice, you can only build one layer at a time. This usually starts with pipelines and data sourcing.

Conclusion: Own Your Operating System

Palantir remains powerful, but the landscape has changed. If you understand data and modelling, you can now build a sovereign, flexible, automated intelligence layer that reflects your business rather than a vendor’s template. With cost no longer a barrier, the strategic question becomes simple: do you want to own your operating system — or rent it?

Tags: systems, architecture, open-source, engineering

• Outcomes differ because systems differ. Success in ALM is not about expert teams, but about whether the organisation operates as an integrated system.
• Fragmentation destroys value silently. Misaligned risk, treasury, capital, pricing, accounting and investment functions create hidden frictional costs and deteriorating capacity.
• ALM is a strategic engine, not a reporting function. When designed intentionally, it coordinates constraints, economics, liquidity and solvency into one steering logic.
• Integrated ALM creates capacity, discipline and clarity. It enables better pricing, more stable earnings, improved growth decisions and transparent risk–return profiles.
• A modern ALM system must be timely, connected and economically grounded. This article outlines how such a system is structured and why it matters.

In my career, I have seen what it takes for deals to succeed, for risks to be absorbed cleanly, for losses to be avoided, for appetite to stay aligned, for growth to build on discipline, for limits to guide decisions, for treasury and capital management to create value, for the investment function to contribute real economic return, for pricing to remain tight, for models to illuminate reality, for capital to be well allocated, for accounting to support true economics, for processes to be timely, and for frameworks to be holistic.
These outcomes are not coincidences. They arise from systems that are designed, connected, and governed for complexity. But across the industry, these systems rarely exist in full. Insurers often rely on fragmented processes and misaligned functions: treasury acting without visibility into liquidity pathways, capital management operating on stale assumptions, investments pursuing return without ALM integration, pricing working with incomplete constraints, and accounting frameworks that distort rather than clarify economic value.

When this happens, insurers experience recurring patterns:

• appetite evaporates without clear cause
• frictional costs accumulate unnoticed
• limits become symbolic rather than binding
• pricing becomes too generous under pressure
• growth stalls despite market opportunity
• profitability erodes long before it appears in P&L

None of this is due to weak teams — the expertise exists everywhere.
The issue is that the system does not reflect the actual risks, frictions, constraints, and interdependencies of modern balance sheets.

This is the heart of ALM.

ALM is not a reporting function. It is the strategic engine that integrates:

• capital
• liquidity
• investment
• treasury
• accounting
• pricing
• market risk

When ALM works, it unlocks capacity, enforces discipline, strengthens pricing, reveals frictional costs, and turns complexity into navigable structure. When it fails, value is destroyed silently — in treasury flows, spread realism, liquidity constraints, reinvestment assumptions, and accounting artefacts. A modern ALM function must therefore be intentional, timely, integrated, explainable, and economically grounded.

That is the journey this article explores: how insurers can build systems that deliver the outcomes we know are possible — and avoid the failures we have all seen.

The ALM System — Overview

ALM must be understood as a connected system, not a department.
The diagram below illustrates this structure in a mobile-friendly format.

Figure: Strategy → ALM Core Engine → Functional Engines → Translators → Outcomes, with feedback loops that refine appetite and constraints.

To clarify the layers shown in the simplified diagram:

• Strategic layer: appetite and constraints
• Core engine: integrated economic, liquidity, capital and accounting views
• Functional pillars: investments, treasury, capital management
• Translators: pricing & accounting as constraint enforcers
• Outcomes: steering, capacity, growth, stability
• Feedback loop: outcomes refine appetite dynamically

Why Systems Win Where Processes Fail

Most insurers do not suffer from lack of intelligence or expertise. They suffer from disconnected systems:

• Treasury decisions that ignore investment flows
• Capital assumptions that lag economic reality
• Pricing frameworks unaware of liquidity constraints
• Investments managed without solvency context
• Accounting volatility shaping decisions more than economics

The ALM system binds these parts into a coherent whole — and coherence is what produces high-quality outcomes.

What a Modern ALM Engine Must Deliver

A functioning ALM system provides:

• Timeliness — decisions based on updated economic, liquidity and solvency conditions
• Integration — one coordinated model of risk, capital, liquidity and accounting
• Explainability — narratives that reconcile numbers with decisions
• Economic grounding — true value creation over accounting artefacts
• Strategic feedback — outcomes that refine appetite dynamically

ALM becomes active steering, not backward reporting.

The Value Case for Integrated ALM

With a modern ALM system, insurers gain:

• visibility of frictional costs
• discipline in pricing
• capital efficiency
• liquidity resilience
• clearer growth decisions
• reduced operational surprises
• transparency in risk and return

Without it, value disappears silently for years through cumulative structural leakage.

Conclusion

ALM is not about producing reports. It is about building systems that create clarity, capacity, and long-term value. Insurers who recognise this shift — and who design ALM as an integrated, feedback-driven engine — position themselves for sustainable profitability and disciplined growth.

Tags: ALM, insurance, capital-management, strategy

Key messages

• Expected league position filters out noise and reveals our real competitive level.
• Probability trajectories show whether the season is stabilising or drifting.
• Squad dashboards explain why results happen and where structural weaknesses lie.
• Predictive modelling improves communication, planning and decision-making across the club.
• xGs are silver, xPs are gold.

1. Expected position — a clearer league table

I use the expected end-of-season position as the first anchor for discussions with coaches, the board, and scouts.

Here, Leipzig stabilises upward while Wolfsburg drifts downward; a reminder that results and underlying performance often diverge. This informs tone, expectations and the urgency of interventions.

2. Probability trajectories — how the season is really unfolding

Trend lines matter more than snapshots.

Wolfsburg’s falling UCL probability and rising relegation risk tell a simple story: the early view and current performance of the squad is diverging, and course-correction becomes a strategic necessity.

I rely on these curves to judge whether we stay on plan or need to adjust.

3. Deep squad view — understanding why results happen

This VfB dashboard illustrates how structural insight replaces guesswork.

Key signals I look for:

• Expected score vs market assessment - my look in the mirror to truly understand external perception
• Squad strengths and weaknesses (attack, defence, home/away profile) - who am I, how strong is my competitor
• Scenario probabilities (Top 6, relegation, mid-table) - am I still on track, to separate the heat of the moment from my management objectives
• Expected-points outlook for the next fixtures - how do I navigate the immediate future
• Final table - move away from 6-points-game now, to truly understand who am I competing with currently

These views align conversations with coaching staff and support decisions on rotation, recruitment and development. The coach can adapt and simulate strategies (squad choice and tactical formation).

4. What predictive intelligence enables

In daily practice, it gives me:

• A neutral, model-based view of squad quality
• Early detection of performance drift
• Better planning for finance, budgeting, contracts, transfers and coaching
• More credible communication with board, owners and supporters

Predictive intelligence doesn’t remove uncertainty — it gives it structure.

Conclusion

Football is chaotic in the short run but structural in the long run. As a sporting director, I use predictive models to understand those structures, anticipate inflection points and make decisions before problems become visible in the table.

The truth is on the pitch — but the future becomes visible in the model.

Tags: sports, analytics, leadership

Key messages

Portfolios win — not individual bets.
The visualisations below highlight the core insights:

• Value is the starting point, not the decision.
• Equal Weight is inefficient; Max Return is overly concentrated.
• Optimised portfolios provide the best balance of return, risk and stability.
• Risk profiles and loss contributions become meaningful only when visualised.

Key metrics from Matchday 12:

1. Value as the entry point

A bet has value when the modelled probability exceeds the implied probability of the market price.
For Matchday 12, seven bets meet this criterion and form the initial opportunity set.

A few points stand out:

• Magnitude varies significantly: from marginal opportunities (EV ≈ 0.02) to strong mispricings such as Hoffenheim–Augsburg (2) with EV ≈ 0.96.
• Value is not a stake signal: it identifies which bets merit further analysis, not how much to allocate.
• The true decision happens on the portfolio level, after diversification and risk are considered.

2. Strategies and the efficient frontier

The following visualisation shows how different strategies behave in the return–risk space:

• Equal Weight: wide, uncontrolled dispersion.
• Min Risk: narrow, well-defined downside limits.
• Max Return: strong return potential but extremely concentrated exposure.
• Optimised λ-portfolios: balanced, risk-aware, and efficient.

The plot conveys more insight than paragraphs of text — it makes efficiency visible.

3. How strategies actually allocate capital

The allocation view illustrates the logic of each strategy:

• Equal Weight distributes capital arbitrarily.
• Min Risk stabilises exposures through diversification.
• Max Return concentrates heavily on the highest EV bet.
• λ-portfolios balance return and diversification in line with risk preferences.

The benefit: misallocations appear visually, not retrospectively.

4. Comparing P&L distributions

The shape of each P&L distribution explains the strategy’s behaviour:

• Equal Weight: broad and unstructured.
• Min Risk: calm, tight, predictable.
• Max Return: volatile with wide swings.
• λ-portfolios: controlled transitions between the extremes.

Interpretation is guided by the chart, not assumptions.

5. Which bet contributes which risk?

Loss contributions show where risk originates:

• Risk becomes attributable to individual bets.
• Dominant loss drivers stand out clearly.
• Portfolio decisions gain transparency and justification.

Risk management becomes explicit instead of conceptual.

Conclusion

Quantitative betting relies on structure, model-driven logic, and visual clarity:

• Value identifies opportunities — not stakes.
• Portfolios replace individual bets.
• Risk becomes visible before it materialises.
• Visualisations carry most of the insight; the text simply provides context.

This approach shifts decision-making from intuition to robust analytical judgement.

Tags: risk, portfolio-thinking, exposure-management, capital-management