PaperlayerView exact revision on arXiv

Source-linked AI summary

Valhalla: A Layered Knowledge-State and Service-Governance Framework for Long-Term Scientific Knowledge Work

Yuyang Zheng, Nan Li, Wenxia Deng, Lige Yan, Xiang Li, Si Chen

arXiv:2608.15193v1q-bio.NCcs.AI

TL;DR

Long-term scientific knowledge work requires content and evidence to be structured while LLM capabilities adapt to knowledge-work requirements, yet knowledge must also be reusable, shareable, and reorganizable. Valhalla addresses this gap with layered knowledge-state objects and governed service interfaces that organize sources, knowledge, relations, and task views. In an antibody-design review, the resulting workflow strengthened evidence use, mechanism explanations, structural organization, scientific depth, logical structure, and evidential rigor, while supporting domain adaptation.

  • Problem

    Long-term scientific knowledge systems need reusable, shareable, and reorganizable knowledge, but existing structures often depend on individual organizational practices.

  • Method

    Valhalla uses layered File-Resource-Entity-Relationship-Graph objects and explicit Router-Contract-Workflow service interfaces to govern LLM access and modification.

  • Results

    Valhalla strengthened evidence use, mechanism explanations, structural organization, scientific content depth, logical structure, and evidential rigor, while supporting domain adaptation.

  • Takeaways & Limitations

    The framework makes structured scientific knowledge shareable and recomposable, extending collaboration from sharing agents to sharing structured knowledge.

  • Takeaways & Limitations

    Evidence for Valhalla comes primarily from its architecture and a single case study, leaving internal and external validity insufficiently established.

Abstract

from arXiv · show

As large language model (LLM) agents are increasingly adopted in scientific research, external knowledge bases, knowledge graphs, and long-term memory have improved information retrieval and task continuity. However, most structured knowledge systems remain node-centric, representing files, concepts, results, and judgments as nodes and relations in a graph. While suitable for personal knowledge management, such structures often depend on individual organizational practices, limiting knowledge sharing, integration, and reorganization across users. This paper presents Valhalla, a layered knowledge-state and service-governance framework for long-term scientific knowledge work. Valhalla replaces flat graphs with layered encapsulation and stable semantic boundaries through a five-layer File-Resource-Entity-Relationship-Graph (FREG) model. File and Resource preserve source identity and provenance, Entity represents knowledge objects, Relationship captures semantic judgments, and Graph provides task-oriented knowledge views, enabling knowledge states from different researchers to be exchanged and reorganized under a unified structure. We further introduce a Router-Contract-Workflow service-governance architecture, inspired by the microkernel paradigm, to constrain how language models access, modify, and extend knowledge states while maintaining structural consistency and auditable operational boundaries. We implement a Valhalla prototype and validate knowledge ingestion, cross-member integration, and scientific writing support through an antibody-design review task comprising 26 paper resources, 80 knowledge entities, and 92 semantic relations. Rather than proposing a new knowledge-extraction algorithm, Valhalla offers a paradigm for organizing collaborative scientific knowledge, transforming individualized knowledge structures into transferable and reorganizable shared knowledge states.

1 Introduction … 4 Data Plane: File–Resource–Entity–Relationship–Graph

