Introduction

Over the last year, the discussion around AI and research has become increasingly confused. We jump between olympiad medals, benchmark wins, flashy demos, and vague claims about autonomous science and “fully-automatic end-to-end research pipelines”. Many of these flashy claims do not hold up or do not generalize; and most importantly in my book this should also not be the point. The useful question for me is a different, more practical one:

If I am an actual researcher in, say, Math or ML, how can I use these systems in my daily work?

That is the question our paper tries to (partially) answer and in some sense it is an amalgamation of research efforts, best practices, and approaches that we have collected over the last roughly 1.5 years in the MATH+ project “Agentic AI in Mathematics”, although our learnings go significantly beyond mathematics.

The backdrop is, of course, quite remarkable with several high-profile achievements. Systems such as AlphaGeometry [AG], AlphaProof [AP], AlphaEvolve [AE], and more recently Aletheia [ALET] have pushed AI much further into mathematical reasoning and discovery than most people expected only a short while ago. The picture is broader than just these headline systems and includes AlphaGeometry2 [AG2], Aristotle [ARI], Mathematical Exploration and Discovery at Scale [MEDS], and the autonomous Aletheia follow-up on First Proof [ALET2]. On the benchmark side, there is now a growing ecosystem around research-level evaluation, e.g., First Proof [FP], FrontierMath [FM], and RealMath [RM]. At the same time, there is a parallel line of work around agentic experimentation and end-to-end “scientific” pipelines, such as The AI Scientist [AIS], ScienceAgentBench [SAB], Karpathy’s autoresearch [AR], and, in a somewhat different flavor, FunSearch [FS]. There is also now a small but growing literature on mathematicians and researchers using these systems in practice, e.g., Avigad [AV], Henkel [H], Dobriban [D], Liu et al. [LCP], and Carbone [C].

All of this is very interesting and inspiring, but the main question remains: How do we unlock “AI for research” in a practical way that supports day-to-day research activities? Most researchers do not want to build a giant bespoke¹ discovery system from scratch. They want to know which tools are already useful today, where the actual leverage is, and which guardrails are needed so that the system does not quietly produce nonsense while sounding very confident. Moreover, they need support in open-ended research endeavors and not merely round-trip IMO problems, which have “one correct answer”. In some sense, the core claim of our paper is simple:

NB. I would like to stress one point here, as this is often confused. Neither do we claim nor aim for fully-automatic end-to-end research. On the contrary, we look at the use of AI as augmentation. Not oracle. Not autopilot. Not replacement. A research associate. Moreover, we are interested in AI systems for open-ended research questions rather than benchmark problems.

Refutation and verification

Our approach operationalizes (or better: tries to operationalize) a very old and, in my view, still very fundamental scientific principle: most attempts are wrong. That sounds banal, but AI systems used “straight-up” have the tendency to produce enough wrong things fast enough (i.e., the failure rate went down but the speed went up, so that the inter-arrival rate of blow-ups is roughly constant) that it erodes trust in the system. Moreover, there is a total lack of calibration: the AI typically does not know where it is unsure and where it could be wrong; in an optimal world the system would attach a well-calibrated probability of correctness to its output, but that seems out of reach, at least at the moment. This has real consequences for how one should use these systems. If an agent only writes polished explanations, tidy derivations, or plausible-looking code, then it is mostly helping you produce surface area: it looks good but has little substance. What actually matters in research is the ability to rule out bad ideas, broken proof strategies, buggy implementations, and misleading empirical wins quickly and cleanly: we need conjectures, refutation, and falsifiability, which brings us straight to Popper (see Stanford Encyclopedia of Philosophy entry on Karl Popper [POP]) and his philosophy (see Britannica’s discussion of eliminativism and falsification [FAL]). No worries, we will skip the philosophy discourse today. The key point is that it is not indulgence but naturally induces a working research habit underneath it: propose something, expose it to failure, and only keep it around provisionally if it survives. Now what survives might still be wrong, but much less so, and that is then where the Human-AI Co-Creativity [HP] takes place.

In practice, this means the agent needs tools for both refutation and verification. That can be a numerical sanity check, a brute-force search for a counterexample, a symbolic derivation, a randomized stress test, a Julia script, a Python script, or some small utility wired into a simulator, etc. Today this is more straightforward than ever: tons of very strong, localized package managers, such as bun, npm, uv, cargo, Pkg, that align perfectly with agents in CLIs being able to write small refutation and verification scripts against their own reasoning to harden it. Once the agent can actually run those checks, we are no longer asking it merely to talk about a hypothesis. We are asking it to try to break it.

This makes a fundamental difference and the consistency and correctness of the output changes dramatically. Verification catches arithmetic mistakes, implementation bugs, and overclaimed results. Refutation-oriented checks kill wrong turns early and force the system to document why an idea failed. In my experience, this is exactly where these agents start becoming useful for real research: not when they sound convincing, but when they can help eliminate what is false.

Five levels of AI integration

To put things into perspective, inspired by the taxonomy in [HP], we distinguish five levels of AI integration, starting at zero, “research without AI”, which is still the default mode, probably one of the most robust modes out there, and the all-important baseline.

The key difference from Level 3 is that the agent does not stop after every experiment to ask what to do next. It continues autonomously within a carefully bounded workflow, and the human intervenes periodically for steering, review, and correction. This is exactly the boundary point where “AI as tool” becomes “AI as research associate”.

Figure 1. A useful way to think about the research-associate setup: the agent gets a concrete research question, the relevant tools and data, and the prior work or domain knowledge needed to operate in context.

The actual contribution is the workflow

While the taxonomy is useful, the important part of the paper is the actual workflow. The paper’s main claim is that one does not need a highly specialized custom-built system to get meaningful agentic research behavior. Instead, one can take strong existing CLI agents and wrap them in a disciplined environment:

• persistent instructions
• sandboxed execution
• a structured report
• a live TODO.md
• Git-based experiment tracking
• a set of explicit methodological rules

The result is a system that is much less magical than the hype suggests, but also much more useful in practice. It just works. And it is highly customizable to the research needs of the individual researcher. It is your tool.

The workflow in the paper runs inside a sandboxed container, keeps all progress in inspectable artifacts such as report.tex (which I, for example, often have open simultaneously in VS Code so I can regularly compile the PDF and preview it) and TODO.md, and can scale from a laptop to multi-node Slurm experiments. The longest autonomous session reported in the paper ran for more than 20 hours; we have much longer sessions with repeated calls to downstream tools for subproblems. That sounds dramatic, but the important part is not the wall-clock number. The important part is that the agent keeps a disciplined experimental loop alive over long horizons without silently discarding context, changing metrics, or forgetting what it already tried. I would go one step further: this kind of “external memory” is one of the main reasons long sessions are usable at all. In other words: the secret sauce is not some mystical “agent architecture”. It is mostly methodology (e.g., refutation and verification) and workflow (e.g., persistency); granted, for high-profile applications we do rely on SOTA LLMs (current favorites being Claude Opus 4.6 and GPT-5.4).

Figure 2. The workflow view from the paper: persistent instructions, a CLI agent running inside a sandbox, and an explicit experiment loop with reporting, verification, and Git-based memory.

The commandments

We have encoded the “rules” that guide the systems’ behavior as “ten commandments”, which sounds a bit theatrical but follows the language escalation paradigm to harden rule-following; yes, it does make a difference. The underlying rule-of-thumb is: if a behavior matters, make it explicit. Do not rely on vague hopes like “the model will probably know what I mean”. I will not list all ten in full here and I grouped them by the overarching goal. In the following the term experiment is used broadly, to mean one agentic-loop iteration, e.g., proof attempt, one numerical experiment, one design attempt, etc.

1. Integrity and trust.

The first group is basic research hygiene:

• do not promise work and then quietly skip it
• do not change the evaluation because the original setup looks inconvenient
• do not invent bibliography

This sounds trivial until you actually let these systems run for hours. Then it stops sounding trivial very quickly.

2. Autonomy and efficiency.

The second group is about making the agent actually useful rather than merely interactive:

• finish autonomous work before reporting back
• treat crashes as bugs unless proven otherwise

This addresses one of the most common failure modes: the agent stops too early, asks for permission too often, or mistakes implementation bugs for failed research ideas. “Dangerously skipping all permissions” does not solve your problem here; you need to “unleash” the agent.

3. Scientific rigor.

The third group is the most important “research-specific” one:

• change one variable per experiment
• evaluate in tiers
• bound the best-case improvement before celebrating a heuristic

The “one variable per experiment” rule is particularly powerful. It sounds almost embarrassingly obvious, but it prevents a huge amount of pseudo-progress and conflation of factors. If two things change and the metric improves, you often do not know what actually helped.

The staged evaluation rule is equally important. A fast sanity check is for catching bugs, not for drawing conclusions. This is exactly the kind of thing researchers understand intuitively and agents do not unless told very explicitly.

4. Documentation and reproducibility.

The last group is what makes the whole system robust over long sessions:

• record everything
• verify before claiming

This means that failed experiments go into the report as well, not only the good-looking ones. It also means that a claim is not “explained” into existence but should be stress-tested, checked numerically, or challenged through a verification script whenever possible. Everything not fully “verified” is considered “unverified” and “unproven”.

The three meta-principles behind this go back to our refutation discussion at the beginning:

1. explicit over implicit
2. falsifiable over aspirational
3. failure-driven over theory-driven

“Be rigorous” is not a usable instruction. “Change exactly one variable per experiment” is. Similarly, “failure-driven over theory-driven” ensures that things are constantly stress-tested and hardened, rather than endless proof-attempts over pages where the mistake is in the assumptions or right at the beginning.

Three sample case studies

The paper contains six case studies across ML and mathematics. I will only discuss three here, because they already show most of the pattern; for the others, check the paper. All figures below marked with [sic] are verbatim, unaltered output from the agent.

1. Optimizer exploration for LLM pretraining

The first case study starts from a concrete and very ML-style question. AdamW uses two extra buffers per parameter, while Muon only uses one. The natural question is whether the spare memory budget can be used to make Muon better.

This is exactly the kind of problem where our agentic workflow shines: there is a nontrivial design space, the experiments are expensive, and the researcher mostly wants disciplined exploration rather than one-shot “creativity”. For this case study, the agent ran more than 40 experiments, changing one thing at a time, and discovered two largely independent improvements:

• a normalization before orthogonalization
• weight decay for Muon’s matrix parameters

The combined result is about a 5% improvement in validation perplexity over Muon and about 8% over AdamW at the same memory budget, i.e., basically for free. Even more interestingly, the agent also found a nearly matching zero-overhead variant. This application demonstrates what Level 4 autonomy looks like in a compute-heavy setting: multiple GPUs, long runs, careful ablations, literature checks, and a report that keeps all of this coherent over a session lasting more than 20 hours.

Figure 3. A terminal view from a long-running session. Multiple training jobs, timed checks, and verification tasks stay alive in parallel while the agent keeps an inspectable record of what is running.

Figure 4. [sic] Final validation perplexity for the optimizer exploration case study. Lower is better; the best learned variant improves over both Muon and AdamW at the same memory budget.

2. Weight reconstruction in LLM pruning

The second case study, while still in the LLM space, highlights a different aspect that we encountered quite regularly: serendipity. The original task was to fix a broken pruning-mask idea. The agent eventually concluded that the original approach was mathematically flawed. But instead of just discarding the project and moving on, it analyzed why the approach failed. During that analysis, it observed a strong imbalance in post-layer activation distortion after pruning and proposed a very simple reconstruction step to compensate for it.

The resulting method is almost comically lightweight:

• about 10 lines of code
• less than 1% computational overhead
• no hyperparameter tuning

Yet it reduces perplexity by 18–50% across multiple model scales, architectures, and pruning methods, and captures about 92% of the gain of a least-squares oracle reconstruction.

Figure 5. [sic] The pruning reconstruction idea transfers across model scales. Left: relative improvement versus model size. Right: absolute perplexity comparison against the baseline.

3. Frank-Wolfe lower bounds on uniformly convex sets

The third case study comes from optimization, more precisely (as you might have guessed) from the Frank-Wolfe and conditional gradients domain. The problem is was an open lower-bound question for vanilla Frank-Wolfe on uniformly convex sets. For $p$-uniformly convex sets, an upper bound of $\mathcal{O}(1/T^{p/(p-1)})$ was known due to [KDP21], but no matching lower bound was available in the relevant regime; this became in particular striking after the recent lower bounds for strongly convex sets (see [HDZRSP26] and [GL26]).

The agent first tried to generalize an existing high-dimensional lower-bound construction and failed. Importantly, this failure was documented rather than hidden. It then pivoted to a more direct dynamical analysis of the Frank-Wolfe iterates on $\ell_p$-balls, used numerical exploration to identify the right pattern, and eventually assembled a proof showing a lower bound of

for $p \geq 3$, matching the known upper bound in that regime. This particular application touched on each step of the research loop for mathematics:

1. try a proof strategy
2. fail
3. document the obstruction
4. switch to computation-guided exploration
5. identify structure
6. derive the proof
7. verify numerically along the way
8. verify once more symbolically

Figure 6. [sic] Log-log convergence for the Frank-Wolfe lower-bound case study. The empirical behavior matches the rate suggested by the analysis.

There are three more case studies.

I am not going through the remaining three in detail here, but they are also worth reading:

• GPTQ column ordering in LLM quantization
• multi-variable dual tightening for Boscia and mixed-integer convex optimization
• extremal search for maximal real solutions in $K_7$ power networks

They essentially make the same basic point: the agent is most useful when it can combine implementation, experimentation, proof attempts, verification, and structured reporting inside a single inspectable loop.

Limitations: What this does not solve

Verification remains the central problem. Natural-language proofs still require human inspection; we think of this more as a feature than a bug. Code is easier to check (syntax, types, compile checks, unit tests, integration tests, etc.), but subtle bugs remain dangerous. Citations remain a known weak point; tools such as OpenAlex can help a lot but are not a silver bullet. There are formal verification tools such as Lean 4 available, but in our experience this often does not scale (yet?!) to actual research workflows; in particular when paradigm changes are present (e.g., numerics vs. symbolics vs. computational exploration vs. writing a SAT program as proof). So yes, the researcher still owns final verification (and responsibility).

Novelty is not automatically solved. An agent can search the literature and reduce the burden, but it cannot guarantee novelty. This is especially important now that many groups are exploring similar design spaces with similar tools. The researcher still has to do the serious prior-art work.

Context remains fragile. Long sessions eventually hit context-window limits. This is why the persistent external memory in report.tex and TODO.md matters so much. Without it, the system will forget, repeat itself, or silently lose important information. Nonetheless, this does not fix all cases of context churn. Also, simply more context like Claude Opus 4.6’s 1m token window is not an immediate fix either: the context needs to be actively managed with meaningful information and simply having a larger context window also increases the risk of context pollution. As with (human) researchers, focus and concentration are key.

Cost is real, but often not the main issue. Long frontier-model sessions are not free. But in many Level 4 setups, much of the wall-clock time is actually spent waiting for code, experiments, or training runs, not generating tokens. So the real bottleneck is often compute time and workflow quality, not just API cost.

A couple of final thoughts

My overall view is quite positive. Used in the right way, these systems are already good enough to impact how research is done, potentially opening up new avenues. They are particularly strong on the wide, messy, implementation-heavy part of research: exploring various proof directions, setting up experiments, checking boundary cases, writing and revising code, keeping notes, running ablations, and simply pushing several lines of attack in parallel for much longer than a human would do manually. This is not the same as “fully autonomous science”, but it is absolutely real leverage.

At the same time, I do not believe in unbounded speedups either. Research is not one isolated task; it is a workflow. And workflows obey Amdahl’s law [AL26]. Even if the agent becomes extremely fast at some parts of the loop, the remaining serial parts still cap the total gain: choosing the problem, deciding what actually matters, judging novelty, interpreting ambiguous evidence, and performing final verification. These pieces do not go away just because code generation or argument generation got faster. So no, I do not expect 100x researcher productivity. In many realistic settings the true ceiling is much lower.

Then there is the rework problem, which in practice is at least as important. Every wrong derivation, flaky script, plausible-but-false citation, or misleading empirical win creates a tax that has to be paid later by the researcher. Local speed does not automatically turn into global speed. If the system saves you two hours and then costs you ninety minutes of checking, cleanup, and reinterpretation, the headline gain is mostly fiction. This is one reason why disciplined workflows matter so much: they reduce the rework tax before it compounds.

There is also a more subtle downside risk. If you use the agent to outsource the core thinking, you may get more text, more code, and less understanding. In that sense there is indeed a “thinking tax” if the tool is used lazily [TT26]. But if you use it to harden your own reasoning, by searching for counterexamples, stress-testing claims, implementing verification scripts, and documenting failed attempts, then the system becomes genuinely valuable. That distinction is crucial.

