A New Educational Paradigm

Preparing the Thought Engineers of Tomorrow

ReasonRun

“I think the really lovely mixture of mathematical reasoning and computation used in the sample solution I read is terrific . . . It's what mathematics is going to become, arguably already has become.”

— Senior Editor, American Mathematical Society
Scroll
Hands typing on keyboard with binary codeThe Translator
Hand touching geometric wireframe structureThe Architect
The Calling

The Era of the
‘Translator’ is Over

As AI automates routine computation and syntax, the value of human labor shifts. We are moving from an era of Translation (writing code) to an era of Structural Mathematical Reasoning (logical modeling).

The future belongs to “Thought Engineers.”

Those who use wide-scope human experience to architect new logical frameworks [Reason], then use computation to rigorously navigate the countless paths within those models [Run].

Data Point

AI agents can now run autonomous workflows to generate patches and fix bugs without human intervention.

Notes

The deeper problem isn't just that AI writes code. It's that reasoning itself gets externalized.

The deeper problem isn't just that AI writes code. It's that reasoning itself gets externalized — future generations become less and less capable of reasoning on their own. And since AI, having no intuition, remains severely limited in wide-scope reasoning — modelling real-world phenomena, developing new methods — this leaves society without the human capacity to sustain its most critical infrastructure: autonomous vehicles, medical AI, financial systems. That's why we're not just building a better coding course. We're addressing a civilizational gap.

The Recipe Trap

The “Recipe Trap” in STEM Education

Syntax over Structure

Learning languages that AI now speaks better.

Recipes over Reasoning

Memorizing steps rather than understanding principles.

The Result

A “Reasoning Gap.” Students cannot verify AI outputs or model complex systems.

Current education creates students vulnerable to professional obsolescence before they graduate.

Notes

For decades, CS education focused on coding, or, at best, programming. Generative AI has driven the marginal cost of both to near zero.

In the last decades, most CS curricula were designed around a simple premise: teach students to input instructions in a specific language, or, at best, how to design algorithms. That made sense when both were scarce. But AI has inverted the equation. Code generation is now trivially cheap, and as AI agents start winning informatics competitions, algorithm design also becomes cheaper. What's expensive is the ability to model, architect and reason about systems. Current pedagogy produces graduates who can implement a sorting algorithm, maybe even tweak it a little, but lack the creativity and mental clarity needed to create or even understand a novel idea. The “recipe trap” — learn syntax, memorize patterns, pass exams — produces exactly the skills AI replaces first. Meanwhile, deeper skills AI cannot replicate — abstraction, reasoning, modelling — are barely taught at all. This is the gap Reason & Run addresses.

The Solution

Symbolic Computational Modelling

Reason
Wide-scope human
experience & logical
architecture.
Feedback Learning Loop
Run
Computational
navigation of
countless paths.

We don't just teach code. We teach students to architect logical frameworks, then use computation to explore them.

The Outcome: The “Thought Engineer” — An AI-resilient mind capable of high-value creative technical work.

Notes

The loop is not a metaphor. It is the literal structure of every RR module.

The same feedback loop is at the core of the Reason & Run experience. Students begin with a Reason phase: trying to understand primary sources and define a mathematical model. In the Run phase they build a computational model which, by execution, can be used for exploring the mathematical model. The findings of the exploration lead to the feedback loop, a refinement of the mathematical model, a deeper understanding of its hidden properties. Often this comes in the form of a conjecture that should be validated by a solid mathematical argument. The feedback loop means alternations of Reason and Run phases, after each cycle both the mathematical and the computational models get refined.

The Engine

The Engine: eMaude

Built on 30 Years of Oxford & IMAR Research.

Competitors (Python)