Valhalla addresses long-term scientific knowledge work by combining structured, provenance-preserving knowledge states with inspectable service governance. Its FREG data plane separates source identity, knowledge objects, semantic judgments, and task views so knowledge can be shared, traced, and reorganized without claiming that correctness or governance problems are eliminated.

  • 1 Introduction: Valhalla combines content structuring with LLM capability adaptation because long-term knowledge work requires both organized evidence and services suited to knowledge-work requirements.The framework targets knowledge that is reusable, shareable, and reorganizable across users, projects, and scenarios.
  • 2 Main Contributions: Valhalla makes provenance-constrained knowledge states, auditable service extension, and human-in-the-loop governance explicit design requirements while exposing tensions among transfer, extension speed, and runtime guarantees.The framework treats these trade-offs as inspectable objects and operational interfaces rather than claiming they have already been eliminated.
  • 3.1 Framework Definition: Valhalla treats research content as maintainable data objects and requires models to access or modify them through explicit service interfaces under a content-first organization.Services may not bypass object boundaries merely for execution convenience.
  • 3.2 Data Plane and Control Plane: The data and control planes jointly organize what Valhalla stores and how models operate: FREG supplies stable traceable objects, while Router, Contract, and Workflow govern eligible operations.Router classifies requests; Contracts declare permissions, risks, states, confirmations, and output boundaries; Workflows specify execution steps after eligibility checks.
  • 4 Data Plane: File–Resource–Entity–Relationship–Graph: The FREG data plane defines distinct responsibilities for File, Resource, Entity, Relationship, and Graph, creating a unified architecture for sharing structured knowledge across users.The design defines object identities, maintenance responsibilities, and traceability paths rather than proposing a new extraction algorithm [1,5,20].
  • 4.1 File and Resource: From Human-Facing Entry Points to Stable Source Identities: File preserves researcher-facing organization, while Resource provides a stable source identity that can unify multiple file instances without erasing their provenance or task context.Identity matching may be erroneous for versions or supplementary materials, so manual verification remains necessary [2‑3].
  • 4.2 Entity: Provenance-Constrained Knowledge Objects; 4.3 Relationship: Typed Semantic Judgments: Entities represent independently maintainable, provenance-constrained knowledge units, while Relationships preserve typed judgments such as support, contradiction, causation, constraint, and dependence.Source-specific Entities remain separate when conditions or contexts differ, and relations provide inspectable judgment structure rather than causal proof [1‑3].
  • 4.4 Graph: Task-Oriented Knowledge Networks; 4.5 Core Semantic Graph and Evidence Mappings: Graphs organize selected Entities and Relationships around a current research task, while separate file, semantic, and evidence views let users inspect structure, verify provenance, and return to original materials.Graph coverage and isolated nodes indicate knowledge-organization gaps, and view switching cannot correct erroneous registration, extraction, or relation judgments.

5 Formal Architecture of the Data Plane �

The Valhalla data plane defines a Root knowledge state composed of five encapsulated layers—Files, Resources, Entities, Relationships, and Graphs—and links adjacent layers through four transformation mappings. These mappings provide interfaces for inter-layer knowledge-state transformations with distinct responsibilities.

  • 5.1 Five-Layer Knowledge-State Architecture: Root is the concrete data-plane implementation of the Valhalla knowledge state.
  • 5.1 Five-Layer Knowledge-State Architecture: The File layer is the set of Files contained in Root.
  • 5.1 Five-Layer Knowledge-State Architecture: The Resource layer is the set of Resources contained in Root.
  • 5.1 Five-Layer Knowledge-State Architecture: The Entity layer is the set of Entities contained in Root.
  • 5.1 Five-Layer Knowledge-State Architecture: The Relationship layer is the set of Relationships contained in Root.
  • 5.1 Five-Layer Knowledge-State Architecture: The Graph layer is the set of Graphs contained in Root.
  • 5.2 Inter-Layer Knowledge-State Transformations in the Data Plane, ℳ�: The five data-plane layers are connected by mappings that perform inter-layer knowledge-state transformations.These mappings have distinct responsibilities in linking the layers.
  • 5.2 Inter-Layer Knowledge-State Transformations in the Data Plane, ℳ�: Four transformation mappings link the five encapsulated structured-data layers as interfaces between adjacent layers.

1. File-to-Resource Transformation Mapping ℳ�� �∈�, �∈� … 4. Relationship-to-Graph Transformation Mapping ℳ���� ℳ����

The framework transforms source files into standardized resources, extracts entities, organizes relationships among them, and constructs topic-specific knowledge graphs. These mappings support source consolidation, structured knowledge extraction, semantic organization, and task-oriented graph construction.

  • 1. File-to-Resource Transformation Mapping ℳ�� �∈�, �∈�: Files are mapped to standardized logical Resources, preserving the identity of source material across the transformation.
  • 1. File-to-Resource Transformation Mapping ℳ�� �∈�, �∈�: Multiple Files can map to one Resource when differing paths, filenames, or member ownership identify the same source material.
  • 2. Resource-to-Entity Transformation Mapping ℳ��: Entities are extracted from Resources, with each Resource potentially containing multiple Entities.
  • 2. Resource-to-Entity Transformation Mapping ℳ��: Relationships summarize and organize connections among extracted Entities.
  • 3. Entity-to-Relationship Transformation Mapping: A pair of Entities may be connected by Relationships of different types, allowing multiple semantic associations between the same objects.
  • 4. Relationship-to-Graph Transformation Mapping ℳ���� ℳ����: Distinct knowledge graphs are constructed according to topic, grouping relationship and entity information into topic-specific views.

5. Composite Transformation Mappings … 5. Composite Provenance Mappings

Valhalla constructs its five encapsulated knowledge layers upward through composable transformation mappings and traces provenance downward from each object to its sources. The provenance chain preserves canonical source records, allowing graph knowledge to be traced back to original files.

  • 5. Composite Transformation Mappings: Transformation mappings construct the five encapsulated knowledge layers bottom-up, and adjacent mappings can be composed for compact composite transformations.The four transformation mappings are summarized and may also be expressed in a readability-oriented composite form.
  • 1. Graph Provenance Mapping ℳ��: Graph provenance records both the Relationships and Entities used to construct each Graph.Graph provenance is represented as a set mapping from Graph objects to their constituent knowledge objects.
  • 2. Relationship Provenance Mapping ℳ���: Relationship provenance records the Entities from which each Relationship was constructed through a set mapping.
  • 3. Entity Provenance Mapping ℳ��: Entity provenance records the Resource from which each Entity was constructed through a set mapping.
  • 4. Resource Provenance Mapping ℳ��: Resource provenance records the Files from which each Resource was constructed and uses a canonical copied record to keep provenance reachable despite manual file changes.The canonical record is unaffected by manual operations, preventing changes to Files from rendering provenance unreachable.
  • 5. Composite Provenance Mappings: Knowledge Graph G provenance can be traced back to the original Files when necessary by composing the downward provenance mappings.The four provenance mappings are summarized and adjacent mappings can be composed into a readable composite form.

6 Formal Architecture of the Implemented Data Plane �∗

The implemented data plane operationalizes Valhalla’s layered knowledge-state architecture through multiple knowledge bases and a virtual Resource layer. It supports provenance-constrained resource selection, transformation into knowledge structures, and Root fusion within a shared data plane.

  • 6.1 Implemented Knowledge-State Architecture: The implemented architecture enables structured knowledge to be reused and reorganized at the Resource layer through multiple knowledge bases.This implementation provides the operational foundation for sharing and reorganizing structured knowledge.
  • 6.1 Implemented Knowledge-State Architecture: Each knowledge base has an independent knowledge space and a virtual Resource layer for constrained provenance tracing.The virtual layer complements the knowledge-space components while preserving provenance constraints.
  • 6.2 Virtual Resource Layer: The virtual Resource layer comprises four Resource-based components: local materials, required materials, excluded materials, and a Root-level blacklist.Local resources are considered but optional; required resources must be used; excluded resources must not be used; and blacklisted materials are globally disabled within the Root.
  • 6.2 Virtual Resource Layer: Excluded resources take precedence over local resources when their selections conflict.The exclusion rule ensures that resources marked as unusable are retained as excluded even when also registered for general use.
  • 6.3 Resource-to-Transformation Mapping: Resource-to-table transformation mappings assign Resources to local, required, or excluded Resource tables before subsequent knowledge transformation.The mappings formalize how resources enter the corresponding virtual-layer categories.
  • 6.4 Resource-to-Entity Transformation; 6.5 Shared Data Plane: The framework then defines Resource-to-Entity transformation and illustrates the virtual Resource layer through Root fusion in the shared data plane.Two distinct Roots are fused into a new Root, whose Resource layer is constructed as part of the shared data plane.

1. Resource-Layer Integration … 7 Control Plane: Constrained Knowledge Operations