So my expectation is neither “AI changes nothing” nor “AI gives us fully autonomous science”. However, the realistic middle ground is already quite useful: better exploration, broader search, faster implementation, more systematic verification, and the ability to sustain open-ended research loops for longer. Even a fairly mundane 2x on the right parts of research would be enormous over the course of a few years. But to get there, we have to be honest about the downside risks as well: overtrust, cognitive atrophy, workflow bloat, and rework. The researcher remains the one who has to decide what is important and what is worth believing.

References

(for a more complete list, see our paper [ZPRP26] and the references contained therein)

Main paper.

[ZPRP26] Zimmer, M., Pelleriti, N., Roux, C., Pokutta, S.: The Agentic Researcher: A Practical Guide to AI-Assisted Research in Mathematics and Machine Learning (2026)

AI for mathematics and mathematical discovery.

[AG] Trinh, T. et al.: Solving olympiad geometry without human demonstrations (2024)

[AP] Hubert, T. et al.: Olympiad-level formal mathematical reasoning with reinforcement learning (2025)

[AG2] Chervonyi, Y. et al.: Gold-medalist Performance in Solving Olympiad Geometry with AlphaGeometry2 (2025)

[ARI] Achim, T. et al.: Aristotle: IMO-level Automated Theorem Proving (2025)

[AE] Novikov, A. et al.: AlphaEvolve: A coding agent for scientific and algorithmic discovery (2025)

[MEDS] Georgiev, A., Gómez-Serrano, J., Tao, T., Wagner, S.: Mathematical exploration and discovery at scale (2025)

[ALET] Feng, Y. et al.: Towards Autonomous Mathematics Research (2026)

[ALET2] Feng, Y. et al.: Aletheia tackles FirstProof autonomously (2026)

[FP] Abouzaid, M. et al.: First Proof (2026)

[FM] Glazer, D. et al.: FrontierMath: A Benchmark for Evaluating Advanced Mathematical Reasoning in AI (2024)

[RM] Zhang, Y. et al.: RealMath: A Continuous Benchmark for Evaluating Language Models on Research-Level Mathematics (2025)

AI-assisted mathematical research and human-AI collaboration.

[AV] Avigad, J.: Mathematicians in the age of AI (2026)

[H] Henkel, C.: The Mathematician’s Assistant: Integrating AI into Research Practice (2025)

[D] Dobriban, E.: Solving a Research Problem in Mathematical Statistics with AI Assistance (2025)

[LCP] Liu, Z. et al.: AI Mathematician as a Partner in Advancing Mathematical Discovery – A Case Study in Homogenization Theory (2025)

[C] Carbone, A.: Advancing mathematics research with generative AI (2025)

[HP] Haase, J., Pokutta, S.: Human-AI Co-Creativity: Exploring Synergies Across Levels of Creative Collaboration (2024)

Optimization and conditional gradients.

[KDP21] Kerdreux, T., d’Aspremont, A., Pokutta, S.: Projection-Free Optimization on Uniformly Convex Sets. Proceedings of AISTATS (2021)

[HDZRSP26] Halbey, J., Deza, D., Zimmer, M., Roux, C., Stellato, B., Pokutta, S.: Lower Bounds for Frank-Wolfe on Strongly Convex Sets. arXiv preprint arXiv:2602.04378 (2026)

[GL26] Grimmer, B., Liu, N.: Lower Bounds for Linear Minimization Oracle Methods Optimizing over Strongly Convex Sets. arXiv preprint arXiv:2602.22608 (2026)

Agentic workflows and evaluation.

[AIS] Lu, C. et al.: The AI Scientist: Towards Fully Automated Open-Ended Scientific Discovery (2024)

[SAB] Chen, X. et al.: ScienceAgentBench: Toward Rigorous Assessment of Language Agents for Data-Driven Scientific Discovery (2024)

[AR] Karpathy, A.: autoresearch

[FS] Romera-Paredes, B. et al.: Mathematical discoveries from program search with large language models (2023)

Philosophy of science.

[POP] Stanford Encyclopedia of Philosophy: Karl Popper

[FAL] Encyclopaedia Britannica: Philosophy of science - Eliminativism, Falsification, Theory

AI productivity and cognition.

[AL26] just a tourist: The 20x Ceiling: Amdahl’s Law and the Limits of AI Speedup (2026)

[TT26] just a tourist: The Thinking Tax: When AI Tools Cost More Than They Save (2026)

Tools.

[CC] Anthropic: Claude Code overview

[CX] OpenAI: Codex

[OC] Anomaly: OpenCode / The open source coding agent

[GC] Google: Gemini CLI

Footnotes

In 1960, physicist William Newcomb invented a thought experiment so divisive that when Robert Nozick published it in 1969, he noted that “to almost everyone, it is perfectly clear and obvious what should be done. The difficulty is that these people seem to divide almost evenly on the problem, with large numbers thinking that the opposing half is just being silly.”

Sixty-six years later, they still do. The 2020 PhilPapers survey of ~2,000 professional philosophers found 39% favor two-boxing and 31% favor one-boxing, with the rest undecided. Among decision theory specialists, the lean is stronger: 61% two-box, 26% one-box. The general public and the AI alignment community tilt the other way.

The puzzle is simple. You face two boxes. Box A is transparent and holds \$1,000. Box B is opaque and holds either \$1,000,000 or nothing. A highly reliable predictor, right about 99% of the time, has already examined you and made a prediction. If it predicted you’d take only Box B, it put the million in. If it predicted you’d take both, it left Box B empty. The predictor is done. The money is placed. You choose.

The paradox is that two ironclad principles of rational choice give opposite answers. And the real interest isn’t in which answer is right. It’s in why we can’t tell.

The payoff matrix is simple:

Two-boxing strictly dominates: it pays \$1,000 more in every cell. But the predictor ties the column you’re in to the row you choose. Write $M = 1{,}000{,}000$ for the big prize, $K = 1{,}000$ for the small one, and $q = 0.99$ for the predictor’s accuracy. Four frameworks handle this coupling differently:

EDT (Evidential Decision Theory) conditions on the action:

With our numbers:

EDT one-boxes. Your action is evidence about which column you’re in.

CDT (Causal Decision Theory) intervenes on the action:

Since $V(\text{two-box}, s) = V(\text{one-box}, s) + K$ for every box state $s$:

for every prior over the box state. CDT two-boxes. Your action can’t cause the column to change.

FDT (Functional Decision Theory) optimizes over algorithm outputs:

If your algorithm outputs “one-box”, the predictor fills B: payoff $M = 1{,}000{,}000$. If your algorithm outputs “two-box”, the predictor empties B: payoff $K = 1{,}000$. FDT one-boxes. Your algorithm is the column selector.

Regret-based (online learning) asks what kind of adversary the predictor is:

• If oblivious (box contents fixed before you act): swap regret says two-box.
• If adaptive (box contents respond to your policy): policy regret says one-box.

The answer depends on how you classify the predictor.

We will now look at these four frameworks from four different lenses.

Lens 1: Observation vs. Intervention

The cleanest formalization comes from Judea Pearl’s causal framework. Pearl distinguishes between observing that something is the case and intervening to make it the case. In his notation, $P(Y \mid X = x)$ is the probability of $Y$ given that we observe $X = x$. But $P(Y \mid do(X = x))$ is the probability of $Y$ given that we set $X$ to $x$, surgically, from outside the system. These are not the same thing.

In Newcomb’s problem, the underlying causal graph looks like this:

Your disposition $\theta$, the kind of decision-maker you are, is a common cause of both your action and the prediction. This is a classic confounding structure. And the entire paradox lives in one inequality:

The left side is observational. If we observe you one-boxing, that’s strong evidence you’re the kind of person the predictor expected to one-box, so Box B is probably full. This gives:

The right side is interventional. If we intervene on your action, surgically setting it to one-box regardless of your disposition, the arrow from $\theta$ to your action is severed. The intervention carries no information about the prediction. Whatever is in Box B is already there. So taking both boxes gets you an extra \$1,000 regardless:

Evidential decision theory (EDT) uses the left side and says: one-box. Causal decision theory (CDT) uses the right side and says: two-box. Pearl himself sided firmly with the interventionists, arguing that treating actions as mere observations, as EDT does, is precisely what generates the paradox. “The confusion between actions and acts,” he wrote in Causality, “has led to Newcomb’s paradox and other oddities.”

But Pearl’s resolution has a cost. To see this cost, we plot the expected payoff as a function of the predictor’s accuracy $q$:

The crossover is at $q \approx 0.5005$, essentially a coin flip. For any predictor even marginally better than chance, one-boxing yields a higher expected payoff. At $q = 0.99$, one-boxers average \$990,000 while two-boxers average \$11,000. Being “causally rational” makes you poorer. That’s uncomfortable to say the least.

Lens 2: Algorithmic Correlation and Self-Reference

The second lens comes from an unexpected direction: the logic of self-reference.

If the predictor is accurate because it modeled your decision process, say by running a simulation, analyzing your algorithm, or examining a sufficiently detailed model of your brain, then there are two instantiations of your decision-making procedure: the one in your head and the one the predictor evaluated. They aren’t causally connected (the predictor is done), but they are logically connected: they produce the same output because they implement the same function.

This is the insight behind Functional Decision Theory (FDT), proposed by Eliezer Yudkowsky and Nate Soares in 2017. FDT says: don’t ask what your action causes (CDT) or what it provides evidence for (EDT). Ask what the best output of your decision algorithm would be, across all instances where that algorithm is evaluated.

Your algorithm is evaluated in two places: your head (where the output determines your action) and the predictor’s model (where the output determined the prediction). If your algorithm outputs “one-box,” you get \$1,000,000. If it outputs “two-box,” you get \$1,000. FDT one-boxes.

This connects to the Self-Sampling Assumption (SSA) in anthropic reasoning. Bostrom’s SSA says you should reason as if you’re randomly selected from your reference class of observers. In Newcomb’s problem, the analogous move is reasoning as if you’re randomly selected from the set of all instantiations of your algorithm. The predictor’s model of you and the actual you are both running the same code: different instantiations, same function.

The structural parallel is pretty much straightforward:

This framing dissolves the paradox, but at the price of accepting a notion of “logical causation” that most decision theorists find metaphysically suspect. The predictor’s model and your brain don’t share any causal arrows. The correlation comes from mathematical identity, not physical interaction. Whether that should count as a reason to act is itself an open question.

This can be also seen also with a simple monte-carlo style simulation: We initialize a population of 500 agents, each carrying a single parameter: its one-box probability $p \in [0,1]$, drawn uniformly at random. Each generation proceeds in three steps. First, every agent plays 20 rounds of Newcomb’s game against a predictor with accuracy $q$; the agent one-boxes with probability $p$ in each round and its fitness is its average payoff. Second, we form the next generation by sampling 500 agents with replacement, proportional to fitness (roulette-wheel selection). Third, each offspring’s $p$ is perturbed by Gaussian noise with standard deviation 0.03, clipped to $[0,1]$. This is pretty much a textbook evolutionary algorithm: selection amplifies high-payoff strategies, mutation explores nearby variants. The key question is whether the population converges to one-boxing or two-boxing, and how fast.

When the predictor is 70% accurate or better, populations evolve toward near-pure one-boxing within ~20 generations ($p > 0.9$). Even at $q = 0.51$, barely better than a coin, there’s a slow drift upward. Evolution doesn’t care about causal philosophy; it follows the payoff gradient.

Lens 3: Data vs. Counterfactuals

The third lens is the most empirical. Suppose you’re not a philosopher but a statistician. You observe 10,000 people play Newcomb’s game. The data is unambiguous: one-boxers average \$990,000. Two-boxers average \$11,000. The observational conditional $E[\text{payoff} \mid \text{action} = a]$, the average payoff grouped by observed action, overwhelmingly favors one-boxing.

The two-boxer’s defense is a counterfactual: “Those one-boxers would have gotten \$1,001,000 if they had two-boxed.” This claim may be true. But it is unobservable. You never see the same person both one-box and two-box under the same prediction. This is the fundamental problem of causal inference: the impossibility of observing both potential outcomes for the same unit. In fact, the structure is identical to treatment effect estimation, where the same gap between observed and counterfactual outcomes makes naively comparing treated and untreated groups unreliable:

The expected payoffs can be computed in closed form. Plotting them as a function of the predictor’s accuracy makes the gap visible, and shows exactly where it hides:

The top dashed line is the two-boxer’s counterfactual claim: one-boxers would have earned \$1,001,000 if they had grabbed both boxes with the same prediction. That line is real, and invisible. At $q = 0.99$, the gap between the observed one-box payoff (\$990,000) and the counterfactual (\$991,000) is exactly \$1,000. You’d need to observe the same person doing both to see it. You can’t.

If you’re a frequentist who follows the data, you one-box. If you’re a structural modeler who trusts your causal graph over the observed conditional, you two-box. Neither is obviously wrong. They’re optimizing different things: one follows the joint distribution the agent is embedded in, the other follows the causal structure the agent can manipulate.

Lens 4: Oblivious vs. Adaptive Adversaries

The fourth lens comes from online learning and the theory of multi-armed bandits. In this setting, a learner repeatedly chooses actions, and an adversary determines the losses. The central question is: what kind of adversary are you facing?

An oblivious adversary commits to the entire loss sequence before the game begins. It doesn’t see or react to the learner’s actions. Against an oblivious adversary, the natural performance measure is swap regret: “Holding the loss sequence fixed, could I have earned more by switching my action?” If yes, you have regret. The optimal response is straightforward: play the dominant action, since the environment won’t change.

An adaptive adversary observes the learner’s policy (or past behavior) and adjusts losses accordingly. Against an adaptive adversary, swap regret is misleading: the losses would have been different under a different policy. The right measure becomes policy regret: “Would a different policy have produced better outcomes, accounting for how the adversary would have responded to that policy?”

Linking this back to Newcomb’s problem:

CDT treats the predictor as oblivious. The money is placed, the game state is fixed, and two-boxing is the dominant action, exactly the swap-regret argument. The two-boxer says: “Holding Box B fixed, I always get \$1,000 more.”

EDT and FDT treat the predictor as adaptive. The predictor responded to your algorithm, so the box contents are a function of your policy. Switching from a one-box policy to a two-box policy doesn’t just change your action; it changes the adversary’s response. The one-boxer says: “A two-box policy faces an empty Box B.”

The precise role of anticipation, i.e., the adversary’s ability to foresee not just the learner’s policy but also their realization of randomness, has been studied in detail in the online learning setting (see e.g., Pokutta and Xu, 2021, where we looked at this in particular in the context of robust optimization). When the adversary can anticipate the learner’s random coin flips, even randomized strategies lose their hedging value. The Newcomb predictor, with 99% accuracy, sits squarely in this regime: it anticipates not just your policy but your execution.

This reframing is clarifying because the online learning community has precise theorems about when each regret notion applies. Against a truly oblivious adversary, swap regret is tight and achievable. Against an adaptive adversary, minimizing swap regret can be catastrophically wrong; you need policy regret, which accounts for how the environment co-adapts. The entire Newcomb debate reduces to a classification question: is the predictor oblivious or adaptive?

The answer, of course, depends on your ontology. If you believe the box contents are a physical fact determined before your choice (oblivious), CDT follows. If you believe the predictor adapted to your decision algorithm and the contents are therefore policy-dependent (adaptive), one-boxing follows. The bandit framework doesn’t resolve the paradox, but it reveals its skeleton: the same structural ambiguity that separates oblivious from adaptive adversaries in online learning separates two-boxers from one-boxers in Newcomb’s problem.

The Mixed Strategy: Flipping a Coin

The first three lenses assume a deterministic chooser (the bandit lens already allows randomized policies, but there the focus was on regret notions, not on what randomization does to the predictor). So what if you flip a biased coin: one-box with probability $p$, two-box with probability $1-p$?

This breaks the predictor. A predictor that’s 99% accurate against deterministic strategies can’t beat $\max(p, 1-p)$ against a genuinely random (but biased) coin (i.e., private randomness as the boxes have been set up already). The predictor’s best response is simple: predict “one-box” (and fill Box B) if $p \geq 0.5$, predict “two-box” (and leave Box B empty) if $p < 0.5$. Under this best response, the predictor’s effective accuracy is

which hits its minimum of $50\%$ at $p = 0.5$: a fair coin reduces the “99% accurate” predictor to a coin flip. The expected payoff works out to:

This creates a phase transition, a million-dollar cliff:

At $p = 0.49$, the predictor leaves Box B empty and you average \$510. At $p = 0.51$, the predictor fills Box B and you average \$1,000,490. A 2% shift in coin bias produces a \$999,980 jump in expected payoff.

