Biomedical Knowledge Composition: A Software Engineering Perspective
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: We're looking at the paper: "Biomedical Knowledge Composition".
Title and authors: Tom: So we're looking at this paper today called Biomedical Knowledge Composition: A Software Engineering Perspective, and it’s really trying to bridge the gap between all that incredible biomedical data we have and actually using it.
Jane: Right, so you know all this molecular and clinical stuff is out there, but turning it into useful knowledge is super hard because of all these technical roadblocks.
Tom: Exactly. This paper introduces knowledge graphs as the central structure for integrating that data, treating them like the main database for biomedicine now.
Lu: It frames them as essential because they let you represent biological entities and their relationships in one traversable graph structure, which is how we can actually do multi-hop graph traversals and automated reasoning over curated ontological relationships.
Meng: That sounds neat conceptually, but I wonder if that’s even practical when you’re dealing with real-world data sources that are all these different formats.
Lalam: The paper points out that the biggest problem is data harmonization, which involves identifier mapping, entity resolution, schema alignment, evidence integration, and provenance tracking.
Tom: That sounds like a lot of heavy lifting just to make sure all those pieces actually talk to each other correctly across different databases.
Jane: It’s like trying to make every single medical term or gene name match up perfectly when the sources are built totally independently for different purposes.
Lu: And the paper shows that this harmonization happens across these four orthogonal problem categories: batch effects, modality heterogeneity, semantic heterogeneity, and cross-study integration.
Meng: Modality heterogeneity is a big deal because we have everything from gene expression data to clinical trial reports, and they all speak different languages.
Tom: And semantic heterogeneity is the nightmare when terms don't align even conceptually across different repositories like Gene Ontology or UniProt.
Jane: So it’s not just one problem, but these different kinds of misalignment happening at the same time, which makes building a single integrated view really tough.
Lu: The paper contrasts two workflows: KG construction and model assembly from knowledge graphs, showing they have very different goals for maintenance and tooling requirements.
Title and authors: Meng: I’m more interested in that model assembly part because that’s where we actually ship things to production, not just building a big data structure for research.
Tom: The paper suggests a shift in focus: instead of just deployed graphs, we need to focus on the reproducible process of assembling them through versioned dependencies and build pipelines.
Jane: That means treating the assembly pipeline itself as the main artifact, rather than just the final graph instance we deploy.
Lu: They propose a few design principles for this, like choosing canonical identifier namespaces before you even start writing your ETL code to avoid those mapping headaches upfront.
Meng: A canonical versioning scheme for database releases sounds like something I could actually use to pin down exactly what data I’m pulling from a source.
Tom: And they push for treating provenance, or where the data came from, as a first-class requirement in the entire process, not an afterthought.
Jane: It makes sense because if you can't trace where a piece of knowledge came from, you can't trust what it’s saying about a patient’s tumor or any other biological thing.
Lu: The paper also looks ahead to future directions, suggesting formal models for biological data package management and standardized approaches for identifier and namespace management.
Tom: And then they mention that the rise of AI agents means we need well-defined interfaces, like TRAPI, so those agents can actually ground their behavior in this curated knowledge.
Jane: So the goal is to build a coherent engineering stack that unifies KG construction, maintenance, and model assembly lifecycles for all these different systems.
Meng: That sounds ambitious. If we’re talking about building an entire unified stack, what does that look like in terms of immediate engineering effort?
Tom: It’s about moving toward virtualization and federated access to manage the sheer volume of data involved, which seems like a necessary step for the near future.
Jane: And they also have this idea about visualization, treating it not just as a reporting step but as an infrastructure concern where visual encodings are mapped declaratively from domain ontologies.
Title and authors: Lu: That would make visualizations reproducible and queryable because the rules for what gets drawn would come directly from the domain ontologies themselves.
Meng: If we can get that level of declarative control over visualization, it might help us debug why a model isn't performing well in a specific way.
Tom: So, to wrap up this paper on Biomedical Knowledge Composition: A Software Engineering Perspective, the big point is that progress depends not just on having good biological data, but on developing robust software engineering practices and standards.
Jane: It really highlights that the reliability of future AI agent workflows depends entirely on having transparent, versioned, and interoperable knowledge infrastructure to work with.
Lu: I think the shift toward a canonical intermediate representation, like a Biolink-typed node and edge schema with SHACL constraints, is where we need to focus our foundational work right now.
Meng: From my side, it means we need tooling that supports this entire lifecycle—from data sourcing all the way to model assembly—in one cohesive way so I don't end up integrating three different messy systems just to run a simple test.
Lalam: I'm confident that if we establish these formal models for package management and identifier compatibility, we can start building those reproducible pipelines you need.
Tom: So, in summary, this paper lays out the necessary engineering path forward for making biomedical knowledge actually useful at scale.
Jane: It’s a lot of work to harmonize all that fragmentation across different data types and sources.
Lu: The main challenge is moving past building isolated systems toward creating a versioned, composable infrastructure for knowledge assembly.
Meng: I just need to know what the cost of running that unified system is going to be before I can sign off on adopting it in production environments.
Lalam: The paper suggests that establishing those formal standards for identifiers and namespaces will be the prerequisite for any reliable agentic work we want to do.
Tom: That’s where we’ll be looking next, figuring out exactly how to build that versioned dependency management system.
The paper's summary: Tom: So, what's the big idea here? Basically, they’re saying all this massive biomedical data we have—molecular stuff, clinical trials—is just a pile of fragmented information that’s hard to use.
Jane: Right. And this paper says the solution is knowledge graphs. They treat these graphs as the central structure for putting everything together, like a main database for biomedicine now.
Tom: Exactly. It explains *why* we need them because they let you represent all those biological entities and their relationships in one single graph that you can actually traverse.
Lu: It’s about enabling multi-hop graph traversals and automated reasoning over the relationships between genes, proteins, and drugs once everything is integrated into that structure.
Meng: But I always wonder if building this giant database is even practical when your data sources are all so different.
Jane: That’s the whole problem they tackle first: data harmonization. They say you have to solve the mess of getting all those different data sources to speak the same language.
Tom: And that means dealing with things like identifier mapping, figuring out which entity is which—entity resolution—and making sure all your schemas align perfectly.
Lu: They break that down into four areas: technical batch effects from variability, differences in data types like imaging versus text, semantic differences in terminology, and integrating evidence across different studies.
Jane: It’s a lot of upstream work just to make sure the pieces don't contradict each other when you try to put them together.
Tom: And the paper points out that the current tooling is really lacking. They argue we need better software engineering practices for this, something more mature than what we have right now in other fields.
Jane: So they’re talking about a shift from just having a finished graph to focusing on the reproducible process of assembling it using versioned dependencies and build pipelines.
Lu: They suggest concrete design principles: you should pick your canonical identifier names before you start writing any of your data transformation code, and provenance—where the data came from—needs to be treated like a first-class requirement.
Tom: That sounds like a real engineering focus, not just a theoretical exercise. It’s about making the process reliable so it doesn't break when you scale up.
Jane: And they also look ahead, saying that for future AI agents to actually work with this knowledge, we need standardized interfaces, like TRAPI, so those agents know exactly what kind of data they are grounded in.
Lu: They propose creating a canonical intermediate representation—something like the KGX format—that bundles the node and edge schemas with integrity rules and provenance tracking all in one place.
Meng: I’m interested in that intermediate representation part because having one standardized format would make running this system much easier to manage at scale, instead of juggling a hundred different data formats.
Tom: It sounds like the move is toward creating a unified engineering stack that handles construction, maintenance, and the model assembly life cycle all together.
Jane: It really puts the focus on building tools that are versioned and composable because without that maturity in software engineering, all this amazing biological data just stays trapped in silos.
Lu: The paper suggests visualization shouldn't be seen as a final reporting step but as an infrastructure component where visual encodings are mapped declaratively using rules from the domain ontology itself.
Tom: So it’s about making the entire knowledge engineering process—from raw data to a usable model—reproducible and verifiable.
Jane: It suggests that the next big step is moving toward these formal models for data package management and standardized identifier handling, which will unlock how we build reliable agentic workflows.
Lu: We need those standards to be solid because if the foundation isn't right, any high-level AI application on top of it will just be brittle.
Meng: So the paper says we need better software engineering practices and standards before we can fully expect these complex knowledge systems to become production ready.
Tom: It really depends on whether we can nail that versioned dependency management system they’re talking about.
The paper's improvements: Tom: So, after talking about the main problem, they lay out what needs to change in how we actually build these knowledge graphs. They aren't just suggesting better data; they’re suggesting a new set of software engineering practices for biomedicine.
Jane: It’s about moving away from just deploying a graph instance toward focusing on the reproducible process of assembling it using versioned dependencies and build pipelines instead.
Lu: They propose specific design principles, like choosing canonical identifier names before you even start writing any data transformation code to avoid those mapping headaches right at the beginning.
Tom: That sounds like a concrete fix for the upfront integration problems we talked about earlier, something that could stop us from building messy systems in the first place.
Jane: And they insist on treating provenance, where the data came from, as a first-class requirement throughout the entire assembly process.
Lu: They also want to create a canonical intermediate representation—they call it something like KGX—which bundles all those node and edge schemas with integrity rules and provenance tracking in one format.
Meng: Having that unified format would make running the system much easier at scale because I wouldn't be juggling a hundred different data formats every time I wanted to run a test.
Tom: And they’re pushing for semantic service composition, which is like having services declare their inputs and outputs in terms of shared ontological types, kind of like typed function signatures.
Jane: That means we stop relying on fragmented REST APIs and start composing our systems based on agreed-upon ontological type signatures.
Lu: This approach aims to create a coherent stack that unifies the construction, maintenance, and model assembly lifecycles for these knowledge graphs across all systems.
Tom: I like that idea of a unified stack because right now, it feels like we're just patching different pieces together as they break.
Jane: So the implication is that progress depends on developing formal models for biological data package management and standardized ways to handle identifiers and namespaces.
Lu: That’s the future direction: formal models that dictate how these packages should be managed, not just ad-hoc solutions we patch up later.
Meng: If we have those standards, it gives us a much clearer path to deploying something that doesn't constantly break because of mismatched data dependencies.
Tom: It sounds like the next big engineering challenge is figuring out how to build that versioned dependency management system they’re proposing for these biomedical assets.
Conclusion: Tom: So, to wrap up this deep dive into "Biomedical Knowledge Composition: A Software Engineering Perspective," the main message is that we need software engineering standards to handle biomedical data at scale, not just better biological data itself.
Jane: It really boils down to needing a reliable way to assemble and maintain these complex knowledge graphs so they actually become useful tools for discovery.
Lu: The paper’s big point is shifting the emphasis from just having a deployed graph instance toward focusing on the reproducible process of assembling it through versioned dependencies and build pipelines.
Meng: I agree with that, because if you can't reproduce your data pipeline, you can't trust what the final model assembly is actually doing in production.
Tom: And they argue that this means we need to focus on canonical intermediate representations and standardized ways to handle identifiers across all data sources.
Jane: That’s a huge step because it moves us from isolated systems toward a coherent engineering stack for knowledge construction.
Lu: They’re pointing toward formal models for data package management and standardized approaches to identifier handling as the next major research directions.
Meng: If we get those standards, it makes building things that are production-ready much more tractable, even if the initial setup takes more time.
Tom: It sounds like the reliability of future AI agent workflows depends entirely on having this transparent, versioned infrastructure in place to work with.
Jane: And they also suggest that visualization needs to become an infrastructure concern where visual encodings are mapped declaratively using rules from the domain ontology itself.
Lu: That declarative approach would make visualizations reproducible and queryable because the rules for what gets drawn come directly from the biological knowledge itself.
Meng: That’s interesting, though I still wonder what the actual cost is to build that whole infrastructure layer before we commit resources to it.
Tom: It really depends on whether we can nail that versioned dependency management system they’re proposing for these biomedical assets in a way that's practical.
Jane: So the path forward involves formalizing how we manage our data packages and identifiers so the entire process is traceable and reliable.
Lu: I think that focus on creating a canonical intermediate representation is where we need to concentrate our foundational work right now.
Meng: For me, it just means tooling that supports this whole lifecycle—from raw data sourcing all the way to model assembly—has to be in one cohesive way so I don't end up integrating three messy systems just to run a simple test.
Tom: So, in summary, "Biomedical Knowledge Composition: A Software Engineering Perspective" shows that progress requires solid software engineering practices and standards for biomedical data.
Jane: It highlights the challenge of harmonizing all that fragmentation across different data types and sources into one usable knowledge structure.
Lu: The main hurdle is moving past building isolated systems toward creating a versioned, composable infrastructure for assembling knowledge reliably.
Meng: I just need to know what the cost of running that unified system is going to be before I can sign off on adopting it in production environments.
Tom: That’s where we’ll be looking next, figuring out exactly how to build that versioned dependency management system.
Natallia Kokasha, Adam S.Z. Bellouma, Paola Grossoa
Institute of Informatics, University of Amsterdam
cs.SE
Submitted: 2026-08-09
Updated: 2026-11-17
Code: https://github.com/TaylorResearchLab/CFDE_
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 73/100
The gist: Biomedical research has accumulated extraordinary molecular, clinical, and population data, yet translating this wealth into actionable knowledge remains severely constrained by technical and…
Key concepts
- Knowledge Graphs (KGs)
- KGs structure biological entities like genes and proteins as nodes connected by relationships. This allows complex queries and reasoning over integrated data, moving beyond siloed datasets to create a single, traversable map of biomedical knowledge.
- Data Harmonization
- This is the difficult process of cleaning and unifying diverse biomedical data. It tackles technical variability (batch effects), different data formats (modality heterogeneity), and inconsistent terminology (semantic heterogeneity) to make the raw data compatible for use in a KG.
- Reproducible Construction
- Instead of focusing only on the final graph, this principle emphasizes building the system through repeatable processes. This means using versioned dependencies and build pipelines so that any part of the knowledge infrastructure can be rebuilt reliably and consistently over time.
Terminology
Summary
Biomedical research has accumulated extraordinary molecular, clinical, and population data, yet translating this wealth into actionable knowledge remains severely constrained by technical and organizational difficulties The first perspective introduces the biomedical domain to software engineers: it explains why knowledge graphs (KGs) are the central integrative data structure in modern biomedicine The second perspective asks why engineering biomedical knowledge infrastructure remains so difficult
The Central Role of Knowledge Graphs
Knowledge graphs (KGs) address the fragmentation of biomedical data by representing biological entities and their relationships in a single, traversable graph structure Nodes represent biological entities like genes, proteins, and drugs, while edges represent typed, directed relationships such as causes or treats Once integrated, KGs enable multi-hop graph traversals and automated reasoning over curated ontological relationships These capabilities underpin applications ranging from drug repurposing to digital twins
The Hurdles of Data Harmonization
Realizing the potential of KGs depends on solving the difficult upstream problem of data harmonization Data harmonization operates across multiple dimensions simultaneously, including batch effects from technical variability, modality heterogeneity from different data types, and semantic heterogeneity from inconsistent terminology The core challenges in this process encompass identifier mapping, entity resolution, schema alignment, evidence integration, and provenance tracking
Engineering Deficiencies in Current Tooling
The difficulty in engineering biomedical knowledge infrastructure is rooted in the limited adoption of software tooling that makes development reliably composable and reproducible This lack of maturity contrasts sharply with mature domains like web engineering, which benefit from package management, typed namespaces, and canonical interchange formats Specific engineering challenges include the absence of a package manager for biomedical data sources and the lack of a canonical intermediate representation for heterogeneous data formats
Design Principles for Reproducible Construction
The article emphasizes shifting emphasis from deployed KG instances toward the reproducible process of assembling them through reusable build pipelines and versioned dependencies Key design principles include choosing canonical identifier namespaces before writing ETL code, treating provenance as a first-class data requirement, and prioritizing the assembly pipeline over the deployed artifact The dominant trend is a shift toward virtualization and federated access to manage the volumes of data involved
The Path Forward for Knowledge Engineering
Future research directions point toward formal models for biological data package management, standardized approaches to identifier and namespace management, and tooling that supports reproducible end-to-end data integration workflows The emergence of LLM-based agents introduces requirements for well-defined interfaces like TRAPI to ground agent behavior in curated biomedical data Progress depends on developing a coherent, general-purpose engineering stack that unifies KG construction, maintenance, and model assembly lifecycles
Visualization as an Infrastructure Concern
Visualization is often treated as a downstream reporting step rather than infrastructure in biomedical data engineering There is an emerging opportunity for a semantic visualization layer where node and relation types are mapped to visual encodings through declarative rules derived from domain ontologies This would make visualizations reproducible, queryable, and automatically updatable
Conclusion on Engineering Maturity
The analysis suggests that progress in biomedical knowledge engineering depends not only on the availability of high-quality biological data but also on the development of software engineering practices and standards The reliability of future agentic workflows depends entirely on the availability of transparent, versioned, and interoperable knowledge infrastructure Progress requires continued collaboration among software engineers, knowledge engineers, data providers, and biomedical researchers
References
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Standardize identifier mapping through canonical namespaces before writing any ETL code to ensure
no package manager for biomedical data sources
is solved by establishing acanonical versioning scheme for database releases.
This allows downstream consumers to useversion-pinned sources
and receive integrity verification via published checksums. -
Implement a system where namespace types are first-class objects in the pipeline language so that
joining ensembl:ENSG
withncbigene:gene
identifiers produces a compile-time type error rather than a silent semantic failure, addressing the challenge ofnamespace type safety.
-
Develop an open problem solution for biomedical data package management that includes "(1) a canonical versioning scheme for database releases; (2) a manifest format for declaring data dependencies with version constraints; (3) a registry of published data packages with integrity hashes; and (4) a resolver that satisfies dependency declarations while enforcing identifier namespace compatibility."
-
Design an engineering maturity gap bridge by creating a
canonical intermediate representation
such as the KGX format, which combines(1) a Biolink-typed node and edge schema; (2) a SHACL constraint layer expressing biological integrity rules; (3) a PROV-O provenance subgraph; and
(4) an identifier namespace declaration per node type." -
Establish semantic service composition by developing services that
declare inputs and outputs in terms of shared ontological types,
analogous totyped function signatures,
enabling automated composition from ontological type signatures rather than relying on fragmented REST APIs. -
Create a semantic visualization layer where
node and relation types are mapped to visual encodings through declarative rules derived from domain ontologies such as Biolink,
allowing visualizations to bereproducible, queryable, and automatically updatable.
Abstract
Biomedical research has accumulated vast molecular, clinical, and population data, yet translating this wealth into actionable knowledge remains constrained by technical and organizational difficulties. This article presents a unified treatment of two perspectives on biomedical knowledge infrastructure. The first introduces the biomedical domain to software engineers: it explains why knowledge graphs (KGs) are the central integrative data structure in modern biomedicine, characterizes five data harmonization challenges (identifier mapping, entity resolution, schema alignment, evidence integration, and provenance tracking), surveys application domains from drug discovery to digital twins, and profiles six representative KG systems with contrasting choices. The second perspective asks why engineering biomedical knowledge infrastructure remains so difficult. We argue that a contributing root cause is limited adoption of software tooling and practices that make development in other mature domains - particularly web engineering - reliably composable and reproducible: package management, typed namespaces, canonical interchange formats, service composition protocols, reproducible pipelines, and lifecycle governance. Against this backdrop, eight open engineering challenges for biomedical data integration are catalogued, each with partial solutions but no universally adopted stack. Crucially, the article shifts emphasis from describing deployed KG instances toward the reproducible process of assembling them: reusable build pipelines, versioned dependencies, and engineering practices that let others compile and customize a KG from source rather than consuming a static artifact. Together, the two perspectives provide domain grounding for newcomers and a research agenda for software engineers seeking to make transformative contributions to biomedical knowledge infrastructure.
Sources
- Interactive Data Harmonization with LLM Agents: Opportunities and Challenges
- Improving Biomedical Knowledge Graph Quality: A Community Approach
Related papers
- ArkEval: Benchmarking and Evaluating Automated CodeRepair for ArkTS
- TestPrism: Rethinking Test Evaluation Beyond a Single Reference
- Mining Workflow Graphs for Black-Box Boundary Testing of Conversational LLM Agents
- Falsification-Based Verification of LLM-Generated Optimization Models: Sound Test Batteries and Their Detection Limits
- GitSkills: A Dataset of Agent Skills on GitHub
- For Coding Agents, the Repository Matters