Valhalla integrates resources through identity preservation, version separation, conflict-aware blocking, and fused knowledge bases, while governing language-model operations through routed services, explicit contracts, and auditable workflows. The design improves structural readability and operational consistency but remains normative rather than a complete security guarantee.

  • 1. Resource-Layer Integration: Resource integration preserves separate publication versions and avoids erroneous merging between similar but distinct materials.The Resource layer also supports reassignment of unified identities.
  • 2. Blocking Strategy: Blocking conflicts are resolved through user decisions that can globally block a Resource, block it locally within relevant knowledge bases, or allow it again.Global blocking adds the Resource to the new Root’s blocked set, whereas local blocking updates applicable entries under the originating Root.
  • 3. Fused Knowledge Base �: Knowledge bases under the two Roots are fused according to the selected blocking strategy.
  • 7 Control Plane: Constrained Knowledge Operations: The control plane converts natural-language requests into system services with explicit request classification, access scope, risk, confirmation, and output-validation conditions.It makes these operational boundaries explicit rather than simulating formal authorization through natural-language rules [22‑23].
  • 7.1 Microkernel-Based Service Structure: Valhalla uses a microkernel-inspired structure in which minimal resident rules perform self-checks, state identification, routing, and safety checks while capabilities load on demand.This design reduces irrelevant context occupancy and localizes service changes, but context compression may still fail to preserve critical constraints.
  • 7.2 Router: Routing Natural-Language Requests to Services: The Router classifies requests and selects a Contract, exposing ambiguity for clarification rather than combining unclear write scopes autonomously.It dispatches services without modifying knowledge or deciding final authorization.
  • 7.3 Contract: Operational Eligibility and Service Contract: The Contract checks eligibility and defines inputs, permissions, risk, prerequisites, confirmation, scope, outputs, and failure handling for each service.Delegated services must repeat Contract checks, and the resulting boundary is normative rather than an unbypassable security guarantee.
  • 7.4 Workflow: Readable and Modifiable Execution Procedures: After routing and eligibility checks, the Workflow executes ordered reads, registry checks, state updates, logging, validation, and conflict handling through reusable procedures.Readable workflows support interdisciplinary modification and auditability, but critical isolation, transactional commits, and permission enforcement should rely on external orchestrators or code-based mechanisms [18‑19] [22‑23].

8 Semi-Formal Architecture of the Control Plane ℂ · 1. System State �

The control plane ℂ is organized around system services, mandatory startup initialization, safety constraints, and distinct system and session state models. The system state describes Valhalla’s overall condition and governs operational permissions through base and administrative states.

  • 8.1 Microkernel Architecture: The control plane ℂ contains a set of system services, denoted �= {�1, �2, �3, ⋯}.
  • 8.1 Microkernel Architecture: Each element of the control-plane service set is defined as a system service.
  • 8.2 System Kernel �: Startup initialization is mandatory, implemented in Python, and performs system-integrity checks, state resets, and Router loading.
  • 8.2 System Kernel �: The system kernel includes safety constraints.
  • 8.3 System State �and Session State �: Valhalla distinguishes between a system state � and a session state �.
  • 1. System State �: The system state � describes Valhalla’s overall state and manages operational permissions through base and administrative states.

2. Session State �

Valhalla’s session state records whether the session is idle or active and identifies the target of system services. Its Router-Contract-Workflow architecture maps requests to governed services, constrains execution, and supports controlled, repeatable workflows.

  • Session State: Session state distinguishes idle sessions without a service target from active sessions with a service target.It describes the current Valhalla session and identifies the target of system services.
  • Router: The Router maps a natural-language request to the entry point of its corresponding operational contract.Router keywords trigger the relevant entry point.
  • Contract: The Contract uses structured language to govern workflow execution based on system and session state, service targets, permissions, and workflow entry points.Permissions include write authority and read-access scope.
  • Workflow: Workflows are constructed in natural language, while system services remain decoupled except for limited calls between services.When one service calls another, the second must execute fully rather than being bypassed through direct execution.
  • Workflow: Valhalla supports idempotent operations, so repeatedly executing a system service does not further change a knowledge state.This preserves stable behavior across repeated service execution.

