Prior Art: Interoperable-Tooling Research Programs in Other Disciplines

Part of the Research Program for AI as Babel Fish for Structural Economics. The patterns this program is pursuing — a declarative model language, a typed core, swappable numerical methods, multi-backend interoperability, reproducible archives, and community governance — are not new to science. Several mature fields have run essentially the same program for decades. This document catalogs the strongest analogues and extracts concrete specifics worth adopting.

The program is organized into three working groups: WG1 (Language, Calculus & Formal Semantics), WG2 (Methods, Backends & Verification), and WG3 (AI Assistance, Reproducibility & Standards). The “Most informs” column below maps each analogue onto them.

At a glance¶

Click any ecosystem to see it. The six marked ★ get a full treatment below; the rest are strong corroborating analogues surveyed here.

0. The most important pattern: programs that wrote a document, organized a community, and won funding¶

Several of these efforts began exactly the way this program is starting — as a written research-program / strategic-plan document that pulled in institutions and then attracted large grants. There is even a funding mechanism built around the genre: NSF’s SI2 / S2I2 program (solicitation) funds research-software ecosystems in two stages — a Conceptualization Award (~1 yr) whose deliverable is literally “a strategic plan for ... a sustained software infrastructure” (in other words, NSF will pay you to write the research program), then an Implementation Award for the institute that executes it. The strategic-plan document is the instrument that both organizes collaborators and wins the implementation grant.

Worked examples (document → community → money):

• IRIS-HEP / high-energy physics. An S2I2-HEP conceptualization project produced a Strategic Plan and a Community White Paper with hundreds of co-authors across dozens of institutions — which led NSF to launch IRIS-HEP (2018). A heavily co-authored white paper is simultaneously a collaborator-recruiting and a funder-convincing instrument.

