acceptodds
Under review as a conference paper at ICLR 2027

OMNE-Engram: A Programmable Knowledge Substrate for Agents with Governed Schema Evolution

Abstract

Long-horizon agents need knowledge representations that evolve with their domains, tasks and information. Retrieval-augmented generation and memory systems often couple representation and retrieval within application-specific pipelines, leaving each application to coordinate structural revisions, validation and query support. We present OMNE-Engram, a programmable knowledge substrate whose domain schemas and governing contracts (covenants) configure reusable write validation, declaration activation and query admission. We establish its representation capacity through theory and experiments: finite typed relational structures admit lossless encoding under stated assumptions, and reconstructed structures and predefined query results match three heterogeneous sources exactly. Fixed-domain applications approach the strongest baselines across five knowledge-QA and memory benchmarks. Agents driven by three different LLMs further design schemas and covenants and revise them through system checks. Together, these results support OMNE-Engram as a reusable foundation for knowledge applications and governed, agent-driven knowledge construction and evolution.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Knowledge representation, long-horizon agents, agent memory, retrieval-augmented generation, schema evolution, governed self-evolution

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_pDDgOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes a programmable knowledge substrate that supports domain-specific schemas, governance constraints, and query capabilities for LLM agents. The system enables agents to construct and revise knowledge representations while enforcing predefined constraints. The authors validate structural fidelity and constraint enforcement across heterogeneous data sources, evaluate knowledge QA and memory applications against existing systems.

Critical strengths

The paper presents a comprehensive system design that integrates schema management, constraint enforcement, and query capabilities into a unified framework. The structural fidelity and fault-injection experiments provide evidence that the implemented mechanisms behave as intended across heterogeneous knowledge sources.

Critical weaknesses
  • Limited novelty. The proposed framework largely builds upon established database and knowledge-management mechanisms. Although the integration of schema evolution, governance constraints, and query preparation is a potentially useful systems contribution, the paper does not sufficiently establish its technical novelty over existing programmable knowledge systems.

  • Insufficient evidence of the proposed mechanisms' practical value. The fixed-domain experiments demonstrate competitive QA and memory performance but do not isolate the benefits of governance or schema evolution. Agent-driven revisions yield only marginal or inconsistent improvements, without independent repeated runs or uncertainty estimates to establish their reliability. Moreover, the lack of simpler schema-revision baselines and component-level ablations makes it difficult to attribute any gains to the proposed mechanisms.

Questions for authors
  1. What are the key technical innovations beyond existing schema-management and knowledge-graph systems?

  2. How much improvement can be attributed specifically to governed schema evolution rather than the underlying retrieval and construction pipelines?

  3. Are the small improvements from agent-driven revisions consistent across repeated runs and random seeds?

  4. Can the authors compare against a simpler schema-revision baseline without the proposed governance framework?

Reviewer_KXAbOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces OMNE-Engram, a knowledge substrate in which each domain consists of a schema, a governing contract called a covenant, and a typed knowledge graph. The schema specifies node types, edge types, fields, and structural constraints. The covenant specifies operational requirements, including write permissions, provenance requirements, schema-evolution policies, locked invariants, audit history, infrastructure commitments, and required query capabilities. These declarations control how the system validates writes, approves schema and covenant revisions, prepares access structures such as indexes, and admits queries. The paper evaluates OMNE-Engram in three ways:

  1. It maps Reactome, BiomedSQL, and CypherBench into the substrate, testing structural reconstruction, fixed queries, and fault rejection.
  2. It builds fixed knowledge-QA and long-term-memory applications and compares them with RAG and memory baselines on HotpotQA, 2Wiki, MuSiQue, LoCoMo-R, and EMB-D.
  3. It asks three LLM agents to design and revise schemas and covenants through the public interfaces, using system feedback to repair invalid writes or revise domain declarations. The paper also includes a representation theorem showing that finite typed relational structures can be encoded and reconstructed under explicit assumptions.
Critical strengths

S1. The governance model is conceptually coherent and technically well motivated. The separation between schemas, covenants, stored knowledge, and derived query structures is sensible. In particular, checking a proposed revision against the currently active covenant prevents an agent from granting itself additional authority through the covenant it is trying to install.

S2. The paper evaluates several layers of the system rather than reporting only downstream QA scores. The experiments include structural reconstruction, query agreement, fault localization, state preservation after rejection, access-materialization behavior, and agent revision traces. The appendix also clearly states several untested cases, which makes the current evidence easier to interpret.

Critical weaknesses

W1. The downstream application results are not causally attributed to OMNE-Engram’s core mechanisms. The knowledge-QA and memory systems use manually designed schemas, covenants, extraction strategies, graph organization, retrieval procedures, and agent prompts. The paper does not compare against a matched implementation using the same pipeline on a standard graph store, without covenants, without query admission, or without declaration-driven access preparation. As a result, Table 4 shows that the complete hand-designed pipeline can be competitive, but not that the substrate or governance features are responsible for the performance.

