PhD Position (mfd) World Models for Software Architecture Synthesis (Constructor Fabric)

Supervisor: Prof. Dr. Alexander Tormasov

About the Position

Constructor Knowledge Labs (CKL) in collaboration with Constructor Technology invites applications for a PhD position in machine learning for software engineering and formal methods on the Constructor Fabric project.

Constructor Fabric turns a companys informal knowledge into production software through a pipeline of composable capability units called gears: requirements architecture product fit framework (G1) application runtime. We are building a World Model over that pipeline a model that does not just generate code but predicts the consequences of an architectural decision: total cost of ownership unintended side effects latency and failure behaviour and whether a proposed composition is even admissible.

The central object is not a digital twin of the application but its formal architectural skeleton: gear contracts (GearSpec) a typed attributed hypergraph of the application (AppGraph) a composition algebra that defines which assemblies are legal and several semantic projections (types protocols resources security) over which properties are proved refuted by counterexample or reported as an explainable gap. All of it is written in a domain-specific language whose syntax trees and graphs we keep in a projectional editor (JetBrains MPS) so the DSL is not a convenience layer it is the thing that defines the models state space and the boundary of what the model is allowed to propose.

What you will work on
Depending on your background one or two of:

• Formal skeleton and composition GearSpec as a contract $(Requires Provides State Effects Assumptions Guarantees Parameters)$; AppGraph as a typed attributed hypergraph; an algebra of assembly (sequential parallel feedback refinement); semantic projections and system-level invariants over trajectories.
• Architecture synthesis as an inverse problem given a specification load and constraints find the composition of gears that realises it. Constraint solving and MCTS as the baseline; a learned transition/value model for ranking and pruning; LLM proposals treated strictly as candidate hypotheses that a DSL parser type checker and property checks must then admit or reject.
• DSL design and language engineering the gear DSL and its glue layer decide which AppGraphs are expressible at all and therefore where the search space ends. This thread covers the abstract syntax and static semantics of that DSL; the requirement that an architectural decision be unbypassable by construction (you must not be able to wire authentication around the Auth Resolver); what happens to the language when gear contracts change or a 201st gear is added; projectional representation of graphs with cycles; and the open hypothesis that a specialised G1-DSL is generated together with every G1.
• Local transition models and pipeline surrogates fast approximate predictors for single pipeline steps (spec change code quality architecture product fit app runtime outcome) with calibrated uncertainty validated against real telemetry.
• Data reconstructing (specification architecture) pairs from open repositories at scale plus synthetic project generation from a fixed gear set and DSL grammar to cover rare transitions gaps and counterexamples.

Your Profile

• MSc (or equivalent) in computer science mathematics or a mathematical natural science.
• Coursework in compilers programming-language theory language design or model-driven engineering is a strong positive signal half of this project is deciding what a formal architecture description is allowed to say.
• Evidence that you finish things: a maintained open-source repository a peer-reviewed publication or a strong competition result.
• Fluent technical English.
• Most importantly: the habit of stating an assumption explicitly and designing an experiment that could falsify it.

Required mathematical background

Core skills:

• Probability and statistics. Estimation Bayesian inference uncertainty quantification and calibration (proper scoring rules reliability diagrams ECE) experiment design and significance testing. A prediction we cannot calibrate is not usable here.
• Linear algebra and multivariate calculus at the level needed to derive not just call a training objective: matrix calculus gradients stochastic optimisation conditioning.
• Discrete mathematics and graph theory. Typed and attributed graphs and hypergraphs subgraph matching and isomorphism graph rewriting reachability basic complexity classes.
• Mathematical logic and formal methods. First-order logic type systems SAT/SMT temporal logic (LTL/CTL) and model checking pre/post-conditions invariants refinement.
• Sequential decision making. MDP/POMDP dynamic programming model-based RL latent state-space (world) models Monte-Carlo Tree Search.

Strong command of at least one working knowledge of a second:

• Formal languages semantics and language engineering grammars (context-free attribute and graph grammars) derivation and reachability parsing; abstract versus concrete syntax; operational and denotational semantics; metamodelling model-driven engineering model-to-model transformation and projectional (structural) editing of the kind JetBrains MPS implements. We are asking for the education not the tool: you should know why a projectional editor exists what a metamodel buys you over a text grammar and how a language evolves without breaking its existing models. Hands-on MPS experience is explicitly not required we will teach it.
• Category theory for compositional systems monoidal and traced monoidal categories functors as semantic projections string diagrams operads. This is the language of our assembly algebra.
• Causal inference structural causal models do-calculus counterfactuals identifiability. Required for the what happens if we replace this technology / move on-premises class of questions which similarity search alone cannot answer.
• Queueing theory and applied stochastic processes M/M/1 and networks of queues heavy tails retries timeouts partial failure and reliability models. This is the resource and stochastic projection.
• Combinatorial optimisation constraint programming and program synthesis theory CEGIS version-space algebras symmetry breaking search heuristics.
• Representation learning theory VAEs and latent dynamics GNN expressiveness (Weisfeiler-Leman hierarchy) permutation equivariance embedding migration under a changing vocabulary.

Required hands-on programming skills

This is an engineering-heavy PhD. We expect code that another person can clone run and reproduce not notebooks that worked once.

Must have:

• Python (professional level). Type hints packaging pytest profiling asyncio memory-aware data structures. You write unbuffered logged restartable long-running jobs by default.
• Training loops written from scratch custom datasets and collation mixed precision multi-GPU; experiment tracking (W&B or MLflow) configuration management (Hydra) strict seed and artefact reproducibility.
• Graph machine learning. PyTorch Geometric or DGL message passing heterogeneous and typed graphs graph transformers handling graphs whose node vocabulary changes between versions.
• Solvers and verification tooling driven from Python. Z3 or cvc5 hands-on; demonstrated exposure to at least one model checker (TLA/TLC SPIN NuSMV Alloy) or proof assistant (Lean Coq Isabelle).
• Code as data. AST manipulation tree-sitter static analysis dependency and interface graph extraction large-scale repository mining.
• Parallel data pipelines. multiprocessing Ray or Dask; checkpointing heartbeats cost estimation before launching a run that touches millions of files.
• LLM engineering. API orchestration structured and grammar-constrained decoding evaluation harnesses token/cost accounting with the discipline to treat model output as a hypothesis subject to formal checks.
• Linux git code review shell.

Desirable:

• Language tooling you have actually used: ANTLR Xtext Lark or a parser type checker or interpreter you wrote yourself. Our internal representation of gear syntax trees and graphs lives in JetBrains MPS again we do not ask for MPS experience only that you are comfortable reading and extending a metamodel; Java/Kotlin literacy helps once you get there.
• JAX or compiler / SAT-SMT internals.
• Infrastructure literacy Docker Kubernetes Terraform OpenTelemetry/Prometheus since the resource projection is calibrated against real deployment telemetry.
• One systems language (Rust Go or C) for performance-critical search.
• Prior experience with production software architecture or with a brownfield system you had to change without breaking.

Funding

The appointment provides full financial coverage through a dedicated fellowship comprising:

• Monthly stipend of 1650
• Monthly research-cost allowance of 100 (Forschungskostenpauschale)
• Health-insurance subsidy of 100 per month

Location: Bremen Germany

Duration: 3 years full time

Start date:November 2026

Application package must include

• CV including publications code or research projects.
• Cover letter (12 pages) explaining your motivation research interests and fit with the project.
• A link to code you have written.
• A one-page research statement picking one open research question from the project and sketching how you would approach it.
• Masters and Bachelors degree certificate and transcripts.
• Contact information for 23 academic referees.

Applications are reviewed on a rolling basis. Shortlisted candidates will be invited to interviews.

Please note that only applications submitted through the official application portal will be considered for recognition