01020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
class Config:
    def __init__(self, n = 0):
        self.boxes = [n]
        self.sumprod = 0

    def __hash__(self):
        return hash(tuple([self.sumprod, tuple(self.boxes)]))

    def __eq__(self, other):
        return hash(self) == hash(other)

    def __ne__(self, other):
        return not self == other

    def __str__(self):
        return '- ' + str(self.boxes) + ', with sumprod = ' + str(self.sumprod)

    def isFinal(self):
        return all(b == 1 for b in self.boxes)

    def splitAt(self, b, i):
        c = Config()
        c.boxes = self.boxes.copy()
        c.boxes.remove(b)
        c.boxes.append(i)
        c.boxes.append(b-i)
        c.boxes.sort(reverse = True)
        c.sumprod = self.sumprod + i*(b-i)
        return c

    def divide(self):
        if self.isFinal():
            return self
        else:
            return {self.splitAt(b, i) \
               for b in self.boxes \
               for i in range(1, b // 2 + 1) \
               if b > 1}

def divideAll(configs):
    return set().union(*map(Config.divide, configs))

def done(configs):
    return all(c.isFinal() for c in configs)

def printConfigs(n):
    configs = {Config(n)}
    k = 0
    while not done(configs):
        print('Configurations for n = ' + str(n) + ' obtained after ' + \
              str(k) + (' iteration:' if k == 1 else ' iterations:'))
        for c in configs:
            print(c)
        print('-----------------------------------')
        configs = divideAll(configs)
        k += 1
    print('Final configuration(s) for n = ' + str(n) + ':')
    for c in configs:
        print(c)

if __name__ == '__main__':
    printConfigs(7)
    printConfigs(10)
    printConfigs(15)

RR (eMaude)

01020304050607080910111213141516
mod PARTITIONING-BALLS is
  protecting NLIST .
  --- prepares the initial box as a list
  protecting ONEBOX .
  sort Config .
  var S : Int .
  vars L L' L1 L2 : List{Int} .
  op <_|_> : List{Int} Int -> Config .
  crl < L 0 L1 L2 0 L' | S > =>
      < L 0 L1 0 L2 0 L' |
        S + size(L1) * size(L2) >
    if onebox(L1 L2) and
       --- (L1 L2) is one box, no 0 separators
       (L1 =/= nil) and (L2 =/= nil) and
       size(L1) <= size(L2) .
endm

Moat

The Computational Engine

A R&R adaptation of the logic-based industrial-strength computer language Maude.

Uncopyable Expertise

Developed by Prof. Răzvan Diaconescu, key architect of the CafeOBJ ecosystem.

Notes

Our secret sauce is eMaude — a R&R adaptation of the logic-based industrial-strength computer language Maude, built by the key architect of the CafeOBJ ecosystem.

Maude is a world-leading logic-based programming language developed at Stanford and Illinois over three decades. It enables formal logical modeling and verification of complex systems — the kind of deep structural reasoning that AI cannot replicate. Our adaptation, eMaude, transforms the Maude system into a computational tool adapted to the Reason and Run method and curriculum. Competitors cannot copy this curriculum because it requires the specific deep expertise of Prof. Răzvan Diaconescu, a key architect of the CafeOBJ language and system and longtime collaborator on the Maude project. The foundation of this expertise, rooted in sophisticated mathematics, exists within a handful of other researchers worldwide, who are anyway lacking the particular expertise in the Reason & Run paradigm only Prof. Diaconescu and his close circle have. This irreplaceable expertise creates a durable competitive moat that no amount of funding can easily replicate.

The Platform

A Learning Community That Grows Together

Where Logic Meets Execution

Seamless eMaude Environment: Run reasoning in real-time.

Deep Integration: Methodology develops how a student thinks, not just if the code runs.

AI-Augmented Feedback: Instant feedback on logical structure and clarity of presentation.

R&R Problem-Solving Interface

R&R Problem-Solving Interface

Notes

ReasonRun is engineered as a mid to high-performance Education-as-a-Service platform that bridges the gap between complex formal logic and intuitive learning.

ReasonRun is engineered as a mid to high-performance Education-as-a-Service platform that integrates complex formal logic with intuitive learning with a focus on clarity. The architecture centers on an eMaude Execution Service — a computational logic environment that allows students to "run" their reasoning in real-time. By integrating the reasoning and programming layer into every step, the methodology develops how a student thinks and experiments, not just whether their code executes or whether a math solution is reached. This is the key differentiator — we're not grading outputs, we're developing cognitive architecture.

Explore

Reason & Run — A Strategy for Solving Hard Problems

These problems illustrate the kind of reasoning R&R develops — logic, structure, and creative problem-solving based on computational experimentation. No memorization. No recipes. Just thinking and exploration.

Every problem on this platform is designed to be solved with the ReasonRun method — a cycle of modelling, computing, pattern-finding, and proving. They're the kind of challenges our students will tackle to build AI-resilient thinking.

Reason

Model the problem

Run

Build and compute

Reason Again

Find the pattern

Prove

Validate with rigor

A Logical Puzzle

A self-referential logical puzzle. Shows how much clarity formal logic brings to the table.

ColorWar

Live

A territorial strategy game. Two players, asymmetric powers, one grid. Every move demands structural thinking.

Play now →

Partitioning Balls

A solitaire game. A fascinating process, full of surprises.

Notes

We center our lessons around such problems because they are the most efficient pedagogical device for developing the technical skills a thought engineer needs.

We didn't choose to center our lessons around these kind of puzzles by accident. First, being focused on technical skill, these lessons obviously need to contain some kind of problem-solving. And problems from the field of elementary and recreational mathematics provide, from a pedagogical viewpoint, the best terrain for developing the skills we're looking for most efficiently. This is because, unlike for real-world problems, the characteristics of mathematical problems (such as level of complexity) can be more easily fine-tuned to one's needs while remaining intellectually engaging. In particular, mathematical puzzles provide the easiest path towards an appreciation of the beauty of mathematical thinking, appreciation which is essential if one wants to develop solid reasoning skills (i.e. the base for all other technical skills) in an efficient manner.

Social Impact

Education as a Force for Equity

Partnerships with foundations & corporations to fund scholarships for underserved communities.

Philanthropists get impact tracking.

Corporations get a pipeline of “Thought Engineers.”

Democratization through Access.

Notes

The ability to integrate wide-scope reasoning with computing power should not be a privilege reserved for those who can afford elite education.

The ability to integrate wide-scope reasoning with computing power should not be a privilege reserved for those who can afford elite education. R&R is designed from the ground up to democratize access to this transformative skill set, starting with STEM-inclined teenagers. For philanthropists: sponsor cohorts of students and watch them develop into the logical architects society desperately needs — track their progress, attend showcases, witness the direct impact. For corporations: fund scholarships and gain early access to a pipeline of uniquely trained minds. Sponsored students can be offered internships, mentorship from company engineers, and eventual employment pathways — creating a direct bridge from education to industry. This isn't charity — it's strategic cultivation of human potential.

Team

We Reason We Run

Răzvan Diaconescu
Oxford DPhil. 30+ years in formal methods and logic-based computer science. Professor at IMAR (Romanian Academy). Key architect of CafeOBJ, contributor to Maude ecosystem. 4,000+ citations. Inventor of Symbolic Computational Modeling. Author of forthcoming ‘Reasoning and Programming in Elementary Mathematics.’ The mind making R&R possible.
Victor Anastasiu
Serial entrepreneur with previous exit (SkinVision). CEO of Adiem. Proven ability to commercialize deep tech. Experience building and scaling technology companies in health and education. Brings operational expertise to transform paradigm into product.
Alexandru-Tashi-Tsering Diaconescu
Bridge to the User
British and Romanian Math Olympiad medalist. Deeply connected to target users through online schooling experience. Emerging expertise in Symbolic Computational Modeling. Already contributing to curriculum development with math puzzles as ‘grist for the mill.’
Advisory Board (Planned)

We plan to attract global figures who share our line of thought — pioneering global authorities in both tech and math — to validate our frontier-science narrative and spark international attention.

Partner With Us

First generation of RR Students

Key Milestone

Launch MVP, secure beta cohorts, proven traction for Series A.

ALLOCATION_SECTOR

CURRICULUM40%COMMUNITY35%PLATFORM15%OPS10%φ
Notes

Why join us now? First-mover advantage in Symbolic Computational Modelling education.

Why join us now? First-mover advantage in Symbolic Computational Modelling education. 30 years of R&D crystallized into a market-ready curriculum. A defensible pedagogical moat — competitors can't replicate the expertise. A growing homeschool market seeking rigorous STEM alternatives. AI disruption creating urgent demand for reasoning-first education. And a social impact model that creates value for students, families, and society. The goal is to graduate the first generation by the middle of 2027. And in 5 to 10 years, symbolic computational modelling will power countless fields, from drug-discovery companies to autonomous-factory operators to climate research. The students trained now will lead that transition.

The Vision

Computational Reasoning: The New Literacy of a Complex World

In the 19th century and before, literacy meant the ability to read. In the 20th century it expanded to holding and making use of scientific knowledge. In the 21st century, literacy will mean the ability to imagine and reason across complex systems and run those models through computation.

Reason & Run is not only a course, a platform, or a curriculum. It is the foundation of a new intellectual discipline — one that equips human minds to remain essential in an age of intelligent machines.

We are building the environment in which the next generation learns not to consume knowledge, but to construct it; not to follow recipes, but to design frameworks; not to compete with AI, but to direct it.

This is how we prepare the Thought Engineers who will design safer technologies, more resilient economies, and more humane systems. This is how we keep human insight at the center of an automated world.

φ = 0.618y = 0.618x = 0.382
ReasonRun

Let's build the future together

reasonandrun.com
victor@adiem.com
Reason Run · © 2026