ABSTRYN is a deep-tech research company exploring new forms of computation, machine reasoning, and computational discovery.
We investigate how machines can discover abstractions, represent complex knowledge, reason over structure, and contribute to the evolution of computational systems.
Pipeline trace
The deeper question is whether machines can discover structures and abstractions that were never explicitly designed by humans. ABSTRYN exists to investigate that possibility.
Read the thesisBut the vocabulary itself is largely fixed by human design.
Independent research programs under the same company. They approach computational intelligence from different directions, and may eventually intersect.
Machine discovery of computational abstractions
We study whether machines can identify recurring computational structures, synthesize abstractions, verify them, and evaluate their usefulness across unseen problems.
Can machines discover new ways to express computation?
Information as a connected computational structure
We study graph-based representations for understanding relationships, dependencies, context, and complex knowledge.
What becomes possible when knowledge itself becomes a computational structure?
The system studies programs, execution behaviour, semantic representations, and computational structures in order to identify recurring patterns. Those patterns become candidates for new abstractions.
Traditional software analysis often begins with source code. ABSTRYN investigates richer representations — once computation is represented structurally, previously hidden patterns may become discoverable.
These areas contain some of the hardest problems in software engineering, and provide a rich environment for studying whether new abstractions can be discovered, verified, and generalized. The domain may expand as the underlying techniques mature.
A second research loop surrounds abstraction discovery, concerned not only with computation but with what the system knows about computation — what it believes, what evidence supports it, and where an abstraction fails.
The objective is not merely to generate hypotheses. It is to build systems capable of evaluating their own hypotheses.
Entities relate to entities. Concepts depend on concepts. Programs depend on abstractions. Graphs give those structures a computational representation, and make relationships available to reasoning rather than only to storage.
What becomes possible when knowledge is represented as a connected computational structure rather than isolated pieces of information?
The objective is not simply to store more information. It is to investigate whether the structure of relationships itself can become a source of computation.
These questions currently shape the research agenda. They are open, and stated as such.
Novelty, utility, complexity, composability and robustness are not yet a single measurable objective.
Formal guarantees are expensive; search spaces are large. The two need to meet.
Whether structure found in concurrency generalizes to unrelated computational settings.
How a system should represent confidence in structure it has discovered itself.
Structure is discovered, abstracted, verified, generalized, and only then allowed to become part of the computational vocabulary. Then the system searches again.
State what structure is expected to exist, and what would count as evidence for it.
Build the computational machinery required to search for that structure at scale.
Submit every candidate to semantic and mathematical constraints before it is believed.
Test on problems and program structures that played no part in discovery.
Programs, generated systems, benchmarks, execution traces, specifications, and other computational artifacts.
Transform programs into representations that expose structure, behaviour, and relationships.
Search for recurring computational patterns and structural regularities.
Construct candidate abstractions from discovered structures.
Determine whether candidates satisfy the required semantic and mathematical constraints.
Evaluate whether an abstraction stays useful on unseen problems and unfamiliar program structures.
Assess novelty, utility, complexity, composability, robustness, and evidence.
Investigate how validated abstractions become part of evolving programming environments.
Validated abstractions become building blocks for future programs — and for further discovery.
→ continued discovery
Many computational systems are designed to produce answers. ABSTRYN is interested in systems that can also reason about the reliability and boundaries of their own knowledge.
What supports a belief, and how strongly.
How confident the system should be, and why.
Where an abstraction breaks down.
How broadly a discovered structure holds.
What remains unknown or contradicted.
Which experiment is worth running next.
The objective is not simply more computation. It is more informed computation.
Each layer produces artifacts the next layer can constrain, reject, or extend. Structure moves upward only when it survives verification and generalization.
Beliefs, evidence, confidence, failure modes, knowledge boundaries, and the selection of the next experiment.
Held-out program spaces and unfamiliar structures used to test whether a discovery survives outside its origin.
Symbolic and formal machinery for checking semantic and mathematical constraints on candidate abstractions.
Construction of candidate abstractions from discovered structure, with composition and reuse as first-class concerns.
Search over large computational spaces for recurring patterns and structural regularities.
Programs, traces, and knowledge expressed as graphs and semantic structures rather than text.
Layers are research infrastructure under active development.
Architecture, algorithms, representations, verification, experiments, research infrastructure. Not features.
A layered research system in which each stage produces artifacts the next stage can constrain, reject, or extend.
Structural search, pattern mining, graph traversal and inference, synthesis under constraints.
Dependency graphs, intermediate representations, symbolic forms, execution traces, semantic relations.
Formal methods applied to discovered structure — properties established, not assumed.
Benchmarks, ablations, held-out corpora, and reproducible experimental records.
Corpus management, trace capture, experiment tracking, and artifact provenance.
Candidate abstractions are submitted to semantic and mathematical constraints. A candidate that cannot be established is recorded as unverified — not reported as a result.
Corpora, traces, runs, and artifacts are tracked so that a claim can be re-derived from its inputs. Reproducibility is part of the system, not a reporting step.
The question now is whether machines can become participants in that process.
What new forms of computation become possible when machines can discover abstractions for themselves?
For decades, software has been built on abstractions designed primarily by humans. Programming languages, data structures, algorithms, APIs, frameworks, architectures, and computational models give software engineers a vocabulary for expressing computation.
That vocabulary is extraordinarily powerful. It is also largely fixed — new abstractions arrive when people design them, bounded by human attention rather than by what the computational space contains.
ABSTRYN explores a different possibility: that computational abstractions themselves could be discovered by machines.
Instead of asking only how machines can write better programs, we ask how machines can discover better ways of representing and expressing computation.
A system that produces another implementation has produced an artifact. A system that produces a reusable computational concept has produced vocabulary.
Vocabulary compounds. An abstraction that is novel, reusable, generalizable, verifiable and composable changes what future programs can express — and therefore what future discovery can find.
A discovered structure is a hypothesis. Left unverified, a convincing-looking abstraction is a liability: it propagates into everything built on top of it.
So discovery is paired with formal methods and held-out evaluation. What cannot be established is recorded as unestablished.
A system that discovers structure also needs to represent its own relationship to that structure: what it believes, what evidence supports the belief, where the abstraction holds, where it fails, and what remains unknown.
This metacognitive layer is what turns a generator of hypotheses into something closer to an experimental method.
The history of computing is partly a history of increasingly powerful abstractions. Each generation gave humans a new vocabulary for expressing computation. ABSTRYN asks whether the next generation could be discovered computationally.
Machine language
Assemblers
High-level languages
Compilers
Operating systems
Distributed systems
Programming frameworks
Discovered abstractions
Today
ABSTRYN research
Long-term possibility
The boundary between using computational abstractions and inventing computational abstractions begins to blur.
ABSTRYN works across software engineering, programming systems, formal methods, graph computation, knowledge representation, machine reasoning, and metacognitive systems.
Not
How can we automate another workflow?
But
What new computational capability should exist?
Expand the vocabulary of computation.
Build computational systems capable of discovering new abstractions, structures, and forms of reasoning.
What happens when machines become participants in the discovery of computation itself?
We begin with difficult technical questions rather than predetermined products.
We build working computational systems to test those questions.
Mathematical reasoning, formal verification, experiments, benchmarks, evidence.
A method is interesting only if it works beyond the examples that produced it.
Research claims should be measurable, testable, and reproducible.
We are interested in technologies that may take years to mature.
Research claims should be measurable, testable, and reproducible. A method is interesting only if it works beyond the examples that produced it.
Interesting ideas are not enough. They must produce measurable evidence.
A computational structure is not successful because it appears convincing.
A discovered structure must work beyond its original examples.
The objective is to find genuinely useful structure, not reproduce known patterns.
The core research belongs in algorithms, representations, and formal methods.
The company exists to conduct deep technical research and build new computational systems. Any future products, platforms, or commercial applications should emerge from that research.
Research comes first.
Can computational systems discover structure rather than merely process structure humans have already defined?
Discovering hidden structure in programs, systems, and knowledge.
Finding reusable computational concepts that explain many instances.
Establishing correctness, consistency, and semantic validity.
Understanding whether discoveries survive outside their original context.
Using relationships and structure as computational primitives.
Modelling knowledge, uncertainty, limitations, and experiment selection.
Systems that accumulate and build upon discovered abstractions.
Constructing programs or computational structures from specifications, constraints, or observed behaviour.
Mathematical and symbolic techniques for establishing correctness and semantic properties.
How new abstractions can be represented, executed, optimized, and composed.
Understanding the structural and behavioural properties of software systems.
Representing and reasoning over complex networks of relationships.
Computational representations that capture structure, meaning, and dependencies.
Exploring large computational spaces for structures not known in advance.
Mechanisms for uncertainty, self-evaluation, knowledge boundaries, experiment selection.
A programming environment whose vocabulary is not permanently fixed.