The optimal mixed strategy is $p$ just above $0.5$: one-box slightly more than half the time. This earns approximately \$1,000,500, which beats pure one-boxing (\$1,000,000) by \$500. You get the million (the predictor fills Box B because you’re majority one-box) while occasionally grabbing the extra \$1,000 when the coin lands on two-box; it is a bit like reaping the extra \$1,000 from an occasional counterfactual switch.

But the optimal mixed strategy is fragile in a way that pure one-boxing is not. It depends on the predictor having a sharp threshold at $p = 0.5$ and not being able to anticipate the randomization itself. A predictor that models coin-flipping agents might demand $p > 0.9$ (i.e., the predictor’s stated accuracy also determines which $p$ are admissible) before filling Box B, and then the optimal response shifts to $p$ just above 0.9, recovering less of the two-boxing bonus. In the limit where the predictor demands certainty (i.e., full anticipation of the random outcome of the coin flip), you’re back to pure one-boxing.

In some sense, mixed strategies reveal that Newcomb’s problem is really a game between the chooser and the predictor, and the payoff landscape has the structure of a game-theoretic discontinuity. In particular, the predictor isn’t just a feature of the environment; it’s a player.

The Fixed Point

There’s a final mathematical observation that cuts across all four lenses. The predictor’s accuracy creates a self-referential loop: the prediction depends on your reasoning, which depends on what you expect the predictor predicted, and so on… At equilibrium, this must be a fixed point: your strategy $\sigma$ and the predictor’s model $\hat{\sigma}$ must satisfy $\hat{\sigma} = \sigma$.

At any such fixed point, the “I’ll trick the predictor” intuition behind two-boxing is unstable. If your strategy is to two-box, the predictor knows, and Box B is empty. If your strategy is to one-box, the predictor knows, and Box B is full. You can’t deviate profitably because the prediction already accounts for your reasoning about the prediction. The fixed point is self-enforcing.

There is a useful game-theoretic way to see this. In the original setup, the move order is: predictor fills boxes (move 1), then you choose (move 2). Two-boxing exploits last-mover advantage: you observe a fixed game state and pick the dominant action. But as the predictor’s accuracy $q \to 1$, the effective move order inverts. A near-perfect predictor reacts to your strategy as if it moved after you, not before. The temporal sequence stays the same (boxes first, choice second), but the strategic sequence flips: the predictor’s move is now essentially a best response to yours. At $q = 1$ the game is equivalent to one where you commit to a strategy first and the predictor fills the boxes second. In that game, one-boxing is obviously correct and two-boxing is obviously foolish.

This is why Newcomb’s problem feels so different from ordinary strategic interaction. In a standard game, you choose against a fixed opponent. In Newcomb’s problem, you choose against a mirror. The four lenses, causal, algorithmic, empirical, adversarial, are four ways of formalizing what it means to make a decision when the universe has already priced in the fact that you’re going to make it.

References

[N] Nozick, R. (1969). Newcomb’s Problem and Two Principles of Choice. In N. Rescher et al. (eds.), Essays in Honor of Carl G. Hempel, pp. 114-146. D. Reidel, Dordrecht. PDF

[P] Pearl, J. (2009). Causality: Models, Reasoning, and Inference. 2nd ed. Cambridge University Press.

[YS] Yudkowsky, E. & Soares, N. (2017). Functional Decision Theory: A New Theory of Instrumental Rationality. arXiv:1710.05060

[B] Bostrom, N. (2002). Anthropic Bias: Observation Selection Effects in Science and Philosophy. Routledge.

[CBL] Cesa-Bianchi, N. & Lugosi, G. (2006). Prediction, Learning, and Games. Cambridge University Press.

[PX] Pokutta, S. & Xu, H. (2021). Adversaries in Online Learning Revisited: with applications in Robust Optimization and Adversarial training. arXiv:2101.11443

[GH] Gibbard, A. & Harper, W. (1978). Counterfactuals and Two Kinds of Expected Utility. In C.A. Hooker, J.J. Leach & E.F. McClennen (eds.), Foundations and Applications of Decision Theory, Vol. II, pp. 125-162. D. Reidel, Dordrecht.

[SEP] Stanford Encyclopedia of Philosophy. Causal Decision Theory.

[PP] PhilPeople. 2020 PhilPapers Survey: Newcomb’s Problem.

[O] Oesterheld, C. (2017). A Survey of Polls on Newcomb’s Problem.

[W] Wikipedia. Newcomb’s Problem.

Written by Louis Schiekiera.

The core question

Cognitive scientists have long inferred semantic structure from observable behavior: show someone the word dog, record what they associate with it (cat, leash, bark), repeat across many cues, and the resulting response patterns sketch an approximate map of an otherwise hidden meaning system (De Deyne et al., 2019). LLMs offer a model system to test this logic. Unlike human participants, a language model’s internal representations are directly accessible alongside its behavioral output. So we can ask a sharper question: when we probe an LLM with word-association tasks, how much of its hidden-state semantic geometry actually shows up in the responses it produces?

That is the focus of our recent preprint, From Associations to Activations led by Louis Schiekiera. Rather than comparing model behavior to human norms, we compare each model’s behavior to its own layerwise hidden states—treating the model as both the subject and the ground truth.

Figure 1: Overview of the approach. A shared vocabulary feeds two pipelines: (i) layerwise hidden-state extraction produces a hidden-state similarity matrix, and (ii) behavioral association tasks (forced choice or free association) yield a behavioral similarity matrix. Representational similarity analysis (RSA) then quantifies how well the two geometries match.

Experimental setup at a glance

Models under study

We tested eight instruction-tuned decoder-only transformers spanning 7B to 14B parameters: Falcon3, Gemma-2, Llama-3.1, Mistral-7B, Mistral-Nemo, Phi-4, Qwen2.5, and rnj-1. All experiments share a single 5,000-noun vocabulary drawn from the SUBTLEX-US frequency list (Brysbaert et al., 2012).

Two ways to elicit semantic behavior

We borrowed two classic paradigms from psycholinguistics.

Figure 2: Illustration of the two behavioral paradigms. In forced choice (left), a cue word is paired with a candidate set and the model picks the most related items. In free association (right), the model generates associates from scratch. Both produce cue–response count matrices whose row-wise cosine similarities define behavioral semantic geometries.

Forced choice (FC). Each cue appears with 16 candidate words; the model selects exactly two that are most semantically related. A deterministic shuffle of the remaining vocabulary produces 313 unique candidate sets per cue.

Free association (FA). Each cue is presented alone and the model generates five single-word associates. We repeat this across 126 stochastic runs per cue to accumulate stable response distributions.

Responses from both paradigms are aggregated into sparse cue–response count matrices. We apply positive pointwise mutual information (PPMI) reweighting to down-weight globally frequent responses, then compute cue–cue similarity via cosine between PPMI-weighted row vectors. Altogether, the dataset spans more than 17.5 million trials across both paradigms and all eight models.

Extracting hidden-state geometry

For every model and every word in the vocabulary, we pulled layerwise hidden states under four contextual embedding strategies:

• Averaged — the word embedded in 50 naturally occurring C4 sentences (Raffel et al., 2020), hidden states averaged across contexts (Bommasani et al., 2020).
• Meaning — a fixed definitional prompt (“What is the meaning of the word {w}?”).
• Task (FC) — the word embedded in the forced-choice instruction prompt, minus the candidate list.
• Task (FA) — the word embedded in the free-association instruction prompt.

Cosine similarity between mean-centered layerwise vectors (Ethayarajh et al., 2019) yields a hidden-state similarity matrix for each model, layer, and extraction strategy.

Reference baselines

Three external baselines anchor the comparison: FastText static word vectors (Bojanowski et al., 2017), BERT contextual embeddings (Devlin et al., 2019), and a cross-model consensus geometry that averages hidden-state similarities from all other models—motivated by evidence for a shared semantic subspace across architectures (Huh et al., 2024).

How we measure alignment

We employed three complementary metrics:

1. RSA (Kriegeskorte et al., 2008; Nili et al., 2014) — Pearson correlation between vectorized upper-triangular entries of the hidden-state and reference similarity matrices, computed per layer.

2. Nearest-neighbor overlap ($\mathrm{NN@}k$) — fraction of shared $k$-nearest neighbors between hidden-state and reference similarity spaces.

3. Held-out-words ridge regression — can behavioral similarity predict hidden-state similarities for words the model never saw during training of the regression? This tests generalization beyond lexical baselines and cross-model consensus.

Key findings

Constrained tasks recover far more internal structure

The gap between paradigms is substantial. Forced-choice behavior aligns with hidden-state geometry far more strongly than free association—consistently, across every model and evaluation metric.

Under the best extraction strategy (Task FC), mean RSA reaches $r = .463$ for forced choice versus only $r = .199$ for free association. Even the weakest FC condition (Averaged extraction, $r = .346$) outperforms the strongest FA condition.

Figure 3: Aggregate alignment across models. Left: RSA correlation by layer. Right: nearest-neighbor overlap as a function of neighborhood size $k$ (log scale). Forced-choice behavior (green) tracks hidden-state structure far more closely than free association (red). Cross-model consensus (black) sets the ceiling.

Why does FC win so decisively? Its controlled candidate sets force every response to emerge from an explicit comparison, concentrating observations onto shared supports and producing a denser, less noisy cue–response matrix (Roads et al., 2021). Free association, by contrast, disperses probability mass across a long tail of idiosyncratic responses, yielding sparser vectors with lower signal-to-noise for recovering geometric structure.

Extraction context shifts where alignment peaks

The choice of how hidden states are extracted determines which layers show the strongest match.

Figure 4: Layerwise RSA profiles under different extraction strategies. Task-aligned and meaning-focused prompts peak at earlier, mid-depth layers. Averaging over natural contexts shifts the peak to later layers.

Task-aligned and meaning-based prompts push the model into a comparable semantically focused processing mode, and peak alignment appears at earlier to mid-depth layers—consistent with evidence that core lexical-semantic representations crystallize in intermediate transformer blocks. Averaging over diverse natural contexts, by contrast, mixes senses and topics, diluting the word-level signal and shifting alignment peaks toward the final layers.

The paradigm advantage holds across all eight models

Model-by-model heatmaps confirm that the FC superiority is universal, though its magnitude varies with architecture:

Figure 5: Per-model RSA heatmaps. Each panel contrasts forced-choice (left sub-panel) and free-association (right sub-panel) behavioral similarity against hidden states, broken down by extraction strategy and summarized across layers.

Behavior predicts hidden structure on unseen words

The held-out regression provides the most stringent test. After controlling for FastText, BERT, and cross-model consensus, adding FC behavioral similarity still improves mean test $R^2$ by $+.022$; FA adds a marginal $+.002$. The full model achieves mean $R^2 = .587$ (baseline: $.569$), peaking at $R^2 = .844$ for Llama-3.1-8B-Instruct.

Figure 6: Held-out ridge regression results for all eight models. Bold values indicate $R^2$ for the full predictor set (behavioral + baselines); parenthetical values show the baseline without behavioral features.

This means that behavioral probing captures something about a model’s internal semantic organization that lexical vectors and cross-model structure alone do not—especially when the behavioral measurement is carefully constrained.

Broader implications

Black-box interpretability

When logits and activations are unavailable, behavioral probing remains an important path to interpretability. Forced-choice paradigms are especially promising: their constrained response sets act as structured measurement instruments that concentrate informative signal.

Lessons for cognitive science

Our fully transparent LLM setup lets us rigorously test a foundational cognitive-science assumption—that structured behavior is constrained by, and therefore partially reveals, internal states. The sharp FC–FA divergence demonstrates that whether behavior reveals internal structure depends critically on the measurement protocol. Open-ended tasks are not inherently less informative; they simply distribute responses too thinly for cosine-based geometry recovery. Protocol design is itself a variable.

A shared semantic substrate

One of the most important observations is the strength of cross-model consensus. Similarity structure aggregated from the other seven models explains a large share of variance in any target model’s hidden-state geometry, lending further support to the hypothesis of a common, low-dimensional semantic subspace across diverse LLM architectures (Huh et al., 2024).

References

• Bojanowski, P., Grave, E., Joulin, A., & Mikolov, T. (2017). Enriching word vectors with subword information. Transactions of the Association for Computational Linguistics, 5, 135–146. doi:10.1162/tacl_a_00051

• Bommasani, R., Davis, K., & Cardie, C. (2020). Interpreting pretrained contextualized representations via reductions to static embeddings. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics (pp. 4758–4781). doi:10.18653/v1/2020.acl-main.431

• Brysbaert, M., New, B., & Keuleers, E. (2012). Adding part-of-speech information to the SUBTLEX-US word frequencies. Behavior Research Methods, 44(4), 991–997. doi:10.3758/s13428-012-0190-4

• De Deyne, S., Navarro, D. J., Perfors, A., Brysbaert, M., & Storms, G. (2019). The Small World of Words: English word association norms for over 12,000 cue words. Behavior Research Methods, 51(3), 987–1006. doi:10.3758/s13428-018-1115-7

• Devlin, J., Chang, M.-W., Lee, K., & Toutanova, K. (2019). BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of NAACL-HLT 2019 (pp. 4171–4186). doi:10.18653/v1/N19-1423

• Ethayarajh, K. (2019). How contextual are contextualized word representations? Comparing the geometry of BERT, ELMo, and GPT-2 embeddings. arXiv preprint. arxiv:1909.00512

• Huh, M., Cheung, B., Wang, T., & Isola, P. (2024). The platonic representation hypothesis. arXiv preprint. arxiv:2405.07987

• Kriegeskorte, N., Mur, M., & Bandettini, P. A. (2008). Representational similarity analysis—connecting the branches of systems neuroscience. Frontiers in Systems Neuroscience, 2, 4. doi:10.3389/neuro.06.004.2008

• Nili, H., Wingfield, C., Walther, A., Su, L., Marslen-Wilson, W., & Kriegeskorte, N. (2014). A toolbox for representational similarity analysis. PLoS Computational Biology, 10(4), e1003553. doi:10.1371/journal.pcbi.1003553

• Raffel, C., Shazeer, N., Roberts, A., Lee, K., Narang, S., Matena, M., Zhou, Y., Li, W., & Liu, P. J. (2020). Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140), 1–67. jmlr.org

• Roads, B. D., & Love, B. C. (2021). Enriching ImageNet with human similarity judgments and psychological embeddings. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) (pp. 3547–3557). doi:10.1109/CVPR46437.2021.00355

Written by Jana Gonnermann-Müller.

Recognizing the Need for AI in Schools

On November 26, school principals from primary and secondary schools gathered with regional authorities for the annual KI-Fachtag der Schulen. The theme this year: Artificial Intelligence in Education.

The spotlight was firmly on concrete use cases: how Artificial intelligence (AI) can support schools today, but also on the fear that AI is used without verification or cross-checking, potentially leading to a loss of skill and knowledge. At the center of the discussion was a dual question. On the one hand, how do we ensure that AI use becomes meaningful, so that it augments, rather than replaces, core competencies, which includes fostering AI literacy, critical thinking, and verification skills so that students learn not simply to consume AI outputs, but to evaluate, challenge, and integrate them in ways that support long-term skill development. On the other hand, how can AI help schools address structural pressures such as rising workload due to classroom heterogeneity and teacher shortages?

As part of the event, our team from the IOL Lab at the Zuse Institute Berlin was invited to give a talk and to lead two hands-on workshops. In the keynote, we outlined the structural pressures that make AI integration in schools necessary: demographic change, Germany’s lag in technological adoption, and the growing information overload that increasingly requires students to critically evaluate and interpret information sources. In such a context, AI literacy and critical thinking become foundational competences. The workshop discussions quickly revealed just how acute these pressures have become. School leaders described rising heterogeneity in their classrooms, the growing need for differentiated instruction, and the challenges of ensuring meaningful and responsible AI use in everyday teaching. Their questions and concerns underscored the urgency of developing approaches that are not only technically feasible but also pedagogically sound. Yet meaningful AI integration depends on supporting teachers with practical, research-grounded tools that address for example diverse learning needs without adding to their workload.

This post situates these discussions within a broader research context, where we see our work as one puzzle piece in a much larger effort: working directly with schools to understand their needs, translate them into researchable questions, and offer evidence-based opportunities to address them. We therefore collaborate with schools to empirically examine where AI can support teaching, such as in differentiation under increasing heterogeneity, where it cannot, and how it must be designed to strengthen rather than undermine students’ skill acquisition. By co-developing and rigorously evaluating an AI-supported tool with practitioners, we aim to move the conversation away from emotion-driven expectations and fears and toward an evidence-informed understanding of what works in real classroom conditions.