9 Human-in-the-Loop Governed Service Evolution

Valhalla governs manual and LLM-driven service evolution through explicit components, targets, contracts, workflows, review, validation, and auditing. Human participation remains essential because generated services require testing, domain review, and boundary refinement rather than constituting evidence of effectiveness or general compliance.

  • 9 Human-in-the-Loop Governed Service Evolution: Governed service evolution extends or modifies services after a user identifies a functional need, either manually or through an LLM following predefined rules.The evolution workflow uses explicit components and targets, while natural-language workflows support review of operating mechanisms.
  • 9 Human-in-the-Loop Governed Service Evolution: Service evolution typically classifies requirements, generates candidates, checks boundaries, obtains human confirmation, registers and validates changes, and audits their effects [10‑14].Because service changes affect future requests, completing the current task alone cannot establish successful registration.
  • 9 Human-in-the-Loop Governed Service Evolution: Valhalla constrains evolution against implicit inheritance, permission expansion, cross-layer writes, and weak validation through explicit scope, independent components, non-inherited confirmation, and diagnosable failure.These constraints require external validators, tests, and orchestration to become enforceable; contracts or workflows alone may be misinterpreted.
  • 9 Human-in-the-Loop Governed Service Evolution: Generating service files does not demonstrate reliable capability, stable model safety classifications, or general biomedical compliance; effectiveness still depends on testing, inputs, and domain review.Valhalla’s basic version also lacks a built-in experimental-protocol review service, so users must evolve one for their requirements.
  • 9 Human-in-the-Loop Governed Service Evolution: An experimental-protocol review service can read relevant Entity, Relationship, and Graph objects, cite Resources, produce reports and validation hypotheses, and avoid modifying relationships without confirmation.Its workflow identifies objectives, maps entities, examines relationship chains, locates evidence gaps, generates risk alerts, and records review logs.
  • 9 Human-in-the-Loop Governed Service Evolution: Human specialists can manually add or modify Router, Contract, and Workflow components, combining model-generated setup with fine-grained maintenance for domain-specific requirements.In an antibody-design ingestion-service case, manual revision narrowed a safety-sensitive capability to review-level information while excluding executable procedures and high-risk optimization pathways.

10 Case Study: A Knowledge-Governed Scientific Writing Workflow Based on Valhalla

The case study evaluated Valhalla on cross-domain antibody-review writing, testing knowledge ingestion, service evolution, knowledge sharing, and knowledge-state-based writing support. Valhalla improved evidence-rich scientific writing and long-term workflow efficiency, while requiring upfront knowledge-ingestion investment.

  • Case-study hypotheses: The case study tested whether structured knowledge states support continuous reuse, whether Router–Contract–Workflow services lower domain-adaptation barriers, and whether governed evolution preserves transparency and maintainability.It evaluated knowledge ingestion, system evolution, knowledge-asset sharing, structured organization, and scientific writing support in a research-team setting.
  • Service evolution: Valhalla’s evolution mechanism adapted services to antibody-design requirements through Router entries, Contracts, and Workflows governing ingestion, extraction, evidence mapping, and logging.Researchers also modified the Workflow and added safety constraints, restricting the service to conceptual knowledge, evaluation metrics, research background, and public experimental results.
  • Knowledge-state construction: The experiment produced a reusable antibody-design knowledge state containing 26 paper Resources, 80 Entities, and 92 Relationships for subsequent scientific tasks.The case used PVRIG/antibody review generation as a cross-domain task spanning immunology, biomedical knowledge, and engineering design.
  • Scientific writing support: Valhalla-supported reviews provided more comprehensive coverage, more specific experimental references, deeper mechanism discussion, and stronger evidence-based organization than paper-workflow-only output.Entities and Relationships let the model build arguments around stable knowledge objects, reducing knowledge loss and breaks in evidential chains.
  • Scientific-task efficiency: 79% lower initial generation time and approximately 30 minutes per writing iteration demonstrated Valhalla’s efficiency advantage when knowledge states and services were reused.Initial knowledge ingestion required approximately 300 minutes, so the workflow may offer no time advantage for only one task but can amortize costs across subsequent tasks.