W2. The evidence for governed agent-driven evolution is too narrow for the strength of the claim. The fault-injection evaluation tests known constraints with deliberately constructed minimal violations. This is useful as a unit test, but it does not demonstrate that the system can detect semantically incorrect but structurally valid changes, manage conflicting revisions, handle concurrent writers, prevent failures caused by stale indexes, or safely govern complex multi-step agent behavior. The agent-designed domains also remain materially below the manual domain, and most revision gains are small.

Questions for authors

Q1: Could the authors provide matched ablations for the fixed-domain QA and memory applications? The extraction model, answering model, agent harness, read limit, prompts, and total resource budget should be held fixed while separately removing or replacing:

  • the OMNE-Engram substrate;
  • covenant-based write and revision checks;
  • query admission;
  • declaration-driven derived access structures. This would clarify which component is responsible for quality or reliability improvements.

Q2: Could the authors report complete resource usage rather than only the final-call input-token accounting? This should include all model-call input and output tokens, embedding tokens, tool calls, wall-clock time, index construction time, and hardware configuration. This is particularly important because OMNE-Engram has substantially higher final-call input totals than several memory baselines on EMB-D.

Q3: Can the authors report stability over multiple runs or provide significance testing? The main application scores come from one run, and the agent-evolution experiment uses small development/evaluation folds. It would be useful to report variation across runs, model versions, and genuinely held-out evaluation data.

Reviewer_xDvjOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents OMNE-Engram, a knowledge store for agents in which each domain declares a schema and a governing contract called a covenant. The covenant's six facets fix which types and fields the schema must keep, which query capabilities must be prepared, who may write or revise the domain, and which values are locked. The system checks every write against both declarations. A revised schema and covenant become active together only if the currently active covenant permits the change, and a query is admitted only after the index it needs is fully built. Theorem 1 shows that finite typed relational structures can be encoded losslessly as graphs in the store. Experiments show exact hosting of three sources and rejection of every injected fault, QA and memory applications that roughly match strong baselines on five benchmarks, and three LLM agents that design and revise working domains.

Critical strengths
  1. Careful governance semantics for self-revising agents. Revisions are authorized by the active covenant rather than the candidate, so an agent cannot grant itself new authority, and a relaxed rule still binds the revision that relaxes it. These conditions are stated precisely (Eqs. 3–6), together with what is not enforced. Guardrails of this kind are a real need once agents edit their own knowledge structures.

  2. Transparent reporting. The paper states the scope of each test, reports exact intervals, notes single runs, and accounts for tokens. One substrate hosts three heterogeneous sources and supports QA and memory applications that are competitive with specialized systems.

Critical weaknesses
  1. No evidence that covenants or governed evolution help. These are the paper's distinctive parts, but the experiments only show that they run as specified. The fixed-domain applications use none of the revision machinery and roughly match the baselines, trailing by up to 4.63 points. On EMB-D under GPT-5.6-luna they also use 5× the answering input of the best baseline (57.33M vs. 11.28M tokens, Table 9). Agent-driven revision changes MuSiQue F1 by +0.05 to +0.53 and LoCoMo-R accuracy by −0.72 to +2.17, which is −1 to +3 questions out of 138, and agent-designed domains stay about 6 points below the manual one (Table 6). No experiment runs the same agents without governance, so it is unknown what the checks prevent or enable. The authority protection is never tested with an agent that tries to relax its own covenant. This gap drives my rating.

  2. The theory and structural tests check standard properties. Theorem 1 is the standard ordered incidence encoding (Courcelle & Engelfriet, §1.9.1), which any typed property-graph store with JSON fields admits. It says nothing about covenants, and the native checks do not fully enforce the class L ( S , C ) L(S,C) the theorem uses: they accept some values outside V V and do not prevent duplicate tuple nodes (App. A). The hosting and fault-injection results (1,800/1,800, 220/220 and 70/70 rejected) are correctness tests of rule classes the authors implemented, with requirements derived from the source data. The paper itself notes that the intervals "describe this run, not independent evidence for other rules", and topology and CEL rules, changesets, concurrent writers and the Cypher entry are untested. No existing system, such as TerminusDB or a relational database with constraints, is run on the same faults, so the self-assessed feature matrix in Table 1 is the only comparison. The reproducibility statement does not mention releasing code, so the system claims are also hard to verify.

Questions for authors

Can you run the same design agents with governance disabled, or under a permissive covenant, and report corrupted records, broken queries or task accuracy? This would show what the governance layer contributes.

Can you test the authority protection directly, with an agent instructed or rewarded to relax its covenant or drop anchored fields, and report how often it tries and how often it is stopped?

Will the system code be released? The system is the main contribution, and the reproducibility statement does not mention code.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.