The Bigger Picture: What ‘AI and School’ Encompasses

Schools constitute the first structured environment in which young people interact with broader social and technological systems. As such, they are expected to cultivate foundational competencies, such as critical thinking, judgment and collaboration, while simultaneously preparing students for rapidly evolving technological conditions. Contemporary education systems therefore face a multi-layered mandate: to enable engagement with AI, support cognitive and socio-emotional development, and contribute to the reduction rather than the reproduction of socio-economic disparities. Within this broader mandate, AI emerges not as an optional add-on but as an integral part of the technological landscape and decision-making contexts, students will have to navigate. The central question is thus not whether AI should be present in schools, but how it can be integrated in ways that reinforce, rather than erode, core cognitive and analytical skills.

We outline that ‘AI in schools’ comprises two interdependent domains. The first is education about AI, encompassing digital literacy, data literacy, and increasingly AI literacy. These competencies enable students to interpret uncertainty, understand model behavior, and critically evaluate algorithmic outputs—skills that underpin agency in AI-mediated environments.

The second is education with AI, referring to the use of AI tools within teaching and learning processes. In this domain, AI can help address structural challenges such as teacher shortages, the need for differentiated instruction, and unequal access to tutoring. Practical examples include teacher-facing support for generating differentiated materials, student-facing tutoring systems that may mitigate socio-economic disparities, and in-class assistants that scaffold reasoning without displacing human pedagogical judgment.

From this perspective, the objective is not AI adoption per se, but competence-oriented integration, ensuring that students develop AI literacy, critical analysis, and robust domain skills, while teachers receive effective, research-grounded support to manage rising workload and heterogeneity without compromising didactical quality.

While public discussions about AI in education often remain abstract, empirical research highlights several concrete structural challenges. One emerging issue is the need to handle the massive increase of (AI-generated) information, which requires students to learn verification and critical evaluation of information. A second, persistent challenge is rising heterogeneity within classrooms [Siepmann et al. (2023). Attention to diversity in German CLIL classrooms: multi-perspective research on students’ and teachers’ perceptions.International Journal of Bilingual Education and Bilingualism]. Students in schools differ substantially in prior knowledge, linguistic background, cognitive profiles, motivational orientations, and emotional needs, patterns documented widely in international research and in German data from the IQB Bildungstrend 2024. Many classrooms include both high-achieving students and learners requiring significant support, including those with reading and spelling difficulties or ADHD, whose prevalence has increased in recent years [Pearson (2025). ADHD diagnoses are growing. What’s going on?. Nature]. Educational theory has long shown that addressing such diversity requires differentiated instruction [Tomlinson (2014). The Differentiated Classroom: Responding to the Needs of All Learners. 2nd Edition, ASCD, Alexandria]. This entails providing tasks at varying levels of complexity, offering scaffolded support, giving individualized hints and stepwise explanations, and supplying feedback aligned with learners’ needs. Motivational research further demonstrates that effective instruction must integrate cognitive challenge with emotional support, self-efficacy building, and relevance cues, as cognitive and affective processes are tightly intertwined [Pietsch (2010). Evaluation von Unterrichtsstandards. Zeitschrift für Erziehungswissenschaften].

Yet teachers face what research describes as an implementation gap: the discrepancy between pedagogical requirements and what is feasible given limited time, class sizes, and workload [Jude (2025). Deutsches Schulbarometer Lehrkräfte 2025]. Although differentiated instruction is theoretically well understood, its practical implementation is difficult. Creating multiple versions of tasks, adjusting scaffolds, and providing targeted feedback for diverse learner profiles is time-intensive, and most available materials still assume an ‘average learner’, a construct increasingly disconnected from classroom reality.

Other countries are already responding to these pressures in structured and systematic ways: In the United States, Khan Academy’s Khanmigo uses large language models (LLMs) to provide individualized guidance, task variation, and adaptive hints. In China, Squirrel AI diagnostic engines that map knowledge gaps and generate highly personalized learning paths for learners. Singapore integrates adaptive learning systems directly into its national Student Learning Space under the EdTech Masterplan 2030, enabling teachers to deliver levelled tasks and automated feedback aligned with curriculum structures.

Our approach: The FACET Framework

Against the backdrop of rising heterogeneity, motivational disparities, and persistent teacher shortages, our work on the FACET aims to contribute an evidence-based component to the debate about AI integration in German schools. FACET is a research framework designed to systematically examine how AI can support the described need for differentiation under real classroom constraints. Its overarching goal is to help teachers create differentiated teaching materials for diverse learner groups and, at the same time, to generate empirical insights into when AI meaningfully supports teaching and learning, where it falls short, and how it must be designed so that it strengthens rather than undermines skill acquisition.

The FACET is implemented as a multi-agent system with four interconnected layers:

1. Learner agents simulate student behavior based on profiles that teachers themselves can define and instantiate—reflecting varying prior knowledge, low motivation, reading and writing difficulties, ADHD-related challenges, or other characteristics observed in their classes. These agents attempt tasks, reveal misconceptions, and produce reasoning traces and emotional cues. As tasks, teachers can upload their own materials or rely on tasks predefined by curriculum.

2. The assessment agent analyzes how these simulated learners interact with instructional materials—whether uploaded by the teacher or prescribed by the curriculum. It evaluates both their reasoning processes and their affective responses to provide the basis for adapting the materials.

3. The generator agent creates differentiated teaching materials based on these diagnostics. This includes levelled tasks aligned with the curriculum’s ‘areas of competence’, scaffolded steps, hints, and motivational feedback tailored to each simulated learner profile. This layer integrates curriculum structures as well as diagnostic and didactical concepts, allowing the system to identify where learners with different profiles are likely to experience cognitive or motivational difficulties.

4. The evaluator agent reviews the generated output along dimensions such as didactical coherence, clarity, creativity, and suitability for the specified learners. Teachers can then inspect, adjust, or reject the materials as they see fit. They can also download the finalized materials as Word, PDF, or LaTeX documents.

The FACET architecture is not intended to replace teachers. Instead, it provides structured starting points for differentiation, aiming to reduce workload while preserving pedagogical control.

Figure 1: FACET's landing page and a screenshot of the worksheet generator

FACET Meets Reality: Insights From Practice

During the ‘KI-Fachtag der Schulen’, parts of our team — Konstantin Fackeldey, Jana Gonnermann-Müller, and Nicolas Leins — conducted two workshops with around 30 school principals to test the FACET under real-world conditions. The discussions provided a clear picture of the pressures schools face and offered feedback that will directly inform the next stages of FACET’s development.

Principals consistently emphasized the urgency of supporting differentiation in increasingly heterogeneous classrooms. Many reported rising numbers of students with reading and spelling difficulties, varying language proficiencies, and large performance gaps within the same class. Teachers report that one way they try to address differences in learning pace is by allowing faster-learning students to move on to new topics while slower-learning students remain with the current one. However, this forced form of differentiation, driven by the lack of time to create differentiated materials for a shared topic, makes working as a unified class group difficult. As a result, the class ends up working on different topics, or with some students become bored, while others still need significantly more time to complete their tasks.

In addition, inclusion schools in particular expressed strong interest, noting that the current staffing conditions make meaningful differentiation nearly impossible. As one principal described: ‘We have so many different children in our schools … we are labeled an inclusion school, yet we only have one teacher for an entire class. We don’t know how we’re supposed to meet all children’s needs.’ The possibility of generating differentiated materials tailored to specific learner profiles resonated strongly. Principals already aknowledged the quality of FACET’s outputs — ‘much more thoughtfully constructed than what we can produce ourselves under time pressure’— while also highlighting important requirements for classroom use. At the same time, they stressed that differentiated materials must be aligned with the curriculum and that teachers need to integrate FACET’s outputs into the broader workflow of lesson planning and classroom management. Importantly, this real-world feedback is crucial for ensuring that FACET evolves in line with the actual needs of teachers. It underscored that any AI-supported tool must be tightly coordinated with curricular structures and flexible enough to fit into existing teaching practices. Principals also contributed new use cases, such as using FACET as an AI-in-class assistant that scaffold material for diverse students, which we had not previously considered. In sum, these insights are invaluable. They allow us to refine FACET not as an abstract technological experiment but as a research framework developed with schools and oriented toward the real demands of everyday teaching. Many principals expressed interest in long-term testing, and we look forward to continuing this collaborative process as FACET evolves.

Figure 2: Sebastian Pokutta delivering a keynote at the KI Fachtag on AI in Schools (more information).

The Weizenbaum Debate on AI in Schools

Just days earlier, on November 18, our team took part in the 4th Weizenbaum Debate, a packed and lively evening at the Quatsch Comedy Club that brought together researchers, teachers, and students to explore what AI in the school of the future should look like. We were invited to join the debate, sharing insights from research on the FACET and discussing how AI can be meaningfully integrated into everyday teaching. Again, we discussed pressing questions, such as when AI genuinely supports learning and when it slips into mere ‘cognitive offloading’, how generative AI must be designed so that it strengthens understanding rather than undermining it, and what competencies students need to use AI in a self-determined, responsible way. Teachers and students challenged long-standing assumptions about exams, resources, and the role of human educators, grounding the debate in lived reality.

Figure 3: Jana Gonnermann-Müller on stage at the Weizenbaum Debate on AI in Schools (more information).

The Bigger Picture - Why All of This Matters

The underlying core challenge is structural: without scalable support for differentiation, rising learner heterogeneity will continue to outstrip schools’ capacity and deepen educational inequality. Recent assessments already show widening gaps in competencies, motivation, and socio-economic background—pressures intensified by persistent teacher shortages, where education with AI can offer targeted relief. At the same time, students must learn to navigate environments saturated with information, misinformation, and rapidly changing knowledge, underscoring the need for education about AI. Frameworks like FACET cannot solve these systemic issues, but they can offer research solutions that ease critical bottlenecks and free teachers to focus on what cannot be automated: cultivating critical thinking, guiding inquiry, and preparing students to participate responsibly in an AI-shaped society.

Interested in our FACET? Read our paper on FACET at arxiv.org/abs/2508.11401 or reach out to us anytime. This research by Konstantin Fackeldey, Jana Gonnermann-Müller, Jennifer Haase, Nicolas Leins, and Sebastian Pokutta is part of our ongoing work of the Humans and AI research thrust, which is part of the IOL Lab at the Zuse Institute Berlin.

Written by Dominik Kamp, Gioni Mexi, and Sebastian Pokutta.

Introduction

The SCIP Optimization Suite 10.0 is now available. The new release updates the entire stack:

• SCIP 10.0 (core solver)
• SoPlex 8.0 (LP solver)
• PaPILO 3.0 (presolving library)
• GCG 4.0 (automatic decomposition solver)
• Zimpl 3.7 (modeling language)
• UG 1.0 (parallel framework)
• plus SCIP-SDP, PySCIPOpt, MIP-DD, and the new PBSolver application.

At a high level:

• SCIP 10.0 is faster and more robust on both MILPs and MINLPs than 9.x, with the largest gains on harder instances.
• A new exact solving mode can solve rational MILPs without numerical tolerances and produce verifiable certificates.
• IIS detection for MIPs is now integrated directly into SCIP, enabling users to extract irreducible infeasible subsystems for debugging and model analysis.
• Decomposition, presolving, symmetry handling, and conflict analysis all received substantial upgrades.
• The ecosystem around SCIP (GCG, PaPILO, SCIP-SDP, interfaces, and tooling) has matured further.

For full technical details see the SCIP 10.0 release report.

Faster and More Reliable Core Solver

Performance: What Changes in Practice?

The team benchmarked SCIP 10.0 against SCIP 9.0 and 9.2.4 on large MILP/MINLP test sets (MIPLIB, COR@L, MINLPLib).

• On MILPs, SCIP 10.0 is about 4% faster overall than 9.2.4, with up to ~10% speed-ups on harder instances (≥ 100–1000 seconds).
• On MINLPs, the gains are larger: ≈9% faster on average and 20%+ speed-ups on the hardest problems, while also solving more instances within the time limit.

This may sound incremental, but for real workloads (e.g., nightly planning runs, large-scale research experiments) a 5–20% speed-up with improved robustness delivers tangible, hassle-free gains simply by upgrading.

Numerically Exact Solving Mode for MILPs

The headline feature of SCIP 10.0 is a numerically exact solving mode for rational MILPs:

• MILP data (MPS/LP/CIP/OPB/ZIMPL) can be read in exact rational arithmetic.
• SCIP maintains floating-point and rational views and uses a hybrid strategy:
  • Safe dual bounds and cut generation via directed rounding.
  • Exact LP solves via SoPlex or QSopt_ex only when necessary.
• You can log a VIPR certificate that captures the full branch-and-bound proof. Its correctness can be verified with a C++ proof checker included in the SCIP Optimization Suite VIPR repository, or with a formally verified checker built on CakeML/HOL4 for maximum rigor.

Why this matters:

• For safety-critical or audited applications, you can now prove optimality of MILPs with rational data instead of trusting floating-point tolerances.
• For research, this is a playground for exact algorithms, certified MIP technology, and proof logging workflows.

The trade-off is performance: exact mode is currently roughly 3–4× slower than a comparable floating-point configuration and ~7–10× slower than the default configuration, depending on the test set. The fundamental benefit is that the exact objective bounds are actually guaranteed.

Extended Presolving, Symmetry Handling, and Cuts

Smarter Detection of Implied Integrality

SCIP 10.0 adds a new Total Unimodularity-based implied integrality detector that uses network submatrices to infer when some variables can be seen as integers even if they are declared continuous.

• On MIPLIB 2017, it detects implied integrality for ~19% of variables on average, compared to ~3% before.

This extra structure can feed into branching, cutting, and propagation, and is particularly relevant for models with network-like structure. It’s not yet enabled by default, but it’s an important building block for future performance gains (and fun for people who like to tinker with advanced settings).

Better Symmetry Handling (Including Reflections)

SCIP’s symmetry machinery has taken a major step forward:

• Reflection symmetries (e.g., flipping binary variables 0↔1 or reflecting coordinates) are better detected and exploited.
• Schreier-Sims cuts, orbitopes, double-lex matrices, and small but effective symmetry handling inequalities have all been extended to handle these reflections.

For highly structured models (graph coloring, packing, disk packing, many combinatorial designs), this can significantly reduce search by eliminating symmetric parts of the tree.

Cut-Based Conflict Analysis and Flower Cuts

Two new pieces in the cut/propagation story:

• Cut-based conflict analysis: instead of analyzing conflicts purely via implication graphs, SCIP 10.0 can operate directly on linear inequalities, which can theoretically provide exponentially stronger reasoning than classical SAT-style conflict analysis, which is based on the resolution proof system and CNF encodings.
• Flower inequalities: a new separator for products of nonnegative variables (e.g., logical ANDs) generates so-called k-flower inequalities over a multilinear hypergraph representation. The implementation focuses on k=1 or 2 neighboring edges, for efficiency, and is near-neutral when no multilinear structure is present, but can be a noticeable win on affected instances.

In practice, both features help SCIP learn more from infeasibilities and nonlinear structure, translating into fewer nodes and more solved instances.

Heuristics, Branching, Benders, and Explainability

Several “everyday” parts of the solver got smarter:

• New decomposition-aware heuristics: two primal heuristics (including a kernel search variant) exploit user-provided decompositions to search promising subspaces first. This is particularly useful when you already know the structure of your problem (e.g., time periods, locations, or scenario blocks).
• Improved branching strategies: reliability pseudocost branching was made safe for exact mode and further tuned for floating-point runs. This mainly shows up as more stable performance on hard instances.
• Enhanced Benders’ decomposition framework: more flexible ways to define master and subproblems and better automatic detection of linking variables. This lowers the barrier to using Benders’ decomposition in real models.
• Infeasibility explanations (IIS): a new tool can compute irreducible infeasible subsystems, giving more interpretable explanations of why a model is infeasible. This is useful for model debugging and communicating with non-optimization stakeholders.
• CONOPT interface: you can now use CONOPT as the NLP solver. It’s not uniformly faster than Ipopt, but on the hardest MINLPs it yields substantial reductions in runtime and node count, and can solve some instances that stall with Ipopt.

Taken together, these features make SCIP 10.0 not just faster, but also better at telling you what’s going on when things fail.

Ecosystem Updates: GCG, PaPILO, SCIP-SDP, SoPlex, UG, Zimpl

GCG 4.0: Decomposition Solver

GCG’s new release focuses on usability and performance:

• Harmonized Apache 2.0 licensing with SCIP.
• New GCG object to simplify the C API and unify access to original/master models.
• Easier integration of external pricing solvers (HiGHS, Cliquer-based specialized pricing).
• Parallel pricing enabled by default (with a parameter to control thread count).
• New IPColGen primal matheuristic for set covering/packing/partitioning master problems.
• Decomposition scores refactored into plugins for easier experimentation.