• MolSSI / molecular sciences. A 5-year, $19.4M** NSF institute award ([1547580](https://www.nsf.gov/awardsearch/showAward?AWD_ID=1547580)) in 2016, **renewed with$15M in 2021; an eight-university collaboration with ~40 partner codes and ~100 funded software fellows — the institute and the QCSchema standard reinforcing each other.

• Lean FRO / mathematics. A focused 5-year mission under Convergent Research with a $10M philanthropic gift — the non-NSF (FRO) template (see §2).

• Astropy / astronomy. Program-defining papers carrying hundreds of co-authors double as the program statement and the collaborator roster; “The Astropy Problem” is a candid funding/sustainability manifesto worth studying for WG3.

Honest staging. These describe the end state of a coalition, not its first year; this program is at a much earlier stage (a small core team with prototypes). The realistic sequence: Year 1 — publish this document and a short concept paper (core team + a few collaborators), debut it at a workshop, and stand up an annual pre-SCE meeting; target a planning/conceptualization-scale grant. Years 2–3 — turn early adopters into co-authors of a Community White Paper spanning a few subfields, with the author list visibly growing. Years 3–5 — with a real multi-institution community, pursue the implementation-scale vehicle (an NSF software institute and/or an FRO), making the standard and the organization reinforce each other (MolSSI ↔ QCSchema). The document and a small, credible author group come first; the big coalition is the program’s product, not its precondition.

1. Statistics — model vs. inference, cleanly separated (Stan / PyMC)¶

A Stan program defines a log-probability function and its gradients; the inference algorithm is a swappable backend consuming that object — NUTS (MCMC), L-BFGS (optimization), variational inference, etc. The model logic is independent of the execution engine. This is the cleanest possible statement of the program’s math-vs-numerics separation (WG2): specify what the model is, then choose how to solve it without touching the model. The “single core object that many algorithms consume” pattern is exactly Bellman-core (WG1) feeding methodization (WG2). Stan and PyMC also stake out the two ends of a design tension WG1 must settle: a standalone DSL (Stan; maximal expressive power, steeper learning curve) vs. embedding in Python (PyMC; lower barrier).

2. Math formalization — the closest formal-methods precedent (Lean FRO + mathlib)¶

The Lean Focused Research Organization (July 2023, under Convergent Research) runs a focused 5-year mission to improve Lean’s “critical systems — scalability, usability, documentation, automation for formal encoding — while guiding [it] toward long-term self-sustainability.” Its community library, mathlib, now spans 130,000+ definitions contributed by 770+ people — a vivid picture of what a community formal corpus can become. This is a direct precedent for the program’s FRO funding path and for WG1’s formal-semantics layer, and the structure is instructive:

• Separation of infrastructure from library governance: the Lean FRO builds the language/tooling; the community-run mathlib library is governed separately by its maintainer team. → argues for keeping the language standard (WG3 board) distinct from the model/component registries (WG1), each with its own governance.

• “Growing mathlib” documents exactly the fast-growing-library problems the stage/period/trellis registries and the WG1 formal library will face: deprecation systems for breaking changes, linters for global coherence, mandatory code review, compile-time/technical-debt management, and custom triage tooling. This is a ready-made checklist for the registries and the formal DP library — both in WG1.

• Bridging informal and formal: the FRO’s goal of a “unified environment where [authors] interleave prose, familiar notation, and Lean code to produce both machine-readable formal encodings and conventional-looking papers” is the same vision as binding the model on paper to the code — and a strong tie to WG1 (the program’s Lean formalization work) and WG3 (symbolically grounded AI for math/modeling).

• Philanthropic scale: a recent $10M gift (split FRO/mathlib) shows the magnitude achievable on this model — a direct template for funding WG1’s formal layer.

3. Astronomy — community ecosystem governance (Astropy)¶

Astropy is a community core package plus an ecosystem of “affiliated packages” that share its goals and build on its infrastructure, with a formal review process for affiliation. Governance is a do-ocracy codified in APE 0 (an “Astropy Proposal for Enhancement,” modeled on Python PEPs): a 5-member Coordination Committee, Voting Members, and an Ombudsperson. It is a NumFOCUS fiscally sponsored project. Because Econ-ARK is already a NumFOCUS project, this model is the most directly transplantable: the affiliated-package + review process is a template for the registry ecosystem (community-contributed stages/periods/trellises reviewed for inclusion in the core catalog), and the APE/PEP-style proposal mechanism is a way for the WG3 advisory board to evolve the language standard transparently.

4. Quantum simulation & computing — IR + multi-backend, in the extreme (OpenQASM / QIR / PennyLane / QuTiP)¶

Quantum computing has, in just a few years, built the layered language + IR + device-agnostic backend stack this program is aiming for — and across fierce commercial competitors, which is itself instructive for a standards effort.

• OpenQASM 3 — a portable, machine-independent circuit language designed as a multi-level intermediate representation: the same program can be expressed at a high logical level or lowered toward physical pulses, “capturing intent in a portable manner without tying it to a particular implementation.” IBM calls it the “lingua franca” of quantum software. → the program’s WG1 surface language plus the “one parse, many abstraction levels lowered toward a backend” idea (math → methodization → backend).

• QIR (Quantum Intermediate Representation) — the single best analogue for Bellman-core (WG1) + Rosetta Stones (WG2) combined: a vendor- and language-agnostic IR built on LLVM. Crucially:

  • It specifies an interface (a set of functions), not a gate set — “it is the role of the target-specific compiler to translate … into an appropriate computation that meets the capabilities of the target platform.” That is exactly the Rosetta-Stone contract: define the operator interface; let each backend lower it.

  • It defines profiles — named subsets of the IR that a target supports → a ready-made mechanism for WG2 backend conformance levels: each backend (HARK, Dynare, VFI-toolkit) declares which operators/schemes it implements, and the verification harness checks against that profile.

  • It rides on a mature framework (LLVM) to inherit optimizers and tooling — bearing directly on whether Bellman-core should build on existing IR infrastructure (or, per WG1, on Lean).

• PennyLane — device-agnostic programming: write the circuit once, run it anywhere by swapping the device, via an entry-point plugin registry where backends register themselves — a concrete registration mechanism for both Rosetta backends and the registries.

• QuTiP — a NumFOCUS-affiliated open-quantum-systems simulation toolkit that “grew from a library to an ecosystem”; the HARK/Astropy analogue of a community toolkit serving as a reference backend and ecosystem hub.

QIR also illustrates two governance/versioning patterns: neutral-foundation, cross-competitor governance (a Linux Foundation steering committee spanning Microsoft, NVIDIA, ORNL, Quantinuum, and Rigetti — a distinct alternative to the FMI committee’s member-vote model) and IR versioning against an explicit compatibility matrix (QIR ↔ LLVM), a model for versioning the Bellman-core wire format.

5. AI that reasons inside the laws of a field (formalization · PIML/SciML · symbolically grounded AI)¶

A fast-moving movement — most visible in physics — encodes the known laws of a field in a machine-readable formal form and then builds AI that must reason within those laws rather than by free association. The idea is simple: instead of hoping a language model has correctly absorbed a field’s rules from prose, you hand it those rules as hard constraints it cannot violate, and check its output against them. This is the most direct intellectual parallel to the program: the formal knowledge base (WG1) is economics’ encoded laws, and Matsya (WG3) is the AI held to them. The movement splits into three named threads worth citing explicitly.

• Formalization of a science in Lean (the closest analogue to WG1’s formal layer and our Lean work). PhysLean — now Physlib (Joseph Tooby-Smith; originally HepLean) “digitalises results from physics into Lean 4” — the physics counterpart of mathlib. Lean4PHYS adds a foundation library (a units system + standard foundational definitions) and LeanPhysBench, the first benchmark for LLM formal physics reasoning in Lean 4. Two findings transfer directly to us: (i) math-specialized formal libraries did not transfer to physics, arguing that a field needs its own formal corpus — exactly the case for a Bellman/DP library (WG1) distinct from mathlib; and (ii) putting the formal library in-context raised LLM accuracy ~12% — the empirical case for WG3 grounding in the WG1 formal layer. Lineage: Lean + mathlib, DeepMind’s AlphaProof/AlphaGeometry (external projects whose goals include automated reasoning; our program’s Lean work targets encoding and type-checking, not new mathematical discovery).

• Physics-Informed / Scientific Machine Learning (PIML / SciML). The umbrella for learned models constrained by governing equations — PINNs (Raissi–Karniadakis), with laws entering as soft constraints (loss penalties) or hard constraints baked into the architecture (Hamiltonian/Lagrangian nets, Constraint-Projected Learning, KKT-Hardnet). Econ models are discrete-time stochastic DPs rather than PDEs, but the paradigm is identical to the program’s Υ-vs-Ρ split: specify the math once, attach methodization separately, and make correctness a property rather than a hope. AI for Science is the broadest banner.

• Symbolically grounded AI (the literature also calls this neuro-symbolic AI; closest to “an AI that thinks within the laws”; the WG3 framing). A neural model does the intuition; a symbolic engine enforces hard rules. 2025–26 systems treat conservation laws as hard constraints that reshape an LLM’s output distribution or force a rollback on a non-physical step (NeSyS, OmniFlow), including for LeCun-style world models. This is precisely Matsya’s “correctness before fluency”: the typed Bellman-core and the WG1 formal library are the symbolic constraints the language model must satisfy.

The contrast to internalize: the data-driven pole is Polymathic AI (Shirley Ho, Flatiron/Simons + Cambridge/Princeton/NYU/LBNL) — foundation models (The Well, Walrus, AION-1) that learn physics statistically rather than imposing it. The program sits firmly at the formalization / hard-constraint pole, which is the natural position for a field that already has its governing theory written down (recursive/dynamic-programming theory).

What this means for the program. Economics is unusually ready for this play: because its governing theory is already written down, the work is to encode it (WG1) and ground the AI in it (WG3) — not to discover new results. Two moves follow the physics playbook directly: treat the formal layer as a first-class, community-owned corpus (as PhysLean is, distinct from mathlib), and ship an EconDP benchmark — canonical models with formal specs that tools and LLMs are scored against. A benchmark is a low-cost, high-leverage deliverable that both measures progress and recruits collaborators (WG1 × WG3), exactly as LeanPhysBench did for physics.

6. Cross-subfield & cross-discipline integration (sharing tools across traditions)¶

Letting models and components move across economics subfields — heterogeneous-agent macro, structural microeconometrics, computable general equilibrium (CGE), agent-based modeling (ABM), and applied IO — is a cross-cutting theme of the program rather than a separate working group. Its representational half sits in WG1 (shared/companion structures, coupling interfaces), its numerical half in WG2 (Rosetta Stones to subfield toolkits, coupled-model verification), and its translation/reproducibility half in WG3. Sharing discipline-specific tools across neighboring fields is an established pattern, and the successful efforts each isolate one mechanism — a shared representation, a registry of reusable components, a common backend interface, a federated index, runtime coupling of independently built components, or a translation bridge between traditions.

Reusable components and common interfaces (materials science, chemistry, physics).

• ASE (Atomic Simulation Environment) exposes a single Python “calculator” interface wrapping ~40 external electronic-structure and molecular-dynamics codes (VASP, Quantum ESPRESSO, GPAW, LAMMPS, …): write the simulation once, swap the backend. Exactly the WG2 Rosetta-Stone pattern, realized across the quantum-physics / materials / chemistry boundary.

• OpenKIM (Knowledgebase of Interatomic Models) defines a standard API (the Portable Model Interface) so that one implementation of an interatomic potential runs unmodified in any compliant simulator, with archived models carrying DOIs, citations, and automated verification checks. The closest analogue to the WG1 stage/period/trellis registries: a curated, versioned, citable library of reusable model components shared across codes.

Federated corpora / indexes — a cross-database “Rosetta Stone.”

• OPTIMADE (a 30+-institution consortium) defines a common REST API so materials databases that each grew their own interface — Materials Project, AFLOW, OQMD, NOMAD, COD — can be queried uniformly, with a federated provider “index meta-database”; together they expose >10 million structures. The model for indexing reusable components across subfields without forcing every provider into one store (informs the WG1 registries and WG3 federation).

Coupling independently-developed component models.

• ESMF / NUOPC couples independently developed atmosphere, ocean, land, and sea-ice models — built by different groups — through standardized “caps.” NUOPC negotiates which fields each component imports and exports from a shared dictionary, so a model with a compliant interface plugs into any NUOPC-driven system without bespoke glue. The gold-standard precedent for coupling interfaces (WG1); the economic analogue is joining an applied-IO product market or an ABM labor-market block to an HA-macro model through declared imports and exports. (Engineering’s preCICE does the same for partitioned multi-physics, coupling existing solvers such as OpenFOAM, FEniCS, and CalculiX at runtime.)

Translating a problem into another field’s representation — bridges.

• OpenFermion (Google) bridges quantum chemistry and quantum computing: it takes a molecular specification from classical electronic-structure codes (Psi4, PySCF) and translates it into a qubit Hamiltonian and quantum circuit (via Jordan–Wigner and related mappings). The analogue of the program’s bridges (WG3) for traditions that do not share the Bellman-core — translating, say, a CGE equilibrium or an ABM rule set into or out of the common representation.

What this implies. No single precedent supplies all of these mechanisms at once; the program’s wager is that a typed semantic core (WG1) plus Rosetta Stones (WG2) can supply several together for economics. Two further observations: the most durable efforts (ESMF, OPTIMADE, OpenKIM) are sustained by standing consortia around a shared data/interface standard — reinforcing the WG3 governance and registry agenda — and the cleanest couplings (ESMF, OpenKIM) come from agreeing on an explicit interface of named imports/exports, a concrete design target for the WG1 coupling work.

Cross-cutting lessons (specifics to nail down)¶

1. Factor the standard, don’t monolith it. Mature ecosystems keep the model separate from the numerical method and from the reproducible archive rather than bundling them into one format. This validates and sharpens the program’s WG1/WG2/WG3 boundaries — adopt explicit, separately versioned specs.

2. Lock a machine-readable IR early and make everything fold over it. QCSchema (JSON), FMU (XML+binaries), MOI’s in-memory model, and QIR (LLVM-based) — each ecosystem’s interoperability rests on a stable hand-off object, often versioned with an explicit compatibility matrix (QIR). Prioritize the Bellman-core wire format (WG1) as the contract, and consider building it on existing IR infrastructure — or on Lean (per WG1) — rather than from scratch.

3. Make backend translation reusable and composable, not per-backend bespoke. MOI’s bridges with shortest-path composition and QIR’s “interface, not gate set” are the gold standards for WG2 Rosetta Stones.

4. Define backend conformance via profiles. QIR profiles (named subsets a target supports) give WG2 a clean way for each backend to advertise which operators/schemes it implements, and for the verification harness to check against that declaration.

5. Separate language-infrastructure governance from library/registry governance. Lean FRO vs. mathlib; FMI core vs. layered standards. Map onto WG3 (standard) vs. WG1 (registries).

6. Adopt a proven governance instrument. PEP → APE (Astropy), steering committee + member vote (FMI), or a neutral-foundation steering committee (QIR). Pick one deliberately.

7. Plan registry maintenance up front. mathlib’s deprecation/linters/review/technical-debt playbook is what the stage/period/trellis registries and the WG1 formal library will need at scale.

8. Two viable org/funding templates beyond one-off grants: the NSF software institute (MolSSI, IRIS-HEP) and the FRO (Lean) — both build “pivotal infrastructure as a public good.” The NSF route has an explicit conceptualization → implementation ladder that funds writing the research program itself (see §0).

9. The program document seeds the coalition — and grows with it. A multi-institution Community White Paper / Strategic Plan (IRIS-HEP) or heavily co-authored defining paper (Astropy) recruits collaborators (via authorship) and convinces funders. But those large author lists are an end state; start with a small, credible core-plus-friends document and let the author list and institutional breadth grow over successive drafts and years. The document comes first; the big coalition is its product, not its precondition.

10. Drive adoption with reference APIs, software guides, conformance suites, and workshops (e.g., FMI’s reference FMUs + public tool-compatibility matrix).

11. Formalize the field and benchmark it. The newest lesson (physics): make the field’s laws formally encoded (WG1’s formal layer), ground the AI in that corpus (WG3), and ship a public benchmark to organize contributors — the AI-for-Science / formalization play. Adopting that movement’s vocabulary in grant framing (“formalizing the laws of dynamic economic modeling so AI can reason within them”) places the program inside a well-funded narrative (NSF, philanthropy) rather than a niche econ-tooling story.

Open questions for the team (to refine the program)¶

• Which governance instrument do we want: APE/PEP-style (Astropy; lightweight, community) vs. steering committee + member vote (FMI) vs. a neutral-foundation steering committee (QIR)?

• Do we pursue the FRO path, the NSF software-institute path (conceptualization → implementation), or both in sequence?

• Should we produce a multi-institution Community White Paper / Strategic Plan (IRIS-HEP model) as the program’s public face, and who are the natural co-authors across subfields?

• Should methodization be promoted to a first-class, separately versioned standard rather than a layer inside WG1?

• For WG2, do we commit to the MOI bridge-graph architecture and/or QIR-style profiles (named backend conformance subsets) as the reference design?

• Should Bellman-core build on an existing IR framework (cf. QIR-on-LLVM) rather than a bespoke term-graph, to inherit tooling?

• For the registries, do we adopt the Astropy affiliated-package review model directly (natural, since both are NumFOCUS)?

• For WG1’s formal layer, what is the right scope and cadence for the Lean DP foundation library, and should we ship an EconDP formalization / AI-translation benchmark (à la LeanPhysBench) as an early, collaborator-recruiting deliverable?

• How hard do we commit to the AI-for-Science / formalization framing as the program’s public identity, and should Bellman-core be built on Lean rather than only alongside it?

• DSL design (WG1): standalone language (Stan/AMPL) vs. embedded in Python (PyMC/JuMP)? The current YAML approach sits between these — is that the intended endpoint?

Sources¶

Programs / funding genre: NSF SI2/S2I2 solicitation, S2I2-HEP, S2I2-HEP Strategic Plan (arXiv 1712.06592), HEP Roadmap / Community White Paper (arXiv 1712.06982), MolSSI NSF award 1547580 ($19.4M)](https://www.nsf.gov/awardsearch/showAward?AWD_ID=1547580), [MolSSI$15M renewal, The Astropy Problem (arXiv 1610.03159).

Stan: mc-stan.org, Stan JSS paper. Lean: Lean FRO, mathlib stats, Growing mathlib, $10M gift. Astropy: about, APE 0, NumFOCUS. Quantum: OpenQASM, OpenQASM 3 paper, QIR Alliance, QIR spec, PennyLane architecture, QuTiP.

AI-for-science / formalization: PhysLean / Physlib, PhysLean index-notation paper (arXiv 2405.08863), Lean4PHYS / LeanPhysBench, Physics-informed ML review (Karniadakis et al., Nat. Rev. Phys. 2021), Constraint-Projected Learning (arXiv 2511.03578), Polymathic AI.

Cross-subfield integration: ASE (Atomic Simulation Environment), OpenKIM, OPTIMADE, ESMF / NUOPC, preCICE, OpenFermion.