A New Educational Paradigm

Preparing the Thought Engineers of Tomorrow

ReasonRun

“...this kind of combination of reasoning and programming... 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 Reasoning (ensuring truth).

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 infinite 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 thirty years, CS education conflated programming with coding. Generative AI has driven the marginal cost of both to near zero.

The standard CS curriculum was designed in the 1990s around a simple premise: teach students to write code. That made sense when code was the bottleneck. But AI has inverted the equation. Code generation is now trivially cheap. What's expensive — and increasingly rare — is the ability to reason about what to build, why it's correct, and how to verify it works. Current pedagogy produces graduates who can implement a sorting algorithm but cannot formalize a specification, construct a proof, or reason about invariants. They are trained as translators in a world that no longer needs translation. The “recipe trap” — learn syntax, memorize patterns, pass exams — produces exactly the skills AI replaces first. Meanwhile, the skills AI cannot replicate — structural reasoning, formal verification, wide-scope 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
symbolic ↔ computational
Run
Computational
navigation of
infinite paths.

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

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

Notes

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

Every module in the Reason & Run curriculum follows the same feedback loop. Students begin in the Reason phase: reading primary sources, constructing formal models, defining specifications, and proving properties. Then they enter the Run phase: implementing their models in code, testing against specifications, and observing where theory meets computational reality. The feedback arrow — Run back to Reason — is where real learning happens. When code reveals an edge case the proof missed, students must return to their formal model and strengthen it. This iterative cycle builds the kind of deep structural understanding that no amount of syntax drilling or tutorial-following can produce.

The Engine

The Engine: eMaude

Built on 30 Years of Oxford & IMAR Research.

Competitors (Python)

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)

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) represents one box,
                           --- no 0 as separators
       (L1 =/= nil) and (L2 =/= nil) and
       size(L1) <= size(L2) .
endm

Moat

Proprietary Tech

A proprietary educational adaptation of the industrial-strength Maude system.

Uncopyable Expertise

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

Notes

Our secret sauce is eMaude — a proprietary educational adaptation of the Maude system, built by the key architect of the CafeOBJ ecosystem.

Maude is a world-leading logic-based programming language developed at SRI International over three decades. It enables formal specification and verification of complex systems — the kind of deep structural reasoning that AI cannot replicate. Our proprietary adaptation, eMaude, transforms the industrial-strength Maude system into an educational platform purpose-built for teaching formal methods to the next generation. Competitors cannot copy this curriculum because it requires the specific deep expertise that only exists within a handful of researchers worldwide. Prof. Răzvan Diaconescu, a key architect of the CafeOBJ algebraic specification ecosystem and longtime collaborator on the Maude project, leads eMaude's development. This combination of proprietary technology and 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

Sandboxed 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, not just syntax errors.

Reasoning Explanation

To solve the pathfinding problem, I will define the base cases and the recursive step for the computePath operation.

The base case for empty data is nil.

For a non-empty list, I will check for validity and then recursively process the rest of the data, appending the transformed item if valid.

op computePath : Data -> Path .

eMaude Execution

mod PATH-COMPUTATION is
  protecting DATA-TYPES .
  op computePath : Data → Path .
  eq computePath(empty) = nil .
  eq computePath(item Data) =
    if valid?(complexOp(item))
    then transform(complexOp(item))
         computePath(Data)
    else computePath(Data)
  fi .
endm

Output

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 bridges the gap between complex formal logic and intuitive learning. The architecture centers on a proprietary eMaude Execution Service — a sandboxed 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

A Glimpse Into How We Think

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

Every problem on this platform is designed to be solved with the ReasonRun method — a cycle of modelling, computing, pattern-finding, and proving. These aren't just games. 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

Coming Soon

A new challenge is being designed.

ColorWar

Live

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

Play now →

Coming Soon

A new challenge is being designed.

Notes

These strategy problems illustrate the kind of reasoning RR develops — logic, structure, and creative problem-solving.

These strategy problems illustrate the kind of reasoning R&R develops — logic, structure, and creative problem-solving. No memorization. No recipes. Just thinking. Every problem on this platform is designed to be solved with the Reason & Run method — a cycle of modelling, computing, pattern-finding, and proving. These aren't just games. They're the kind of challenges our students will tackle to build AI-resilient thinking.

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. Creator of the Reasoning and Programming paradigm. 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 end of 2026. In 5 to 10 years, formal verification will power drug-discovery companies, hospital safety platforms, autonomous-factory operators, climate-risk insurers, and AI-governance tools. The students trained now will lead that transition.

The Vision

The New Literacy of a Complex World

As AI runs hospitals, grids, and markets, society will demand proof, not just probability. Formal reasoning is the seatbelt of complex systems.

The students we educate today will be the architects of that safer, more rigorous world.

Notes

As AI systems begin running hospitals, supply chains, financial markets, energy grids, and legal workflows, society will no longer accept “we tested it and it worked.”

As AI systems begin running hospitals, supply chains, financial markets, energy grids, and legal workflows, society will no longer accept “we tested it and it worked.” High-stakes automation demands proof: that schedules cannot conflict, that treatment plans stay within safety boundaries, that autonomous agents cannot enter dangerous loops. These methods let future systems enumerate all possible worlds, explore them computationally, discover hidden laws, and produce mathematically certified decisions for high-stakes real-world problems. Aerospace. Finance. Healthcare. Autonomous systems. The industries that sustain civilization will require this kind of thinking. The students we educate today will be the architects of that safer, more rigorous world. This is the legacy we are building together.

φ = 0.618y = 0.618x = 0.382
ReasonRun

Let's build the future together

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