In short: if you’re doing branch-cut-and-price/Dantzig-Wolfe, GCG 4.0 is a more pleasant and capable environment.

PaPILO 3.0: Faster Presolving with Less Memory

PaPILO 3.0 brings:

• Significant improvements in performance and memory usage for the dominated columns presolver.
• A new parallel clique-merging presolver that extends and cleans up clique structures more efficiently.

These low-level improvements are easy to overlook, but they directly affect large instances where presolving used to dominate runtime or exceed memory.

SCIP-SDP, SoPlex 8.0, UG, and Zimpl

• SCIP-SDP 4.4.0 updates to SCIP 10.0 and adds the ability to export original and transformed MISDPs in CBF format for use with the Conic Benchmark Library.
• SoPlex 8.0 is a major version bump reflecting build system and API changes; it remains the default LP solver and is central for exact LP solving in the new exact mode.
• UG framework now includes an application for parallel Pseudo-Boolean solving with FiberSCIP, featuring 2024 PB competition–tuned settings and optional DIMACS-style log output.
• Zimpl 3.7.0 adds support for permutations (permutate(A)) and better handling of implied integral variables, which are now recognized by SCIP.

Interfaces, Developer Tooling, and PBSolver

Interfaces: PySCIPOpt, Rust, and More

Interface highlights:

• PySCIPOpt now supports matrix variables based on numpy.ndarray, making it much more natural to write matrix-centric models (think: SDP-like structures, network flows, control). The documentation and tutorials have also been significantly improved, including exercises and “recipes” for common modeling tasks.
• The Rust interface (russcip) has a more ergonomic and type-safe API with builder-style variable/constraint creation and safe access to separators and constraint handlers.
• Other interfaces (Matlab, AMPL, SCIPpp C++, PySoPlex, PyGCGOpt, PaPILO’s Julia interface) were updated and documented.

From a user perspective, this makes it easy to access the full solver functionality in your favorite language.

MIP-DD 2.0: Delta Debugging for MIP Solvers

MIP-DD is the first open-source, solver-independent delta debugger for MIP solvers.

• It automatically shrinks a failing instance while preserving the bug, often down to models with just a handful of variables and constraints.
• Version 2.0 adapts modification batch sizes automatically, limits solving effort intelligently, and supports both real and exact solving modes of SCIP and SoPlex.

If you develop solvers or serious extension plugins, MIP-DD is a powerful way to turn pathological “customer instances” into minimal test cases, while also removing sensitive information.

PBSolver: Dedicated Pseudo-Boolean Application

SCIP 10.0 introduces PBSolver, a SCIP-based application tailored to Pseudo-Boolean optimization and the Pseudo-Boolean Competition format.

• Emits competition-compliant DIMACS-style logs and solution lines.
• Handles OPB/WBO instances out of the box, with parameters to control input limits.
• SCIP/FiberSCIP-based solvers using these features won several categories of the 2024 PB competition.

If you work with Pseudo-Boolean benchmarks or SAT+PB hybrids, PBSolver gives you a supported, competition-ready entry point.

Availability and Getting Started

Core Distribution

The SCIP Optimization Suite 10.0 (SCIP, SoPlex, PaPILO, GCG, Zimpl, UG, SCIP-SDP, interfaces, and applications) is available as usual via the project website and GitHub repositories. Licensing is now more unified:

• SCIP 10.0, SoPlex 8.0, PaPILO 3.0, GCG 4.0 under Apache 2.0.
• Zimpl 3.7.0 and UG 1.0 under LGPL.

You can download the latest release from the SCIP Optimization Suite website or from our GitHub repositories.

New Docker Images: Web Service and Jupyter Lab

To make the suite easier to adopt in teaching, prototyping, and production, we provide two official Docker images (described in detail on the dedicated Docker page):

• scip-webservice: a FastAPI-based web service for solving problem instances in common formats (e.g., .lp, .mps, .cip, .cnf, .fzn, .nl, .opb, .osil, .pip, .wbo, .zpl) via HTTP.

  • Single-command startup, with endpoints for status, uploads, and auto-generated API docs.
  • Environment variables to control concurrency, retention, and upload limits; Docker flags for CPU/memory caps.
  • Designed so you can go from “no SCIP installed” to a working REST API in a minute.

• scip-jupyterlab: a pre-configured Jupyter Lab environment with

  • SCIP 10.0, PySCIPOpt 6.0, and Python 3.11,
  • plus a standard data-science stack (NumPy, Pandas, Matplotlib, scikit-learn, etc.).
  • Mount a local directory into /app and you have a ready-to-use notebook environment for teaching, demoing, or exploratory modeling.

Think of these as the modern replacement for the older “Dockerized SCIP for Teaching” setup: less friction, more batteries included.

(For details, examples, and recommended resource settings, see the SCIP Optimization Suite 10 Docker page)

Who Should Upgrade?

• Practitioners get a faster, more reliable solver with better decomposition and PB capabilities, plus easier deployment via Docker.
• Researchers get exact solving, proof logging, extended symmetry and presolving, and richer interfaces.
• Teachers can run everything from a browser via the Jupyter Lab image, avoiding per-student installation pain.

If you experiment with the new exact mode, MIP-DD, or the Docker images and find interesting use cases (or rough edges), feedback is very welcome on GitHub or via email; this release is meant as both a robust workhorse and a platform for the next wave of MIP/MINLP research.

Introduction

The 2025 Nobel Prize in Economic Sciences was awarded jointly to Joel Mokyr, Philippe Aghion, and Peter Howitt for their fundamental work on innovation-driven growth.

Mokyr’s historical analysis explains why sustained growth emerged only under specific institutional and cultural conditions, while Aghion and Howitt’s theoretical model shows how innovation endogenously fuels growth through the process of creative destruction.

Together, their work provides a unified narrative: innovation is the engine of prosperity, but its power depends critically on the societal and institutional environment that allows new ideas to flourish and old ones to fade.

Recent News that complement this narrative

Some recent news that appeared after this post was written but are relevant to the discussion:

• The Economist: How Europe crushes innovation
• A European attempt to catch up: EuroLLM

Mokyr: The Preconditions for Sustained Growth

Joel Mokyr’s research asks a deceptively simple question: Why did the Industrial Revolution happen when and where it did? His answer lies not in the invention of particular machines, but in the emergence of an environment that made continuous innovation possible.

For much of human history, inventions appeared sporadically but failed to trigger self-sustaining growth. Mokyr identifies three essential conditions that finally broke that pattern.

1. Science and Technology Co-Evolving. Growth accelerated when scientific understanding and practical engineering began to reinforce one another. The interplay between theory and application—seen in mechanics, thermodynamics, and chemistry—created a virtuous cycle of cumulative improvement.

2. Engineering Capability and Mechanic Competence. Scientific knowledge alone was not enough. Societies also needed the ability to implement ideas at scale: skilled artisans, standardized components, effective apprenticeship systems, and eventually formal engineering education. This infrastructure enabled the transformation of insight into industrial capability.

3. Openness to Disruption. Perhaps the most fragile condition was social and institutional openness to change. Continuous innovation means continuous displacement—of technologies, firms, and sometimes entire industries. Where vested interests could block such shifts, growth remained episodic.

Implications

Mokyr’s message is timeless: innovation without diffusion, engineering capacity, or openness cannot sustain prosperity. Even advanced economies risk stagnation if they lose these enablers—whether through regulatory rigidity, skill erosion, or entrenched incumbency.

Aghion-Howitt: Creative Destruction

Aghion and Howitt revolutionized growth theory by bringing innovation inside the model. Instead of treating technological progress as an external force, they described it as a product of firms’ strategic choices—to invest, to compete, and to risk being replaced.

Their framework captures the Schumpeterian idea of creative destruction: progress occurs because new technologies displace old ones. This destruction is not a side effect: it is the very mechanism that keeps growth alive.

The Core Mechanisms

1. Endogenous Innovation: Firms innovate when they expect profits from doing so. R&D intensity depends on incentives, policy, and market structure.
2. Competition and the Inverted-U: Innovation is most vibrant under moderate competition—too little protects monopolists; too much erodes potential gains.
3. Entry, Exit, and Reallocation: Dynamic economies rely on turnover. New entrants challenge incumbents, and resources shift toward more productive uses.

Through this lens, growth becomes a process of continuous experimentation, selection, and renewal.

Policy Lessons

Aghion and Howitt’s theory highlights the interdependence of R&D policy, competition policy, and education/labor systems. Each shapes the incentives that determine whether an economy encourages the next generation of innovators; or protects the last.

Innovation, Growth, and Sustainability

Innovation is the only long-run source of growth. But innovation alone does not guarantee it. The engine must run within a system that supports both discovery and renewal. In Mokyr’s terms, science, technology, and social openness must align. In Aghion–Howitt’s framework, competition and institutional design must sustain incentives for continuous creative destruction. Sustainable prosperity, then, is less about preserving existing strengths than about preserving the capacity for renewal—the ability to replace outdated ideas, technologies, and firms with better ones.

What this says about innovation in Germany

Even before the 2025 Nobel announcement, leading growth economists such as Philippe Aghion had warned that Europe, and Germany in particular, no longer fully satisfies the institutional and cultural conditions for innovation-driven growth. Aghion, Dewatripont, and Tirole argue that since the 1990s, Europe has failed to establish the environment required for disruptive innovation: a fragmented single market, underdeveloped venture-finance and risk-capital systems, and a policy culture favoring stability over experimentation. As a result, Europe risks becoming trapped in what they call a “middle-technology equilibrium”, strong in incremental improvements but weak in frontier innovation and technological leadership. These critiques directly echo the Nobel laureates’ insights: innovation must operate within an institutional system that tolerates creative destruction and rewards renewal rather than preservation.

Figure 1: Nominal GDP per capita (via datacommons.org).

The Historical Layer: From Stability to Dynamism

Postwar Germany built its prosperity on incremental innovation and stability. The country perfected the art of refining existing technologies rather than replacing them. This model—anchored in engineering excellence, vocational training, and social partnership—created high productivity and resilience but limited tolerance for disruption.

In Mokyr’s terms, Germany excels in mechanical competence but underinvests in openness to disruptive change. Institutions, regulations, and social norms that once guaranteed continuity now risk locking the system into the past.

Key Tension: Germany’s model maximized stability and diffusion, not frontier innovation. The very strengths that drove its success is now slowing down innovation and adaptation.

The Structural Layer: Inertia vs. Innovation Dynamics

Aghion & Howitt’s growth framework emphasizes continuous entry of new innovators and exit of outdated firms. Germany’s industrial ecosystem, however, tends to favor incumbents and gradualism.

This structure is highly optimized for incremental improvement: excellent at perfecting combustion engines or machine tools, but less agile when the frontier shifts toward AI, software, and renewable systems.

In short: Germany is a world leader in innovation within existing paradigms, but struggles to innovate across them.

The Policy Layer: Institutions and Incentives

The policy environment reflects the same equilibrium: one optimized for stability and incremental improvement rather than experimentation and renewal.

• Finance: Germany’s bank-centered system channels capital primarily to established firms with tangible assets and proven track records. Venture and growth finance remain limited in volume and depth compared to the U.S. or China, constraining the scale-up of young innovative firms. Public financing instruments, though substantial, often emphasize risk minimization and compliance over agility and experimentation.
• Regulation: Complex approval procedures, fragmented jurisdictions, and slow digital administration increase transaction costs and delay the deployment of new technologies. Even pilot projects or regulatory sandboxes face multi-year approval timelines, reducing the incentive for entrepreneurial experimentation.
• Public R&D: Institutional research networks such as Fraunhofer, Helmholtz, and Max Planck as well as excellent universities deliver outstanding science and applied engineering, but translation into scalable high-growth enterprises remains the weak link. Structural barriers between academia and entrepreneurship, ranging from intellectual-property rules to career incentives, limit the spillover of frontier research into the private sector.
• Competition Policy: Designed to safeguard fairness and prevent monopolies, it sometimes has the side effect of preserving incumbents. High regulatory thresholds and sectoral protection dilute entry pressure and reduce the dynamism of domestic markets, particularly in energy, finance, and telecommunications.

These features supported stability, quality, and long-term employment for decades. Yet today they constrain dynamism, speed, and adaptability—precisely the qualities that define success in innovation-driven economies. In Aghion’s terms, the current policy mix underweights entry dynamism: the continual churning of firms that fuels creative destruction and renewal. Sustained growth, however, requires institutional agility: policies that reward experimentation, accept short-term disruption, and tolerate failure as part of the innovation process.

Why It Becomes a Problem

The laureates’ work helps explain why Germany’s model now faces mounting structural headwinds. What once guaranteed stability and prosperity now risks impeding adaptation to a faster, more fluid global innovation landscape.

• Acceleration of technological cycles: Innovation now unfolds at software speed, while Germany’s institutions and industrial processes still move at mechanical speed. The product cycles of AI, digital platforms, and biotech evolve in months, not decades, demanding a pace of response the traditional system struggles to match.
• Shift from physical to digital: Value creation increasingly depends on algorithms, data, and networks rather than production volume or material precision. Germany’s comparative advantage in manufacturing excellence thus erodes unless accompanied by digital capability and data-driven innovation.
• Global competition for innovation: Ecosystems in the United States, China, and South Korea combine capital depth, entrepreneurial risk appetite, and scale in ways Europe and Germany have not replicated. These ecosystems attract top global talent and absorb frontier innovations faster, creating a widening gap in technological leadership.
• Over-embedded incumbency: Political, social, and financial systems continue to shield existing industries—automotive, energy, finance—from disruption. This “incumbent bias” prevents reallocation of capital and talent to emerging sectors and delays renewal.
• Hesitance to adopt external innovation: Beyond domestic inertia, Germany also tends to underutilize external technological breakthroughs. Imported digital and AI tools are often viewed through a compliance or risk lens rather than as catalysts for reinvention. This reluctance to integrate global frontier technologies into local production chains further widens the innovation gap.

The result is a growing mismatch between the velocity of global technological change and the institutional response capacity of Germany’s economic model. Without structural renewal, the innovation–growth link weakens, turning creative destruction into mere creative delay.

In Aghion’s terms, Germany risks falling into a middle-technology equilibrium: a state of high competence in established industries coexisting with stagnation at the technological frontier. In the face of demographic decline and a shrinking labor force, productivity growth through innovation is no longer optional; it is the only path to sustaining prosperity.

Institutional agility, policy experimentation, and a proactive innovation agenda are therefore not economic luxuries but existential necessities. Or put it in the famous words attributed to W. Edwards Deming:

“It is not necessary to change. Survival is not mandatory.” — W. Edwards Deming

What Compatibility Would Require

To realign with an innovation-driven growth path, Germany must evolve from a stability model to a renewal model. One that sustains its strengths while restoring openness, experimentation, and competition.

1. Cultural Shift: Move from risk avoidance to curiosity and experimentation.
2. Dynamic Competition: Strengthen antitrust tools, encourage market entry, and curb excessive concentration.
3. Faster Diffusion: Create translational institutions between academia and startups; reduce administrative friction.
4. Deep Capital Markets: Expand venture and scale-up finance; modernize taxation of employee equity.
5. Talent and Skills Renewal: Extend the dual education model to digital, AI, and systems engineering; simplify international recruitment.
6. State as Catalyst: Use public procurement and infrastructure investment to create domestic lead markets for innovative solutions.
7. Institutional Agility: Embed experimentation into policy, via sandboxes, adaptive regulation, and outcome-based funding.

Sustainable prosperity is no longer about preserving existing strengths, but about preserving the capacity for transformation.

Afterword

Several years ago, in February 2020, I was flying back to Germany from Atlanta and my flight was delayed and it became clear that the pilot won’t be able to make up the time. So I logged into the onboard wifi, opened my (then still) Twitter app and DMed the @Delta twitter account as I had done numerous times before. No 10 minutes later I had my connecting flight rebooked; even though the connection was on a non-SkyTeam carrier. No hassle, no waiting in line, no waiting in line again. It. Just. Worked.

Figure 2: Innovation in action: Delta flight rebooking midair in 8 minutes.

References