11 Limitations, Failure Modes, and Governance Boundaries

Valhalla’s evidence is limited to an architectural description and a single, methodologically weak case study, while its governance mechanisms remain vulnerable to failures in ingestion, service independence, platform safety, state consistency, and context management. These design intentions should not be treated as runtime guarantees until validated through larger, more rigorous, and auditable evaluation.

  • Evidence limitations: The single case study lacked randomization, replication, matched-budget baselines, ablations, and auditable expert evaluation, so its time and score differences cannot establish causal effects or validate D1–D3.Model-assisted evaluation also lacked disclosed judge configuration and bias testing; broader evaluation should examine knowledge quality, task performance, governance failures, cost, and cross-member transfer.
  • Ingestion failure modes: Batch ingestion can combine methods, conditions, and conclusions across documents, undermining evidence mapping when each source is intended to remain an independent boundary.This failure can occur even when a Workflow requires documents to be processed individually.
  • Service-governance boundaries: Natural-language Router, Contract, and Workflow specifications can be reinterpreted, creating undeclared service dependencies whose behavior changes when referenced services are modified.New services must separately register and verify dependencies, read/write scopes, and confirmation conditions rather than inheriting implementation, permissions, or qualifications by default.
  • Safety boundaries: Underlying platform safety policies can refuse biomedical or experimental tasks after internal permission checks, and Valhalla currently lacks complete mechanisms to distinguish refusals, service failures, and committed states.Staged commits, failure markers, human review, and recoverable transactions are proposed without bypassing platform safety mechanisms.
  • State consistency: Directly editable persistent states risk partial commits, concurrent overwrites, and inadvertent changes because automatic snapshots, transactional commits, and verifiable rollback are not yet bound to every operation.Recovery currently relies mainly on local backups and manual restoration, so visibility alone cannot establish transactional safety.
  • Context and evaluation boundaries: Without an independent context-scheduling layer, model compression can erase constraints, provenance detail, and confirmations, making long-running failures difficult to reconstruct.The current system cannot precisely schedule, compress, evict, or restore context objects, and external validity is limited to one topic, team, and run.

12 Conclusion

Valhalla presents a layered knowledge-state and service-governance framework that makes structured knowledge shareable and recomposable for long-term scientific knowledge work. Its prototype demonstrates layered-state construction and service invocation, but current evidence does not establish comparative superiority, long-term reuse benefits, or realization of D1–D3.

  • Framework contribution: Valhalla combines a File–Resource–Entity–Relationship–Graph data plane with a Router–Contract–Workflow control plane for structured scientific knowledge work.The data plane distinguishes document entry points, stable identities, knowledge objects, semantic judgments, and task-oriented views; the control plane organizes request classification, eligibility checks, and constrained execution.
  • Framework contribution: The framework’s primary contribution is a layered architectural protocol that makes structured knowledge a shareable and recomposable asset for LLM-assisted scientific collaboration.It extends collaboration from sharing agents to sharing structured knowledge.
  • Limitations: The PVRIG writing case shows that the prototype can construct layered knowledge states and invoke relevant services, but its time and quality scores come from one independently unaudited workflow.The case does not demonstrate that Valhalla outperforms RAG, GraphRAG, general memory systems, or workflow-only methods.
  • Limitations: The available evidence does not establish long-term reuse benefits or realization of D1–D3 [4‑6,18‑19].The conclusion identifies these claims as unsupported by the current evaluation evidence.
  • Future work: Future evaluation should use multi-task comparisons, component ablations, independent replications, blinded expert evaluations, knowledge-quality audits, fault injection, and longitudinal cost measurements under a frozen protocol.It should also provide independently reviewable code, configurations, corpus inventories, and raw evaluation records before determining whether layered knowledge states and service governance constitute a general contribution.
Loading 2608.15193v1…