• Nobel Prize in Economic Sciences 2025 — Press release https://www.nobelprize.org/prizes/economic-sciences/2025/press-release/
• Nobel Prize in Economic Sciences 2025 — Popular information https://www.nobelprize.org/prizes/economic-sciences/2025/popular-information/
• Reuters — “Trio win Nobel economics prize for work on innovation, growth and creative destruction” https://www.reuters.com/world/mokyr-aghion-howitt-win-2025-nobel-economics-prize-2025-10-13/
• The Guardian — “Nobel economics prize: technology-driven growth (Mokyr, Aghion, Howitt)” https://www.theguardian.com/business/2025/oct/13/nobel-economics-prize-technology-joel-mokyr-philippe-aghion-peter-howitt
• Financial Times coverage https://www.ft.com/content/9b845160-f44b-4865-94f7-1bf21e25596e
• Le Monde (English) — Philippe Aghion: “The key factor of economic power is technological leadership” https://www.lemonde.fr/en/international/article/2025/10/13/2025-nobel-winner-philippe-aghion-the-key-factor-of-economic-power-is-technological-leadership_6746390_4.html
• Philippe Aghion, Mathias Dewatripont & Jean Tirole (2024). “Can Europe Create an Innovation Economy?” Project Syndicate, October 2024. https://www.project-syndicate.org/commentary/europe-falling-behind-us-innovation-technology-what-to-do-about-it-by-philippe-aghion-et-al-2024-10
• VoxEU/CEPR (2024). “Reforming Innovation Policy to Help the EU Escape the Middle-Technology Trap.” April 2024. https://cepr.org/voxeu/columns/reforming-innovation-policy-help-eu-escape-middle-technology-trap
• Financial Times (2025). “Economics Nobel Prize Awarded for Explaining Innovation-Driven Growth.” October 2025. https://www.ft.com/content/9b845160-f44b-4865-94f7-1bf21e25596e

It is the digital equivalent of sealing a message in an envelope and handing it to someone: they cannot see the contents until you open it, but once it is sealed, you cannot replace what is inside.

The Problem: Promises Without Revealing

There are many situations where the “sealing away” of a message might be useful. For example, imagine these situations:

1. You want to prove later that you already knew the solution to a problem, but you do not want to reveal it today.
2. You want to place a bet on the outcome of an event but do not want your opponent to know which side you picked in advance.
3. You are running a digital lottery and need to show that the winning number was (random but) fixed before the draw and not manipulated after the draw.
4. Or more nerdy, you want to convince someone you found a valid graph coloring without revealing the coloring itself (a classic zero-knowledge proof setting).

All of these require a way to commit to a secret so that two key properties are satisfied:

• Hiding. Nobody learns the secret until you reveal it.
• Binding. Once you have committed, you cannot change your mind.

That is precisely what commitment schemes do.

Figure 1: A completely useless AI generated image of a hashed commitment.

A Quick Primer on Hash Functions

The simplest commitment schemes rely on cryptographic hash functions such as SHA-256. A hash function H takes an input of arbitrary length and produces a fixed-size digest. Good cryptographic hashes satisfy several key properties:

• Deterministic. The same input always produces the same output.
• Preimage resistant. Given a hash h, it is infeasible to find any input m such that H(m)=h.
• Second preimage resistant. Given an input m, it is infeasible to find a different m' with the same hash.
• Collision resistant. It is infeasible to find any two distinct inputs m_1 != m_2 with H(m_1)=H(m_2).

Hashes are one-way functions: you can go from message to hash easily, but not back. This makes them perfect for commitments. Here “infeasible” is meant in the sense of computational complexity theory, i.e., it takes a lot of computational resources and time. While hash functions are designed to be collision-resistant they might still have collisions simply because we digest arbitrary-length messages into fixed-size digests. This means in particular it is infeasible (in the real sense) to invert a hash function simply because the preimage is not unique; we may find one preimage (if we are extremely lucky) but there is no guarantee that this is the one that was used to compute the hash.

Secret Commitments: The Basic Idea

The simplest commitment is:

C = H(message)

Later, you reveal message, and anyone can verify that H(message) == C.

However, this naive approach leaks some information. If message comes from a small set (like "YES" or "NO"), anyone can brute-force all possibilities and see which one matches C. That breaks the hiding property.

Hashing with Salt

To prevent this, we add randomness. The usual fix is to prepend a random salt to the message before hashing:

C = H(salt || message)

• salt is a random value (e.g., 128 bits) that makes every commitment (assuming no collision) unique, even if the message is common.
• Without knowing salt, an attacker cannot precompute hash tables or brute-force easily.

Later, you reveal (salt, message). Anyone can check that H(salt || message) == C. For example here is a hash from a hash tool that uses SHA-256 with a salt and an additional domain separation string to hash effectively H(domain || salt || message); see also the appendix below for a lightweight verification script.

e708b9946bee40db71df3486d2ea663f69ffb10a9ed8cabcd01b95aac4cc8028

with full commitment record:

{
  "commitment": "e708b9946bee40db71df3486d2ea663f69ffb10a9ed8cabcd01b95aac4cc8028",
  "salt": "29ea6ad30117dfeb82928cd5b38c4c1a",
  "domain": "commit-v1:",
  "message": "Tomorrow it is going to rain.",
  "mode": "hash",
  "timestamp": "2025-09-28T17:57:29.790Z"
}

The hash alone is worthless but binds the commitment. Once the salt and message are revealed, anyone can check that H(salt || message) == C.

However, now we face an (important) design choice:

1. Publish the salt immediately. This guarantees stronger binding. You cannot change it later to try to force a collision but at the same time, while not being able to use precomputed tables, attackers can start brute-forcing the message; expensive but might be successful if the actual message is known to come from a small list of messages, e.g., “YES” or “NO”.
2. Keep the salt secret until reveal. This provides stronger hiding. Attackers cannot even start guessing until you reveal it but at the same time you may be accused of cheating with a new salt s and new message messageNew so that H(s || messageNew) == C; super unlikely but possible.

In practice, both are considered secure if the salt is long and random and it depends on the application: (a) publishing it makes accusations of “cheating with a new salt” impossible, (b) hiding it makes attacks against short message lists impossible.

Verifier-supplied randomness: stronger binding if needed

We can even go a step further and use additional verifier-supplied (or supplied via a public beacon) randomness r to compute the commitment. This provides even stronger binding than the basic scheme with salt: the committer cannot influence r and the salt still hides the message. The reasoning is one of those subtle but fundamental cryptography points which becomes clear once you think about who controls the randomness and when.

In the basic scheme you control both salt and message before committing. By contrast, if the verifier (or a randomness beacon) first provides a random challenge r, you now compute the commitment as

C = H(r || salt || message)

Why is this stronger?

• You cannot “grind” over many salts anymore. With r fixed by someone else, you lose the ability to search over huge numbers of salts to pick a “nice” one with special properties.
• Binding is strengthened even against powerful adversaries. Without r, binding relies on collision resistance alone. With r, the committer faces preimage resistance under a fixed prefix, which is much harder to game retroactively, even if someone could manufacture collisions offline.
• It provides context and time binding. Different r values yield different commitments for the same message. If r is tied to a timestamp, block hash, or VRF output, the commitment could not have been generated before r existed.
• It removes the “choose your own salt” accusation. Since you do not control all randomness, a verifier need not trust that you sampled salt honestly.

Analogy (lottery tickets):

• Without r: you pick your own ticket numbers and could generate many until you like one.
• With r: the machine draws a random number you must include; advance “ticket shopping” no longer helps.

Summary:

Such stronger guarantees that use verifier-provided nonces or public randomness sources eliminate additional theoretical avenues for manipulation and are foundational to advanced protocols like verifiable delay functions, blockchain randomness beacons, and secure multiparty computation.

HMAC Mode: Adding a Secret Key

Another variant uses an HMAC (Hash-based Message Authentication Code):

C = HMAC(key, message)

Here key is a secret shared between two parties. The result:

• Only someone with the key can generate a valid commitment.
• Only someone with the key can verify it.

General structure of HMAC (as a function of H). At a high level, HMAC wraps a hash H in an inner/outer composition with two fixed byte patterns (often called “pads”) and the secret key:

HMAC_H(key, msg) = H( (key_xor_opad) || H( (key_xor_ipad) || msg ) )

where key_xor_ipad and key_xor_opad are the secret key combined with two fixed constants (one for the inner hash, one for the outer hash). This gives message authentication on top of H without exposing the raw key, and it prevents simple extension attacks against Merkle–Damgård hashes.

Remark (why HMAC is different than hashing with a private salt). Using a secret salt like H(secret || msg) or H(msg || secret) is not the same as HMAC:

• A private-salt hash is typically vulnerable to length-extension/structural issues with Merkle–Damgård hashes (this includes SHA-256); HMAC’s inner/outer pads provide domain separation that defeats these.
• HMAC has strong, widely accepted security guarantees (MAC/PRF) under assumptions on H, whereas a naive private-salt construction does not.
• Verification differs: with a private salt, revealing the salt for verification weakens reuse (this affects the reusability requirements of the key); with HMAC, verifiers share a key and tags reveal nothing about the raw key.

What is length extension? A simple example.

Suppose you try to authenticate with tag = H(secret || msg) using SHA-256. An attacker who sees msg and tag can compute a valid tag for an extended message msg || padding || extra without knowing secret:

• They reconstruct SHA-256’s padding for the unknown secret || msg length.
• They continue the hash state from tag to process extra and produce a forged tag for the longer message.

Result. The attacker forges tag' for msg' = msg || padding || extra that will verify under the naive scheme with secret. This is a serious problem if the secret should be reused as key. HMAC’s inner/outer construction prevents this kind of extension because the outer hash re-keys and finalizes the computation in a way that cannot be resumed by an attacker. In the context of commitments, this is not a problem if a fresh secret, i.e., a salt is used for each commitment.

Note that HMAC is not strictly a commitment scheme; it is primarily for authenticity, but it is useful when commitments must be verifiable only by authorized parties.

Applications: Where Commitments Matter

Commitment schemes may seem abstract, but they have applications in many real-world protocols.

Zero-Knowledge Proofs: Graph Coloring

One of the most elegant applications of commitments is in zero-knowledge proofs. These are interactive protocols that let a prover convince a verifier that a certain statement is true without revealing anything beyond the truth of the statement itself. A canonical example uses the NP-complete Graph 3-Coloring problem.

The Setting.

• The prover (P) knows a valid 3-coloring of a graph $G=(V,E)$ but does not want to reveal it to the verifier (V).
• The verifier (V) wants to be convinced that P indeed knows such a coloring.

Protocol: Iterative Zero-Knowledge Proof for 3-Coloring.

1. Commitment Phase:
   • P randomly permutes the color labels (e.g., swaps “red,” “green,” and “blue”).

   • For each vertex $v_i$, P commits to the permuted color with a salt:

     \[C_i = H(\text{salt}_i \parallel \pi(c(v_i)))\]
   • Salts are freshly sampled for each round (and for each vertex); do not reuse salts across rounds.
   • P sends all commitments ${C_i}$ to V.
2. Challenge Phase:
   • V picks a random edge $e=(u,v)$ and sends it as a challenge.
3. Opening Phase:
   • P reveals the committed colors and salts for $u$ and $v$.
   • V verifies:
     • The openings match the original commitments.
     • $c’(u) \neq c’(v)$.
4. Repeat:
   • Steps 1–3 are repeated $k$ times with fresh random permutations and fresh salts each round.

Each round convinces V a little more. If P does not have a valid coloring, the probability of cheating successfully falls exponentially with $k$.

Remark: Why Shuffle Every Round? Without the random permutation step (and fresh salts), repeated openings would gradually leak the full coloring. The shuffling ensures that even after many rounds, no information beyond “adjacent nodes differ” is revealed.

Complexity Perspective. The 3-coloring problem is NP-complete: verifying a proposed coloring is easy (polynomial time), but finding one is believed to be hard. This protocol does not make solving NP-complete problems easier, but it demonstrates a powerful result:

Every language in NP has a zero-knowledge proof system (under standard cryptographic assumptions).

This is a foundational insight in modern cryptography. The graph-coloring protocol is a canonical constructive example.

Betting and Predictions

Commitments are common in prediction markets or bets. You commit to “Team A will win” by publishing C = H(salt || prediction) now. After the match, you reveal the prediction. Because the commitment was binding, nobody can accuse you of changing your guess after the fact.

Timestamped Knowledge Proofs

Researchers or inventors can commit to a discovery before publication. Later, revealing the original text proves they knew it at the earlier time. Useful for priority claims and intellectual property.

Digital Lotteries and Random Draws

A lottery organizer commits to a random seed before ticket sales close: C = H(seed). After the sale, they reveal the seed, and everyone can verify that the winning draw was predetermined and not manipulated after the fact.

Authenticity and Integrity Checks

If you want to authenticate data without revealing it, you can commit to its hash in advance. Later, when the data is disclosed, others can verify it has not changed. This is basically what the MD5 checksums did for downloads in the past.

Hashes Are Not Encryption

One final note: a hash is not encryption.

You cannot “decrypt” a hash. This one-way property is precisely what makes hashes ideal for commitments.

References

[BR] Bellare, M., & Rogaway, P. (2005). Introduction to modern cryptography. Ucsd Cse, 207, 207.

[KL] Katz, J., & Lindell, Y. (2007). Introduction to modern cryptography: principles and protocols. Chapman and hall/CRC.

[RFC2104] RFC 2104: HMAC: Keyed-Hashing for Message Authentication

Appendix: Lightweight Verification Script (Python)

Below is a minimal verifier you can use to check commitments encoded as JSON. It supports both SHA-256 and HMAC-SHA256 modes; you can also use it to create commitments by using the computed hash.

#!/usr/bin/env python3
"""Lightweight commitment verification script."""

import sys
import os
import json
import hashlib
import hmac
from datetime import datetime

def hex_to_bytes(hex_str):
    """Convert hex string to bytes."""
    return bytes.fromhex(hex_str)

def bytes_to_hex(data):
    """Convert bytes to hex string."""
    return data.hex()

def verify_commitment(data, hmac_key=None):
    """Verify a commitment from JSON data."""

    # Extract components
    commitment = data['commitment']
    salt_hex = data['salt']
    domain = data['domain']
    message = data['message']
    mode = data.get('mode', 'hash')
    timestamp = data.get('timestamp')

    # Convert salt to bytes
    salt = hex_to_bytes(salt_hex)

    # Encode domain and message to UTF-8 bytes
    domain_bytes = domain.encode('utf-8')
    message_bytes = message.encode('utf-8')

    # Recreate the data that was hashed
    data_bytes = salt + domain_bytes + message_bytes

    # Hash the data
    if mode == 'hmac':
        if not hmac_key:
            print("❌ HMAC mode requires key. Use --key parameter or set HMAC_KEY environment variable")
            return False, None

        # HMAC-SHA256 verification
        computed = hmac.new(hmac_key.encode('utf-8'), data_bytes, hashlib.sha256).digest()
        computed_hex = bytes_to_hex(computed)
    else:
        # SHA-256 hash
        computed = hashlib.sha256(data_bytes).digest()
        computed_hex = bytes_to_hex(computed)

    # Verify
    is_valid = computed_hex == commitment

    return is_valid, {
        'commitment': commitment,
        'computed': computed_hex,
        'message': message,
        'domain': domain,
        'mode': mode,
        'timestamp': timestamp
    }

def main():
    """Main verification function."""
    try:
        # Parse command line arguments
        hmac_key = None
        if len(sys.argv) > 1:
            if sys.argv[1] == '--key' and len(sys.argv) > 2:
                hmac_key = sys.argv[2]
            elif sys.argv[1].startswith('--key='):
                hmac_key = sys.argv[1][6:]  # Remove '--key=' prefix

        # Also check environment variable
        if not hmac_key:
            hmac_key = os.environ.get('HMAC_KEY')

        # Read JSON from stdin
        json_input = sys.stdin.read().strip()

        if not json_input:
            print("❌ No JSON input provided")
            print("Usage: echo 'PASTE_JSON_HERE' | python3 verify_commitment.py [--key YOUR_KEY]")
            print("   or: export HMAC_KEY=your_key")
            print("   or: echo 'PASTE_JSON_HERE' | python3 verify_commitment.py --key=your_key")
            return

        # Parse JSON
        try:
            data = json.loads(json_input)
        except json.JSONDecodeError as e:
            print(f"❌ Invalid JSON: {e}")
            return

        # Verify commitment
        is_valid, details = verify_commitment(data, hmac_key)

        # Output results
        print("\n\n")
        print(f"Verification: {'✅ VERIFIED' if is_valid else '❌ NOT VERIFIED'}")

        if details:
            print(f"Mode: {details['mode']}")
            print(f"Domain: {details['domain']}")
            print(f"Message: {details['message']}")

            if details['timestamp']:
                try:
                    dt = datetime.fromisoformat(details['timestamp'].replace('Z', '+00:00'))
                    print(f"Timestamp: {dt.strftime('%Y-%m-%d %H:%M:%S UTC')}")
                except:
                    print(f"Timestamp: {details['timestamp']}")

            if not is_valid and details.get('computed'):
                print(f"Expected: {details['commitment']}")
                print(f"Computed: {details['computed']}")

    except KeyboardInterrupt:
        print("\n⚠️  Interrupted")
    except Exception as e:
        print(f"❌ Error: {e}")

if __name__ == "__main__":
    main()

Written by Sebastian Pokutta in collaboration with David Martínez-Rubio.

Little’s law for queueing systems

Little’s law states that the long-run average number $L$ of jobs in a stable system equals the arrival/throughput rate $\lambda$ times the average time $W$ a job spends in the system:

Interpretation.

• $L$: average work-in-progress (jobs “in the system”)
• $\lambda$: average completion rate for the flow considered (arrivals = departures in steady state)
• $W$: average time in system per job

Assumptions. The assumptions are minimal: stability (finite averages, arrivals balance departures), clearly defined entry/exit points, and stationarity/ergodicity. Crucially, Little’s law is insensitive to the arrival/service distributions and scheduling discipline, and it also holds for stable subflows (e.g.,when splitting into different classes of jobs).

Note. We stick to the notion of hazard as the per-step completion (conditional) probability as customary in queueing theory.

Summary: Link to the conference reviewing model

In our setting, the “system” is the pool of papers under review across calls; arrivals are new submissions per call; exits are final decisions (accept or abandonment). We model each conference call as one time step and authors may resubmit their papers to the next call if rejected, i.e., these papers effectively stay in the system. If $N$ new submissions arrive per call and each paper has an independent per-call accept/complete hazard $p$, then Little’s law gives:

No giving up (infinite patience). In this case, each paper is accepted if it is completed, which happens at some point in time. Given hazard $p$, we have the mean time in system as $W = \frac{1}{p}$ and the expected pool level scales as $L = N/p$:

Key insight: the throughput (= number of accepted papers per call) does not change with $p$. Lowering $p$ just increases the in-system population $L$ (and thus reviewer load).

Finite patience with papers being abandoned after $T$ calls. This is the case where papers are abandoned after $T$ calls if not accepted. We still have only one “class” of papers, but now there are two exit modes: accept or abandon.

Key insight: acceptances rise only modestly with $p$, but backlog and review volume drop sharply. This model is more realistic but still has only one class of papers.

Quality buckets: class-dependent hazards and patience. When submissions split into quality classes (e.g., “great/average/bad”) with different per-call completion hazards $p_i$ and potentially different patience limits $T_i$, Little’s law applies to each class separately:

where $\lambda_i = N\pi_i$ is the arrival rate for class $i$ with share $\pi_i$. The backlog and acceptance shares become

Key insight: reweighting hazards across classes mainly shifts the composition of acceptances and backlog, while total throughput remains roughly fixed at $N$ (since $\sum_i \lambda_i = N$).

Slow growth in arrivals ($g$ multiplicative increase per call). We can immediately also estimate the impact of growth in the arrival rate. Over a window roughly equal to the mean time in system $W\approx 1/p$, a sustained arrival growth $g$ compounds into an approximate $g \cdot W \approx g/p$ increase in the pool level (rule-of-thumb).

Caveats, Assumptions, and Gotchas.

• The hazard $p$ bundles many realities (desk reject, area-chair filtering, author revision time). If those change, so does $W$.
• Little’s law reveals immediately that steady-state acceptances follow arrivals, not the per-call acceptance hazard.
• If resubmissions between different venues happen with delays, one can model them as additional stages; Little’s law still applies stage-wise.
• If arrivals are highly seasonal (e.g., co-located deadlines), replace the $g/p$ heuristic with the exact weighted-sum solution or simulate.

Little’s Law in Action

Below we visualize Little’s law with a simple funnel model, where papers arrive at the top and then go through the system, eventually being accepted or abandoned.

Details and Further Discussion

We will now discuss the above model in more detail and provide additional insights. At the very end we also present a proof of Little’s law.

Assumptions

We make the assumptions from above more precise.

Time unit: one conference call (one submission cycle).

Arrivals: each call injects $N$ new submissions, hence the arrival rate per call is $\lambda=N$.

Completion (“service”): each paper present in a call independently completes (i.e., gets a final accept/abandon decision) with hazard $p$ in that call.

• “No giving up” = a paper continues until accepted;
• “Finite patience” = a paper is abandoned after $T$ unsuccessful calls.

State (queue length): Let $L_t$ denote number of papers currently “in the system” (awaiting final disposition). Then the stock–flow equation is given by

which is exactly a discrete-time queue with batch arrivals $N$ and per-step departure probability $p$.

No-give-up world: geometric time in system

If authors never give up, each paper’s time in system is distributed as Geometric($p$) on ${1,2,\dots}$ with mean

With $\lambda=N$ per call, Little’s law yields

As such, steady-state throughput (accepted papers per call) equals the arrival rate:

Finite patience $T$: truncated geometric & subflows

Let each paper give up after $T$ calls if not accepted. Now there are two exit modes: accept or abandon.

Probability of eventual acceptance. Let us first compute the probability that a paper is eventually accepted (within $T$ calls):

All-exits. Next we compute the time in system irrespective of the exit mode (accept or abandon):

Now we first apply Little’s law to the whole system (all exit modes), to obtain

And next, we apply Little’s law to the subflows arising from the exit modes accept and abandon:

Accepted subflow.

Throughput is given by

Conditional mean time given acceptance is given by

Population of papers currently in-system that are destined to be accepted:

Abandonment subflow.

Throughput is given by

Time in system is given by

Population of papers currently in-system that are destined to be abandoned:

Check. $L_{\text{acc}}+L_{\text{abn}}=L_{\text{all}}$.

Observation. Increasing $p$ modestly boosts $\lambda_{\text{acc}}$ (since $1-(1-p)^T$ saturates), but it significantly lowers $W_{\text{all}}$ and hence $L_{\text{all}}$: far fewer papers sitting in the pool at any time.

Quality buckets: class-dependent hazards and patience

If submissions are split into classes (e.g., “great/average/bad”) and decisions prioritize higher quality, you have class-dependent hazards $p_i$ and potentially class-dependent patience $T_i$. Let $\pi_i$ denote the arrival share of class $i$, so per call

Class-wise Little’s law. For each stable class $i$,

where $W_i$ is the mean time in system for class $i$.

Finite patience (class $i$). If class $i$ abandons after $T_i$ calls with per-call accept hazard $p_i$, then

Accepted throughput (class $i$). The per-call accepted rate is

Mixes (shares). The backlog and accepted shares of class $i$ are

and

Special case (equal hazard). If $p_i\equiv p$ for all classes, then for two classes $g, b$ with $\pi_g+\pi_b=1$,

and $\text{BacklogShare}_g = \text{AcceptShare}_g$.

Interpretation. Because $\sum_i \lambda_i = N$ per call is fixed, reweighting hazards mainly shifts the composition of acceptances; total throughput changes little, while total backlog still scales with the average hazard via $W$.

What a small arrival growth $g$ does to the pool

Little’s law says the instantaneous pool level tracks a windowed average of recent arrivals with window length $\approx W$ (see proof below). Hence a sustained per-call growth $g$ in arrivals translates into an approximate level increase of

thus as a rule-of-thumb we obtain:

Note. For precise dynamics with time-varying arrivals $N_t$, the exact solution is a geometrically weighted sum of recent $N_t$’s.

Converting to yearly units

We considered calls as the time unit. However, we can easily convert/rescale to yearly units. If the field has $c$ calls/year:

• Mean time in system:
  • $W_{\text{years}}=\dfrac{1}{pc}$ for the case of no-give-up
  • $W_{\text{all,years}}=\dfrac{1-(1-p)^T}{pc}$ for the case of finite $T$.
• Backlog level in
  • papers: multiply $L$ above by $1$ (dimensionless)
  • paper-years: multiply by $1/c$.

A short proof of Little’s law

Let $Q(t)$ be the number of items in the system at time $t$. Let $a_k$ and $d_k$ be the arrival times and departure times of the $k$-th job respectively, and $W_k \doteq d_k-a_k$ its sojourn times (time in system). We assume that the system is stable/stationary with long-run arrival rate $\lambda$ and finite mean sojourn time

Let

• $A(T) \doteq \abs{\set{k: a_k\le T}}$ denote arrivals by $T$ and,
• $D(T) \doteq \abs{\set{k: d_k\le T}}$ denote departures by $T$.

We further assume rate stability

Area–interval identity. We start with a simple observation. Given any time $t$, let $Q(t) \doteq\sum_k \mathbf 1_{\set{a_k \le t < d_k}}$ denote the number of jobs in the system at time $t$. We can now integrate and swap sum and integral to obtain:

Therefore, the “area” under $Q(\cdot)$ over $[0,T]$ equals the sum of the lengths of the intersections of $[0,T]$ with the jobs’ sojourn intervals. We can now split the jobs into three disjoint groups:

1. jobs that arrive and depart within $[0,T]$: contribute exactly $W_k$;
2. jobs present at time $0$ (arrived before $0$): contribute at most their remaining times inside $[0,T]$;
3. jobs still present at time $T$: contribute at most the elapsed times since arrival up to $T$.

Letting $S(T) \doteq \int_0^T Q(t)\,dt$, with the three groups we now have:

where $B_0$ is the total residual time inside $[0,T]$ of the finitely many jobs present at $t=0$, and $B_T$ is the total elapsed time inside $[0,T]$ of the finitely many jobs present at $t=T$. Note that both $B_0, B_T$ are finite constants, i.e., they do not grow with $T$.

Divide by $T$ and pass to limits. Similar to convergence proofs of, e.g., (stochastic) gradient descent, we now divide by $T$:

and then take the limit as $T\to\infty$. In particular, as $T\to\infty$ we have $\tfrac{B_0+B_T}{T}\to 0$. Note, this also measures how long it takes for the system to reach stability. Now for the sums:

The left sum counts departures within $[0,T]$. We rewrite it suggestively as

by rate stability and the (ergodic/renewal-reward) law of large numbers for ${W_k}$.

The right sum counts arrivals by $T$ and it can similarly be rewritten as

As such we obtain for $\lim_{T\to\infty}\frac{S(T)}{T}$ that

as it is sandwiched between the two limits from above.

Finally, observe that the left-hand side is the time average of the number of jobs in system:

Therefore,

A few remarks are in order.

Remarks.

1. No assumptions on service-time distribution, number of servers, or service order were used. We only needed stability and finiteness of the relevant limits.
2. The same argumentation can be applied to subflows (e.g., “accepted only”, or splitting into “great/average/bad” papers), yielding $L_i=\lambda_i W_i$ for each stable class $i$.

Disclaimer 1: Stating the obvious or the most likely outcome is not an endorsement.

Disclaimer 2: This is not investment or tax advice, a recommendation or call for any specific action, or an opinion piece; your mileage may vary.

Disclaimer 3: The math is simplified for the sake of intuition; you can go arbitrarily complex with (mildly) improved precision but the main mechanisms are the same.

Introduction

Recently, I had a conversation with a colleague about the skyrocketing rents in Berlin and why it seems impossible to build more affordable housing. They argued that greed from developers and landlords is one of the main reasons, but I wondered if basic economics—like construction costs and interest rates—might not already explain much of what is seen. To explore this, I did some first-principles, back-of-the-envelope calculations, focusing solely on covering costs without any profit motive. We are assuming no subsidies, no self-use scenarios, no feeding the mortgage (also known as negative gearing), and “cold rents” (excluding utilities like heating, water, etc.). If you do not care for the math, just check the estimations in the results section.

The executive summary boils down to: In today’s high interest rate regime by historical standards (even at low-end rates of 3-4%) combined with median construction costs around €4,470/sqm in Germany, sustainable rents are pushed to levels that strain affordability, making new projects barely viable without losses or at least significant risk thereof. Coincidentally, there was also an article in the Tagesspiegel quite recently that looked at the economics of rents and their findings align with the ones below.

All numbers are based on publicly available data; see references at the end of the post.

Covering Costs vs Actual Investments

This analysis focuses on minimum rents that cover only opportunity costs and basic ownership expenses, without profit margins, expected property appreciation, and risk premiums. It represents a “break-even” scenario, assuming investors aim merely to avoid losses. This is a reasonable minimum requirement as otherwise investors would not invest in the first place and put money elsewhere. As a second-order effect this also holds true for institutional investors in the broader sense (including pension funds, governments, etc.) as they face similar opportunity costs and also these investors need to aquire the funds-to-be-allocated from somewhere (be it money paid into a pension fund, taxes collected, or simply debt) and have to answer their constituents and stakeholders.

In contrast, actual investments typically seek profits, incorporating risk premiums, management fees, and anticipated appreciation. Our model is conservative by underestimating required rents for profit‑driven scenarios—real‑world investments might demand higher rents to be viable. However, it is not conservative in ignoring appreciation; by purposefully excluding it, we avoid overestimating feasibility in times of uncertain growth potential and market conditions, or more broadly in times of risk aversion. Moreover, appreciation only affects rents if the investor or owner is willing to take lower rents than required to cover costs, i.e., negative cashflows in anticipation of future appreciation. We will discuss this point in the next section.

Feeding the Mortgage and Negative Gearing

As mentioned in the introduction, our analysis assumes no “feeding the mortgage” (negative gearing), where rental income is less than expenses, and the owner covers the shortfall. This practice, common worldwide for tax benefits, often allows losses to be deducted against other income. We explicitly exclude it here as we focus on break-even scenarios without self-use, appreciation bets, or subsidies; negative gearing may be understood as functioning akin to an indirect subsidy, realized through the tax system. Nonetheless, for completeness, we will briefly discuss it below so that its effects are clear.

The tax mechanisms for negative gearing are country-specific. In Germany, interest and losses from rental properties can be deducted against other income. For example, if a property costs €5,000/sqm with 4% interest, monthly costs might be €20/sqm, but if rent is only €15/sqm, the owner “feeds” €5/sqm—potentially tax-deductible, encouraging investment despite losses, especially if expecting capital gains.

Example: Rental income €15,000/year, costs €25,000/year, loss €10,000 → taxable income reduced by €10,000, saving ~€4,200 at 42% bracket. The state effectively co-funds the feeding.

The example above is more that of a private investor and institutional investors may have very different and highly complex structures. Moreover, negative gearing in Germany is not as aggressive as in some other countries like Australia. It is also important to note, that negative cashflows come with (substantial) risks, including financial strain if property values do not appreciate as expected, higher interest rates increasing losses, or changes in tax laws reducing benefits. Why do investors do it anyway?

• Capital Gains Play: Accept short-term losses hoping the property’s value will rise enough to offset them.
• Tax Deductions: In some countries, deduct the loss from other income, reducing your tax bill as discussed above.
• Portfolio Growth: Enables buying more expensive properties, compounding returns if prices rise.

However, negative cashflows require investors to take realized losses (“money gone for sure”), so that if conditions are unfavorable it might be hard to convince investors to take the risk; in particular if the investment is leveraged, which exacerbates the loss relative to the equity base.

Key Results

Summarizing the calculations from below, here are the minimum cold rents needed to cover costs (at 3% interest and 25% cost factor as defined below), without profits:

• Median new-build construction: 13.96 €/sqm/month (median construction cost of 4,470 €/sqm)
• Mitte (center) existing: 25.00 €/sqm/month (average purchase price of 8,000 €/sqm)
• Charlottenburg existing: 19.69 €/sqm/month (average purchase price of 6,300 €/sqm)
• Spandau (outer) existing: 10.00 €/sqm/month (average purchase price of 3,200 €/sqm)

Current Berlin rents (12.50-20.00 €/sqm) often imply lower sqm prices than actual costs, suggesting unsustainability for new projects (either construction or renting out purchased properties) while older projects from a while back might benefit from cheaper financing, lower construction costs, etc and hence allowing for lower rents. This is also reflected in the building permits, which are down and far away from matching the demand (exacerbating shortages) as often the economics do not work out.

Note that the quoted rents above are also consistent with the folklore rule-of-thumb that every 1000 €/sqm increase in price requires an increase of 4 €/sqm/month in rent. This comes out to an effective interest rate of 3.84% at 25% cost factor (or flat 4.8% at 0% cost factor).

Market Data

In the following we briefly summarize some of the data that we will use in the analysis.

Current Rent Situation in Berlin

Based on 2024-2025 data, average cold rents (excluding utilities) in Berlin are:

• Citywide average (existing apartments): 12.50 €/sqm/month
• New-build apartments: 18.00 €/sqm/month
• Mitte (center): 20.00 €/sqm/month
• Charlottenburg: 15.50 €/sqm/month
• Spandau (outer): 9.50 €/sqm/month

Current Square Meter Prices

Based on 2024-2025 data, average purchase prices for existing apartments in Berlin are:

• Citywide average: 4,000 €/sqm
• Mitte (center): 6,400 €/sqm
• Charlottenburg: 4,960 €/sqm
• Spandau (outer): 3,040 €/sqm

and average prices for new-build apartments are:

• Citywide average: 8,300 €/sqm
• Mitte (center): 14,500 €/sqm
• Charlottenburg: 11,400 €/sqm
• Spandau (outer): 6,000 €/sqm

Median construction costs in Germany are 4,470 €/sqm (for multi-family housing, incl. VAT) (Mieterbund Report, Figure 11).

Building Permits in Berlin

The economic constraints we have discussed manifest in Berlin’s building permit trends. According to the official statistics office, Berlin approved 9,772 dwellings in 2024 (−38.5% year-on-year) (source).

Nationally, Germany issued about 215,900 residential building permits in 2024 (−16.8% year-on-year)—the lowest since 2010 and far below the 400,000‑unit target (Destatis). A slight rebound was reported in April 2025 to roughly 18,500 permits (+4.9%) (Destatis), but monthly levels remain insufficient.

Detailed Analysis

The following sections explain the natural constraints, formulas, and scenarios in detail. Later below there is also an interactive calculator that allows you to play around with the parameters and explore various scenarios.

Natural Constraints

In this section, we outline the fundamental economic constraints that shape feasible rent and price configurations in the housing market. These arise from basic principles: costs must be covered, prices cannot defy construction realities, and rents must remain affordable for tenants. Note that all rents discussed are “cold rents,” excluding utilities such as heating, water, electricity, internet, etc. We are considering a pure buy-to-rent or build-to-rent model without self-occupancy or profit motives.

Opportunity Cost of Capital

For buying-to-rent or building-to-rent to be economically viable, we need capital, either obtained via a loan (debt), e.g., from a bank or via our own capital (equity). In both cases we have to pay interest on that money, either in the form of actual interest to the bank or in the form of opportunity cost, which is essentially the return you forgo by not investing the money somewhere else; we refer to both costs here as opportunity cost.

The monthly rent per square meter $r$ must at least cover the opportunity cost of the capital invested in the property per square meter, plus additional ownership costs (maintenance, property taxes, etc.). This is expressed as:

where:

• $p$: price per square meter (€/sqm)
• $i$: annual interest rate
• $c$: cost factor (maintenance, taxes, etc.)

Meaning: Below this value the rent does not cover the costs of ownership.

Replication Cost Constraint

Property prices cannot sustainably fall below the cost of building or obtaining a new equivalent property:

where $rc$ is the replication cost (€/sqm), i.e., construction costs or cost of buying.

Meaning: The price $p$ to construct or buy a square meter is at least $rc$.

Affordability Constraint

Rent must be affordable based on income. Typically, housing costs should not exceed 33% of net income:

where:

• $n$: monthly net income (€)
• $s$: square meters needed

Note that the 33% is arbitrary but a good estimate; in the calculator below one can simply dial in the desired maximum rent, either via the monthly income or the square meters needed, if one does not agree with the 33% estimate, which admittedly becomes more and more challenging to meet.

Meaning: Rents above this threshold are unaffordable.

Minimum Required Rent

The minimum required rent, based on opportunity cost and replication cost, is calculated at the replication cost price:

This value represents the lowest feasible rent required to cover costs.

Interactive Calculator

Feel free to play around and choose values that you think are reasonable. In particular, the interest rate has significant impact on the required rent per sqm.

The sliders adjust:

• Interest Rate: Annual opportunity cost or loan rate (i).
• Cost Factor: Additional ownership costs as a percentage (c).
• Replication Cost: Minimum construction/purchase price per sqm (rc).
• Net Income: Monthly net income for affordability (n).
• Space Needed (sqm): Living space required for affordability (s).

The light green area is the feasible region where all constraints are satisfied. Adjust the sliders to see how parameters affect feasibility.

Common Scenarios

Using current Berlin real estate data (as of 2024-2025), we explore reasonable configurations. We assume a cost factor $c = 0.25$ (25% for maintenance, taxes, etc.) and a (relatively) low interest rate $i = 0.03$ (3%); this is also rather conservative for the opportunity cost of equity. All calculations use the minimum rent formula:

where $p$ is the effective price per sqm (either construction cost or purchase price).

Median Construction Cost Scenario

• Median construction cost across Germany: $p = 4{,}470$ €/sqm (for multi-family housing, incl. VAT) (Mieterbund Report, Figure 11)
• Interest rate: 3%
• Minimum required rent: $r_{min} = \left( \frac{4{,}470}{12} \times 0.03 \right) \times 1.25 \approx 13.96$ €/sqm/month

This represents the lowest sustainable rent for new builds at median costs, just covering opportunity costs without profit.

Berlin Purchase Scenarios

Purchase prices vary by location. We calculate the minimum rent needed to cover costs for existing and new-build properties.

City Center (Mitte)

• Existing: $p = 8{,}000$ €/sqm → $r \approx 25.00$ €/sqm/month
• New-build: $p = 14{,}500$ €/sqm → $r \approx 45.31$ €/sqm/month

Charlottenburg

• Existing: $p = 6{,}300$ €/sqm → $r \approx 19.69$ €/sqm/month
• New-build: $p = 11{,}400$ €/sqm → $r \approx 35.63$ €/sqm/month

Outer District (Spandau)

• Existing: $p = 3{,}200$ €/sqm → $r \approx 10.00$ €/sqm/month
• New-build: $p = 6{,}000$ €/sqm → $r \approx 18.75$ €/sqm/month

These minimum rents assume covering spot costs only (no profit motive). Higher interest rates (e.g., 4% for private loans) would increase required rents accordingly. Conversely, many properties were financed at lower interest rates and/or built at lower construction costs years ago, significantly reducing the required rent per sqm.

Rent-implied Prices

Based on 2024-2025 data, average cold rents (excluding utilities) in Berlin are:

• Citywide average (existing apartments): 12.50 €/sqm/month
• New-build apartments: 18.00 €/sqm/month
• Mitte (center): 20.00 €/sqm/month
• Charlottenburg: 15.50 €/sqm/month
• Spandau (outer): 9.50 €/sqm/month

To connect this to our analysis, we perform an “inverse” calculation: given the rent r, what implied price per sqm (p) would justify it under the opportunity cost constraint? Solving the formula:

Using $i=0.03$ and $c=0.25$ (as before):

• Citywide average: p ≈ 4,000 €/sqm (below median construction cost of 4,470 €/sqm and city average purchase of 5,500 €/sqm)
• New-build: p ≈ 5,760 €/sqm (below city new-build average of 8,300 €/sqm)
• Mitte (center): p ≈ 6,400 €/sqm (below actual Mitte existing purchase of 8,000 €/sqm)
• Charlottenburg: p ≈ 4,960 €/sqm (below 6,300 €/sqm)
• Spandau (outer): p ≈ 3,040 €/sqm (slightly below 3,200 €/sqm)

These implied prices are often lower than actual replication (construction or purchase) costs from the market data. This suggests that at current rents, especially in central areas, owners may not fully cover opportunity costs unless interest rates are very low, costs are minimized, or significant depreciation is expected or has occurred.

References

1. Investitionsbank Berlin – Housing Market Report 2024 (Summary, EN)
2. Guthmann Estate – Berlin Real Estate Market Report (2025)
3. InvestRopa – Average Rent & Price per m² in Berlin (2025)
4. InvestRopa – Average Rent in Berlin by District (2025)
5. CBRE – Berlin Housing Market Report 2025
6. IfW Kiel – GREIX Rental Price Index Q2 2025
7. Integra Dom – Apartment Rental Prices in Germany, Q3 2024
8. The Guardian – Berlin’s Housing Crisis and Furnished Rental Market (2025)
9. The Berliner – Berlin Rent Increases Outpace the Rest of Germany (2024)
10. Statistik Berlin-Brandenburg – Building Permits Press Release (H1 2025)
11. BBU – Building Permits in Berlin, Jan–Jul 2024
12. Reuters – Germany’s Residential Building Permits Fall to 2010 Low (2025)
13. Destatis – Building and Housing Statistics (2025)
14. REFIRE – Germany’s Housing Pipeline Crumbles as Permits Plunge
15. Mieterbund Report, Figure 11
16. Tagesspiegel - Reich und raffgierig?: Sieben überraschende Erkenntnisse über Deutschlands Vermieter

Introduction

The Frank-Wolfe (FW) algorithm is an important method for constrained (first-order) convex optimization, especially when projections are costly. A critical and often debated component of FW is the choice of step-size $\eta_t$. Basically, there are two types of step-size strategies: so-called open-loop strategies that do not require any feedback from the function and are fixed ahead of time, not adapting at runtime, and so-called closed-loop strategies that “interact” with the objective function. The former are typically much cheaper, while the latter often possess superior convergence performance.

Since the inception of the Frank-Wolfe algorithm, the “standard” open-loop step-size has been $\eta_t = \frac{2}{t+2}.$ More generally, step-sizes of the form $\eta_t = \frac{\ell}{t+\ell}$ for some integer $\ell \ge 2$ have been analyzed. While these provide an $\mathcal{O}(1/t)$ convergence rate in general, recent work [WKP2023, WPP2024] has shown that under certain “growth conditions,” these fixed-$\ell$ step-sizes can achieve much faster rates—up to $\mathcal{O}(t^{-\ell})$.

The catch is that there is no single “best” $\ell$, and there is—as expected—a tradeoff: While for the asymptotic convergence rate, larger $\ell$ are better, we pay a price for this: namely, an initial burn-in with suboptimal convergence whose length depends on $\ell$. Thus, a larger $\ell$ might be great for one problem structure (like strong $(M,1)$-growth, where up to linear rates are possible), but not for others. This leads to a practical dilemma: which $\ell$ should you pick if you don’t know the specific growth properties of your problem beforehand?

Beyond Fixed-$\ell$: Towards an Adaptive Open-Loop

To address this issue, in [P2024] a new open-loop step-size strategy of the form \(\eta_t = \frac{2 + \log(t+1)}{t+2 + \log(t+1)}\) was proposed, albeit without proof of convergence or analysis of expected properties; it was a remark complementing a new adaptive closed-loop strategy. In our recent paper, Adaptive Open-Loop Step-Sizes for Accelerated Convergence Rates of the Frank-Wolfe Algorithm, we remedy this and in fact provide a much broader convergence analysis of a wide range of open-loop step-sizes for the Frank-Wolfe algorithm. Instead of a fixed $\ell$, we propose a more general open-loop step-size scheme:

where $g(t)$ is a non-decreasing function of the iteration count $t$. The idea is to let $g(t)$ “adapt” (or rather, grow) with $t$, potentially capturing the benefits of larger $\ell$ values as the optimization progresses.

To make this work, we require two natural properties from $g(t)$:

1. $g(t)$ has to be non-decreasing and $g(t) \ge 2$ (the latter is a technical condition to ensure compatibility with the standard open-loop strategy and in particular $\mathcal O(t^{-1})$ convergence in general.)
2. The sequence $\eta_t = \frac{g(t)}{t+g(t)}$ itself is non-increasing (or equivalently, $\frac{t}{g(t)} \le \frac{t+1}{g(t+1)}$).

A new open-loop step-size

While the analysis holds more broadly, we are in particular interested in the log-adaptive open-loop step-size, where we set:

leading to the aforementioned step-size strategy:

This choice satisfies both our requirements from above. Moreover, using this choice, we obtain optimal rates without line search or knowledge of parameters in a wide range of growth settings:

(Rates in the table are for the suboptimality gap \(f(x) - f(x^\esx)\) and \(\tilde{\mathcal{O}}(\cdot)\) hides polylog factors)

Essentially, the log-adaptive step-size performs at least as well (up to polylogarithmic factors) as any fixed-$\ell$ choice, and in the strong growth settings, it can significantly outperform them or match the best possible rate achievable by tuning $\ell$, doing line search, or picking an adaptive closed-loop strategy. For instance, in the Strong $(M,1)$ growth setting, its asymptotic convergence rate approaches a linear rate in the limit.

Note. If the log-adaptive step-size does not meet favorable function properties or properties of the feasible region, its performance simply collapses to that of the standard rule \(\eta_t = \frac{2}{t+2}\).

The Key Lemma

The key insight behind these results lies in extending the analytical framework previously used for fixed-$\ell$ step-sizes from [WPP2024] (see also [WKP2023]) and providing a new, stronger cumulative product bound. For those familiar with [WPP2024], we obtain the following strengthened bound:

For \(S \in \mathbb{N}_{\ge 1}\), \(\epsilon \in ]0, g(S)[\), and \(t \in \mathbb{N}_{\ge S}\): \[ \prod_{i=S}^t \left(1-\left(1-\frac{\epsilon}{g(i)}\right) \eta_i\right) \le \left(\frac{\eta_t}{\eta_{S-1}} \right)^{g(S) - \epsilon}.\]

This refinement, when $g(t)$ grows like $\log(t+1)$, allows us to derive the improved and more robust convergence rates.

Numerical Experiments

In the following, we provide an excerpt from our numerical experiments to demonstrate the performance of the log-adaptive strategy. Here we will only depict convergence in the Frank-Wolfe gap

which is a (standard) observable dual gap measure that can be used as a stopping criterion; see the paper for other measures such as the primal (suboptimality) gap or the primal-dual gap.

Note. While we primarily considered two types of experiments in the paper, the log-adaptive step-size is now also included in the FrankWolfe.jl Julia package and has been tested on a wide variety of problems.

Constrained Regression

We tested a constrained regression problem on the Boston-housing dataset, confining the regression coefficients to $L_p$-balls with $p=2$ and $p=5$. We considered the cases where the unconstrained optimum is inside (here we do not expect accelerated convergence) and outside the feasible $\ell_p$-ball (here we expect accelerated convergence). The objective is of the form:

The results are depicted below.

Figure 1: Frank-Wolfe gap for constrained regression, unconstrained optimum inside the feasible region. (L: $L_2$-ball, R: $L_5$-ball)

Figure 2: Frank-Wolfe gap for constrained regression, unconstrained optimum outside the feasible region. (L: $L_2$-ball, R: $L_5$-ball)

Collaborative Filtering

Our second test is collaborative filtering, with the objective

using a Huber loss $H$ over the MovieLens 100k dataset, with nuclear norm ball radii $\beta=1000$ and $\beta=3000$. We expect higher convergence rates when the radius is reasonably small.

Figure 3: Frank-Wolfe gap for collaborative filtering. (L: radius 1000, R: radius 3000)

As can be seen from the plots, across these tests, the log-adaptive step-size ($g(t)=2+\log(t+1)$) consistently performed on par with or better than the fixed step-sizes ($g(t)=2$ and $g(t)=4$). In scenarios aligning with (strong) growth (like the regression problem where the unconstrained optimum lies outside the feasible region, or collaborative filtering with a smaller radius), it often showed notably faster convergence for the primal-dual gap, the primal (suboptimality) gap, and the Frank-Wolfe gap, in line with the predictions from theory.

Wrap-up

The log-adaptive open-loop step-size $\eta_t = \frac{2 + \log(t+1)}{t+2 + \log(t+1)}$ offers a compelling alternative to traditional fixed-$\ell$ step-sizes for the Frank-Wolfe algorithm. It is simple (in fact, trivial) to implement, requires no prior problem knowledge for parameter tuning, and demonstrates robust, often superior, performance both theoretically and empirically. To foster adaptation and community feedback, we have also incorporated these adaptive open-loop step-sizes into the FrankWolfe.jl package.

References

[WKP2023] Wirth, E., Kerdreux, T., & Pokutta, S. (2023). Acceleration of Frank-Wolfe algorithms with open loop step-sizes. Proceedings of AISTATS. arXiv:2205.12838, Poster

[P2024] Pokutta, S. (2024). The Frank-Wolfe algorithm: a short introduction. Jahresbericht der Deutschen Mathematiker-Vereinigung, 126, 3–35. arXiv:2311.05313, Published version

[WPP2024] Wirth, E., Peña, J., & Pokutta, S. (2024). Accelerated Affine-Invariant Convergence Rates of the Frank-Wolfe Algorithm with Open-Loop Step-Sizes. to appear in Mathematical Programming A. arXiv:2310.04096, Published version

[WPP2025A] Wirth, E., Peña, J., & Pokutta, S. (2025). Adaptive Open-Loop Step-Sizes for Accelerated Convergence Rates of the Frank-Wolfe Algorithm. preprint. arXiv:2505.09886

[WPP2025B] Wirth, E., Peña, J., & Pokutta, S. (2025). Fast Convergence of Frank-Wolfe algorithms on polytopes. to appear in Mathematics of Operations Research. arXiv:2406.18789