Toward a Geometric and Compositional Knowledge Architecture for Robin

Abstract

Robin is evolving from a system that stores and retrieves atomic organizational knowledge into one that constructs contextual interpretations from that knowledge. Conventional document search, vector retrieval, and knowledge graphs each solve part of this problem and none solves it alone. Organizational knowledge is distributed across persistent domains; initiatives combine several such domains around an objective; claims interpret evidence within those contexts; and artifacts translate those interpretations for different audiences.

This paper proposes a conceptual architecture built from five layers: Signals (evidence with provenance), Domains (persistent semantic boundaries that classify Signals), Claims (propositions derived from Signals, carrying justifications and an explicit standing), Dimensions (interpretable axes along which Claims can be positioned and compared), and Initiatives (goal-scoped compositions of several Domains that change which Dimensions matter). Claim standing is maintained by a justification-based dependency network in the tradition of truth maintenance systems, so that new or retracted evidence changes labels locally rather than triggering global recomputation. Dimensions follow Gärdenfors' conceptual spaces in spirit but are specified as a constrained, versioned contract rather than as a learned embedding. The runtime separates a fast retrieval path that reads precomputed structure from a slow reasoning path that writes it.

The thesis is that expensive intelligence should write structure and cheap intelligence should read it. Nothing in this paper has been run. The evaluation plan in Section 10 states, for each component, the baseline it must beat, the metric, how the test set is built, the threshold that counts as success, and the result that would cause the component to be dropped, and it includes a cost ledger with a break-even condition for the claim that reads become cheaper.

1. Thesis and Scope

This is an architecture proposal, not a report of results. It describes a design for Robin, a system for organizational knowledge, and it argues that the design is worth building by showing that each part has a concrete mechanism and a concrete test. Where a formal framework is invoked only for intuition, the text says so and keeps it short.

The thesis is a single claim: for an organizational knowledge base that is queried far more often than it is reasoned over, precomputing an interpretation layer (Claims with maintained standing, positioned on validated Dimensions) will improve retrieval quality and artifact quality relative to a system that keeps no such layer and instead retrieves Signals with a strong hybrid retriever and reasons over them per request when reasoning is needed, at a per-query cost that is lower, not higher, because the expensive reasoning is done once at write time and amortized across reads.

The thesis has a quality half and a cost half, and each can fail separately, and both are tested against the same alternative: no persisted Claims, hybrid retrieval over Signals for reads, per-request reasoning for artifacts. The quality half is wrong if that alternative matches the full system on retrieval quality in Section 10.1, where a Signals-only hybrid arm is run, and on artifact quality in Section 10.2, where the slow path is run per request with persistence disabled. The cost half is wrong if the total spend on slow-path writes, per-Signal ingest checks, and fast-path reads never falls below the alternative's spend at the read/write ratio pilot workspaces exhibit; Section 10.5 states the ledger. In either case the structure layer is not paying for its own construction, and Robin should be that alternative, not a knowledge model. The thesis is also wrong in a weaker way if the structure helps but goes stale faster than the slow path can maintain it; Section 10.5 states the staleness measurement that would show this.

The remainder of the paper proceeds from the bottom of the stack upward. Sections 2 through 4 define Signals, Domains, Initiatives, and Claims, including where Claims live and how their standing changes. Sections 5 and 6 define Dimensions and their relationship to Domains and Initiatives. Sections 7 and 8 describe the runtime. Section 9 places the design against prior work, Section 10 gives the evaluation plan, and Section 11 concludes.

2. From Signals to Contextual Knowledge

Robin begins with a simple premise: organizational knowledge should be stored at a finer granularity than documents. Entries represent incoming material, such as conversations, meetings, emails, reports, and database exports. Robin extracts Signals from Entries: atomic pieces of knowledge, each carrying provenance back to its Entry and a semantic embedding. This is the proposition-level granularity that Chen et al. (2024) found to outperform passage-level retrieval units, and Section 10.2 takes that result seriously as a reason to suspect that fine-grained Signals alone may capture much of what a Claim layer would add.

Earlier Robin architecture introduced both Signal Databases and Knowledge Domains. The revised ontology collapses these. A Domain performs the persistent semantic-boundary function directly. A Domain has a description and classification logic, and Signals relevant to that description are attached to it. An Entry yields Signals, and each Signal is classified into one or more Domains; a Domain might represent Climate Change, Kenya, Engineering Practice, Enterprise Sales, Customer Knowledge, or Organizational Relationships.

Domain embeddings and classifiers already provide a useful broad routing mechanism. A new Signal is embedded and classified against Domain descriptions to determine which persistent knowledge contexts it belongs to. This existing mechanism remains the primary semantic routing layer; nothing in the geometric machinery below duplicates it. Because Domain scope acts as a hard filter on the fast path, the classifier's precision and recall matter directly to everything downstream, and Section 10.7 measures them.

Persistent Domains are insufficient for goal-directed work, because organizations regularly undertake activities that cross several knowledge areas at once. Robin therefore introduces the Initiative. An Initiative represents something the organization is trying to accomplish. It attaches multiple Domains and creates an active context in which their knowledge can be composed. A Kenya Climate Implementation Initiative, for instance, might attach the Climate, Kenya, Funding, and Relationships Domains.

The Initiative does not merge these Domains. Climate knowledge remains Climate knowledge; country knowledge remains country knowledge. The Initiative asks which portions of these Domains matter together for the objective at hand.

This distinction matters because valuable organizational knowledge often exists not inside a single Domain but at the intersection of several. Suppose Robin knows four things: Foundation X funds climate adaptation programs; Consortium Y operates within several Kenyan counties; the organization has an established relationship with Consortium Y; and county governments control a relevant implementation mechanism. None of these facts individually implies a strategy. Within the Initiative, together, they may support a new proposition: partnering with Consortium Y may provide the strongest route for accessing and implementing Foundation X's county-level climate program.

That proposition is not another Signal. It is an interpretation produced by combining evidence. This is the role of the Claim.

3. Claims as an Interpretation Layer

Signals represent evidence. Claims represent propositions constructed from evidence. Claims occupy a layer between raw organizational evidence and the artifacts presented to users.

3.1 The Claim record

A Claim is a record

$$C = (\text{proposition},\ J,\ \text{context},\ \text{standing},\ H)$$

where the proposition is a natural-language statement; $J$ is a non-empty set of justifications, each of which is a set of antecedent Signals and Claims from which the proposition was derived together with a derivation record (which model or person produced it, when, and from which Initiative); context is the set of unevidenced preconditions under which the proposition is asserted, defined precisely in Section 3.2; standing is one of the five states defined in Section 3.3; and $H$ is the Claim's home, the set of Domains from which its supporting Signals were drawn. Dates are not a separate field: when the Claim was asserted is in the derivation record, and when its evidence was observed is on the Signals in $J$.

The distinction between Signals and Claims solves a concrete problem. Consider a client saying, "Users should be able to see everything we sell and quickly narrow down the options." That Signal records the client's requirement. Robin may separately know, through an Engineering or UX Domain, that large catalogs commonly require faceted filtering, product grids, pagination, and information hierarchy. Within a client Initiative, Robin might derive Claims such as: the client requires a catalog-browsing experience; the primary workflow is browse, filter, inspect, select; the catalog likely requires faceted filtering; catalog retrieval should be separated from presentation components.

The same Claims support very different artifacts. An engineering specification might list a filter panel, product grid, pagination, and detail transition as components of a catalog page. A stakeholder document might instead state that customers will be able to browse the catalog, narrow products using relevant filters, inspect options, and select a suitable product efficiently. The interpretation is the same; the renderer changes because the audience changes. Artifact generation should therefore not itself become the canonical reasoning layer. Artifacts render a contextual Claim model.

3.2 Where Claims live, and what context holds

Claims are Domain-scoped, not Initiative-scoped. A Claim is stored once and indexed under every Domain in its home set $H$. The Initiative that derived it is recorded in the derivation record.

The alternative, Initiative-scoped Claims, was rejected because it prevents reuse: a second Initiative attaching the same Domains would have to rederive the same interpretations. The cost of the Domain-scoped choice is that a Claim derived under one Initiative's assumptions is visible to others, so those assumptions must be carried explicitly rather than left implicit in the Initiative. Assumptions are handled in two ways depending on whether evidence for them exists.

An evidenced precondition is one that some Signal or Claim in the workspace asserts. When the slow path derives a Claim under an assumption, it is required to search for a Signal or Claim asserting that assumption; if one is found, that node is added to the antecedent set of every justification of the new Claim. The assumption then lives in $J$, not in context, and the dependency network of Section 3.4 retracts the Claim automatically when the evidence for the assumption is withdrawn. A Claim asserted "assuming the Foundation X program is still open," where a Signal records that the program is open, carries that Signal as an antecedent and is retracted when a later Signal supersedes it.

An unevidenced precondition is an assumption for which no evidence was found. Only these are stored in context. Two mechanisms read the field. The renderer must print every unevidenced precondition beside any Claim it cites, in every audience register, and Section 10.2 has a rater check for this. And on every slow-path run that touches the Claim, the search for evidence is repeated; a precondition that acquires evidence moves from context into $J$. Unevidenced preconditions are exactly the assumptions an assumption-based truth maintenance system would label nodes with, which is why Section 3.4 names context as the placeholder for that extension.

Visibility follows from the home set. A Claim $C$ is in scope for an Initiative $I$ when $H(C) \subseteq \text{Domains}(I)$: every Domain the Claim drew evidence from is attached to the Initiative. A Claim combining Climate and Kenya evidence is not surfaced to an Initiative that attaches only Climate. This is a visibility rule, not a theorem. The looser rule $H(C) \cap \text{Domains}(I) \neq \emptyset$, with a fitted rerank penalty on each home Domain the Initiative does not attach (the coefficient $\nu$ of Section 6), is the natural alternative, and Section 10.4 gives the decision rule between them. Outside any Initiative, ordinary search scopes by Domain and sees every Claim indexed there.

3.3 Standing

Standing is the Claim's status in Robin's current view of the evidence. It has five states: proposed, accepted, contested, retracted, and superseded. Standing is not a probability; Robin does not maintain a probabilistic semantics for Claims, and Section 9 explains why factor graphs were considered and not adopted.

The states and their transitions are:

Users move Claims by acceptance, rejection, supersession, and conflict resolution. The dependency network moves Claims when the support status of their antecedents changes and when the automatic acceptance rule fires. The slow path creates Claims and supersession edges but never directly sets standing to accepted.

3.4 Dependency tracking

Robin maintains standing with a justification-based dependency network, adapting the justification-based truth maintenance approach of Doyle (1979). The mechanism is small enough to state completely.

Nodes are Signals and Claims. A Signal is supported unless its source Entry has been withdrawn or a later Signal from the same source explicitly supersedes it. A Claim is supported when at least one of its justifications has all antecedents supported. A conflicts_with edge is a symmetric relation between two Claims asserted by the contradiction check below; each edge records which branch of the check wrote it. Two overrides sit above the support computation: a supersedes edge pointing at a Claim sets its standing to superseded from whatever state it was in, and a user rejection sets it to retracted, and propagation changes neither. Deleting a conflicts_with edge is an edit to the graph, not an override. For a Claim with no override, standing is a function of support and conflict: an unsupported Claim is retracted; a supported Claim with a conflicting partner whose standing is neither retracted nor superseded is contested; a supported Claim with no such partner is accepted if it has been accepted and not since retracted, and proposed otherwise.

The update rule is propagation along justification edges. When a Signal or Claim changes support status, every Claim that lists it as an antecedent is re-evaluated; each Claim whose support status changes is pushed onto the same queue; the process runs until the queue is empty. Because Robin's justifications are monotone (a Claim is justified only by the presence of supported antecedents, never by the absence of something), propagation cannot oscillate and terminates in time linear in the number of edges reached. Doyle's non-monotonic justifications, which support a belief on the condition that some other node is out, are deliberately excluded. Robin therefore cannot represent a Claim justified by the absence of evidence; a Claim such as "no competing bid has been submitted" must be justified by a Signal that asserts it.

Support must also be well-founded: a pair of Claims that justify each other with no Signal beneath them must not count as supported. Cycles cannot arise from derivation, because a derived Claim's antecedents exist before it does. The one path that could create a cycle is the supports verdict below, which adds a new object as an antecedent to an existing justification; before that edge is written, the network checks whether the consequent Claim is an ancestor of the new antecedent through existing justification edges, and rejects the edge if so. With that check, every supported Claim has a finite justification chain ending in Signals.

Propagation changes labels; it does not regenerate text. This is what keeps it cheap. When a Claim becomes retracted or contested, the slow path is scheduled to re-derive it only if the Claim is in scope for an active Initiative or was retrieved in the last thirty days. Re-derivation means running derivation again for the same question the Claim answered against the evidence now present: if the proposition that results differs, it is written as a new Claim with a supersedes edge to the old one; if the same proposition is re-supported by different evidence, the new justification is added to the old Claim; otherwise nothing is written. Everything else stays labeled and dormant until something reads it.

Writes to a Domain are processed in slow-path batches flushed at an interval $\Delta$ ($\Delta = 5$ minutes initially). Within a batch, a newly written Claim is projected onto the active Dimensions of its home Domains (Section 5.3) before its contradiction check runs, so that the check sees positions. Projection adds at most $K$ small-model calls per Claim to the batch, one per active Dimension, and the batch interval bounds how quickly any write can change another Claim's standing: a contradiction is detected no later than $\Delta$ plus the batch's processing time after the contradicting object is written.

The contradiction check runs whenever a Signal or Claim is written to a Domain. Signals are not projected onto Dimensions (Section 5.3), so the candidate step differs by input type. When the new object is a Claim, candidates are the $k$ nearest existing Claims in the same Domain by embedding similarity ($k = 20$ initially), restricted to those that share at least one Dimension $d$ on which both Claims have relevance $r_d \geq \tau_r$ and whose positions differ by $\delta_d > \tau_\delta$, with $\tau_r = \tau_\delta = 0.5$ initially and $\tau_r$ the same relevance threshold used in Section 5.4. This is the signature from Section 5.3: high topical similarity, opposite conceptual position. If fewer than five candidates survive the filter, it is relaxed to similarity alone so that Claims with no Dimension coverage are not exempt. When the new object is a Signal, candidates are the $k$ nearest Claims by similarity alone, since the Signal has no position to compare, subject to a similarity floor $\tau_s$: a Signal whose nearest Claim falls below the floor has no candidates and costs no classifier calls, which is what keeps ingest cost bounded in Domains with few Claims. The floor is set permissively, initially at the lowest decile of Signal-to-nearest-Claim similarities in the Domain, and Section 10.3 reports how many injected contradictions it removes. In both cases, a classifier then labels each (new, candidate) pair as supports, contradicts, or unrelated. The classifier is a small natural-language-inference model by default; this is the contradiction-detection task that de Marneffe, Rafferty, and Manning (2008) found harder than entailment on real text, with precision the scarcer quantity, which is why Section 10.3 sets separate precision and recall bars and names a stronger model or a human queue as the fallback. A contradicts verdict writes a conflicts_with edge tagged with the branch that produced it; a supports verdict may add the new object as an antecedent to an existing justification, subject to the cycle check above.

Because conflicts_with joins two Claims, a contradicting Signal is first lifted into a proposed Claim that restates its proposition and is justified by that Signal alone, and the edge joins the lifted Claim to the one it contradicts. That lifted Claim is supported as long as its Signal is, which is what moves the contradicted Claim to contested. A lifted Claim is written with its work already done and does not re-enter the write path: it is not projected, it triggers no contradiction check of its own, and it is not indexed for retrieval, since the Signal it restates is what a reader should see. It exists to carry the edge and its support. If a later slow-path run derives the same proposition as an ordinary Claim, that Claim enters the write path once, like any other, and takes over the edge. A Claim written with no supported antecedent is retracted on arrival and can contest nothing; every Claim that enters the check has, by Section 3.1, a non-empty justification. The cost is therefore at most $k$ classifier calls plus one lifting call per write, on the slow path, and Section 10.5 carries the per-Signal share of that cost as its own ledger line. Whether the position filter earns its place, by improving candidate precision over similarity alone at fixed $k$, is tested in Section 10.3.

De Kleer's assumption-based extension (1986), which labels each node with the minimal assumption sets under which it holds, is not adopted at first. It becomes relevant if Initiatives need to hold mutually inconsistent working assumptions in parallel; the unevidenced preconditions in context are the placeholder for that.

4. Explicit Graphs and Geometric Relationships

Robin already contains many relationships naturally represented as graph edges: a Signal is extracted from an Entry; a Person authored an Entry; a Signal is classified into a Domain; a Signal or Claim justifies a Claim; an Artifact cites a Signal or Claim; an Initiative attaches a Domain; a Claim conflicts with or supersedes another Claim. These relationships have explicit semantics. They answer who said something, where information originated, what evidence supports a proposition, and which Domains participate in an Initiative.

Many organizational relationships cannot be named so precisely. Two Claims may be highly similar without either supporting the other. Two Claims may concern exactly the same subject but take opposite positions. A Claim may sit between two established clusters of knowledge. An Initiative may create a previously unseen intersection between distant Domains. These are better understood as geometric relationships.

Gärdenfors' theory of conceptual spaces was developed partly to address the limitations of purely symbolic representation. In a conceptual space, entities are represented by their positions on interpretable quality dimensions, and similarity is related to distance; the framework is intended as an intermediate level between symbolic and connectionist representations (Gärdenfors, 2004).

One terminological collision must be resolved before borrowing anything. Gärdenfors uses "domain" for a set of integral quality dimensions that are perceived together, such as hue, saturation, and brightness forming the color domain. Robin's Domain is a topical routing boundary (Climate, Kenya), which is a different object. Throughout this paper, "Domain" with a capital letter means Robin's routing boundary; Gärdenfors' notion is written "quality domain" when it appears. Robin's nearest analogue to a quality domain would be a group of integral Dimensions within a Robin Domain, which this design does not yet model: Dimensions are treated as separable, and Section 5.4's redundancy check is the only place their interaction is examined.

The separation this suggests for Robin is: graphs encode relationships Robin can explicitly name; geometry represents relative conceptual position. An embedding already provides geometry, but its coordinates are opaque. A Claim's embedding vector $[-0.28,\ 0.71,\ 0.04, \ldots]$ supports cheap cosine similarity and offers no organizational explanation. A conceptual-space representation instead positions the Claim on named axes, such as funding availability, policy support, implementation feasibility, and partner access. Such coordinates allow Robin to explain not merely that two Claims are close but along which axis they are close or far.

5. Dimensions as Learned Organizational Structure

The central experimental primitive is the Dimension. A Dimension is not a tag. "Funding" is a topic. "Funding availability" can become a Dimension only if knowledge objects can meaningfully be compared with respect to it.

5.1 The Dimension contract

A Dimension is

$$d = (V_d,\ \rho_d,\ P_d,\ v_d)$$

where $V_d$ is the value space; $\rho_d$ is the native comparison function on $V_d$, from which the normalized dissimilarity $\delta_d$ of Section 5.2 is derived; $P_d$ is a set of prototypes, anchors, or reference points; and $v_d$ is an integer version, discussed in Section 5.5. One Dimension might use a bounded scalar with absolute difference as $\rho_d$, another an ordered categorical scale with rank distance; the registry of Section 5.2 defines the admissible value spaces and their comparison functions. What stays consistent is the contract, not the internal mathematics.

Alshaikh, Bouraoui, and Schockaert (2020) distinguish conventional embeddings, whose dimensions lack clear semantic interpretation, from conceptual spaces, whose dimensions correspond to interpretable semantic features, and they observe that such features are often pertinent only to subsets of entities rather than to one global space. Their method partitions an embedding space by top-level features and then identifies features specific to each partition. Robin's structure mirrors that observation: Dimensions are Domain-specific. A Climate Domain might carry climate severity, funding availability, policy support, and adaptation feasibility. An Engineering Domain might carry implementation complexity, reliability, reversibility, operational maturity, and performance sensitivity. Their method is also a candidate generator for Dimension discovery in Section 5.4, distinct from the LLM-proposal route, and the evaluation plan compares the two.

5.2 A constrained Dimension specification

Robin should not allow models to invent arbitrary executable mathematics. Each Dimension is expressed as a validated specification that references implementations from a controlled registry: a value-space specification, a projection system, a comparison metric, a normalizer, prototypes, provenance, and version. A TypeScript/Zod schema constrains model-generated specifications, and a compatibility validator checks that the chosen components make sense together (an ordinal metric cannot be attached to an unordered categorical value space). Robin maintains registries of value spaces, projection systems, metrics, normalizers, and aggregators. A model composes approved primitives; it does not generate formulas.

Robin normalizes comparison outputs rather than native values. For any Dimension $d$, the normalizer maps $\rho_d$ to a standardized dissimilarity

$$\delta_d(x, y) \in [0, 1]$$

that is $0$ when two positions are indistinguishable and $1$ when they are maximally different on $d$. This lets different native representations coexist while still permitting comparison at the reranking layer.

5.3 Four quantities

The system distinguishes four independent quantities for a Claim $x$ and Dimension $d$. The value $\pi_d(x) \in V_d$ is where $x$ lies on $d$. The relevance $r_d(x) \in [0, 1]$ is how strongly $x$ concerns $d$ at all; the relevance threshold $\tau_r = 0.5$ is the single cut used wherever the paper asks whether an object is relevant to a Dimension. The distance $\delta_d(\pi_d(x), \pi_d(y))$ is how different two positions are. The salience $w(d)$ is how much $d$ matters in the current Domain, Initiative, or query context; Section 6 defines it as a fitted coefficient. Conflating these produces misleading geometry.

Two statements can both be highly relevant to funding while occupying opposite positions on funding availability: "Foundation X committed \$50 million" and "Foundation X cancelled the program." Their embedding cosine similarity is likely high because both concern the same concept. Their conceptual positions should be far apart. This is why embedding geometry and conceptual geometry remain distinct, and, once both statements exist as Claims with projections, it is the signature the Claim-versus-Claim branch of the contradiction check in Section 3.4 exploits.

Projection is the operation that produces $(\pi_d(x), r_d(x))$ for a Claim. Signals are not projected: they are numerous, most are never cited by a Claim, and positioning them would multiply the projection cost of Section 5.5 by the Signal-to-Claim ratio for no read-side benefit, since the reranker of Section 6 scores Claims. Projection is a model call per object and Dimension: the projector is given one Dimension's definition and prototypes and one proposition, and returns a value in $V_d$ and a relevance score. One Dimension per call is deliberate; agreement is measured per Dimension in Section 5.4, and a prompt covering several Dimensions at once would confound those measurements. The same projector, with the same one-Dimension-per-call convention, projects queries in Section 6. Chatterjee, Gajbhiye, and Schockaert (2023) found that language models can recover some conceptual-space rankings, that performance varies considerably across properties, that larger models are not automatically better, and that BERT-family models fine-tuned on human property judgments matched or exceeded a much larger model. Robin's plan follows from that: use a strong model to bootstrap projections, treat projection as an evaluable capability with its own agreement metrics (Section 5.4), and move projection to a small model fine-tuned on the bootstrap projections once its agreement with them is acceptable. That the small model is trained on model output rather than human judgments is a departure from Chatterjee et al.'s setting, which is why Section 10.6 measures the agreement rather than assuming it.

5.4 Discovery and validation

Dimensions are hypotheses about useful axes of organizational knowledge, not permanent declarations. A candidate Dimension is first validated, then activated if it proves useful, and eventually parked or retired. The active set of a Domain $D$ is written $A_D$.

Candidates come from two sources. The first is a model-implemented proposal step, run per Domain once per evaluation cycle: the model is given the Domain description, the definitions of its active Dimensions, and a sample of Claim pairs that embedding similarity places close together but the reranker of Section 6 has ranked far apart for the same queries, which is the residual the current geometry does not explain, and it returns zero or more candidate specifications per Section 5.2. The second, compared against the first in evaluation, is an Alshaikh-style disentanglement of the Domain's Claim embeddings, whose directions a model then names and defines as specifications.

Validation runs against a sample $S$ of $n$ Claims from the Domain ($n = 100$ where the Domain has that many; minimum $30$). Rank agreement below is written $r_s$ (Spearman's coefficient) to keep it apart from the Dimension's native comparison $\rho_d$. The criteria are operational tests, with initial thresholds that are settings to be tuned, not findings:

A candidate passing these becomes validated and is projected only for the Claims that the Domain's validation queries retrieve, which is the pool the Useful screen scores; projection across the whole Domain happens on activation, so that the cost formula of Section 5.5 counts every Domain-wide projection. The candidate becomes active, and enters $A_D$, when the Useful screen passes. The Useful screen is out-of-sample within the validation split of the Domain's query set: the reranker of Section 6 is refit with five-fold cross-validation, fitting the coefficients on four folds and scoring the fifth, and the candidate passes when its coefficient $\beta_{D,d}$ is non-zero in a majority of folds and the out-of-fold nDCG@10 with the candidate included is not lower than without it in a majority of folds. This is a screen, not a test: at the fitting minimum of Section 6 the folds are small, and the screen's job is to keep obviously useless Dimensions out of the active set cheaply, while the significance test of whether active Dimensions help at all is Section 10.1. The screen never sees the held-out test split; Dimensions selected on the queries they are later scored on would inflate every number in Section 10.1. A Domain with fewer validation queries than the fitting minimum cannot run the screen, and its validated Dimensions stay validated but inactive until it can. A Dimension pinned by a user is active regardless. A Dimension that fails the screen in two consecutive evaluation cycles is parked: kept, not projected, not used. Retirement is a human action.

5.5 Projection cost and invalidation

Projection is the dominant per-Claim write cost of the design. For a Domain $D$ with Claim set $C_D$ and active Dimension set $A_D$, the projection cost is

$$\text{cost}(D) = \sum_{d \in A_D} |\{\, c \in C_D : \hat{r}_d(c) \geq \tau_g \,\}| \cdot c_\pi$$

where $c_\pi$ is the cost of one projection call and $\hat{r}_d(c)$ is a cheap pre-estimate of relevance (cosine similarity between the Claim embedding and the Dimension definition embedding) used as a gate with its own threshold $\tau_g$. The gate threshold is distinct from the relevance threshold $\tau_r$: $\tau_g$ is applied to an embedding similarity before any model is called, and is set permissively (initially at the 30th percentile of similarities in the Domain) so that it removes only Claims that plainly do not concern the Dimension; $\tau_r$ is applied to the projector's own relevance output afterward. Without the gate the cost is $|C_D| \cdot |A_D| \cdot c_\pi$. Three controls bound it. The gate removes obviously irrelevant Claims before any model is called. The active set is capped at $|A_D| \leq K$ per Domain ($K = 8$ initially); when a Dimension passes the Useful screen while the Domain is at the cap, the active Dimension with the smallest mean out-of-fold $\beta_{D,d}$ is parked to make room, with ties broken by parking the one activated most recently, so cost grows linearly in Claims rather than in Claims times an unbounded Dimension count. And $c_\pi$ is driven down by moving projection from a frontier model to a small fine-tuned projector once its agreement with the frontier bootstrap meets the Measurable thresholds; Chatterjee et al. (2023) is the evidence that this is plausible, and Section 10.6 is the test of whether it holds for Robin's Dimensions. Projections are computed on the slow path in batches, when Claims are written (before their contradiction check, per Section 3.4) or when a Dimension is activated, never on the fast path.

Projection is not the only write cost. The contradiction check of Section 3.4 runs on every ingested Signal at up to $k$ classifier calls each, and Signals outnumber Claims. Per Claim-equivalent, the two costs are $K \cdot c_\pi$ for projection and $R_{SC} \cdot k \cdot c_{\text{nli}}$ for ingest checks, where $R_{SC}$ is the Signal-to-Claim ratio and $c_{\text{nli}}$ the cost of one classifier call. Which dominates total write spend depends on $R_{SC}$ and on $c_{\text{nli}} / c_\pi$, neither of which this paper assumes; both are measured in Section 10.5, and the ledger there carries the two as separate lines. The similarity floor $\tau_s$ of Section 3.4 is the control on the ingest side.

Every projection is stored as a record (claim_id, dimension_id, dimension_version, projector_id, value, relevance, projected_at). A Dimension's version $v_d$ increments whenever anything that enters the projection prompt changes: the definition text, the value space, or the prototypes. Changes to the metric or normalizer do not bump the version, because they operate on stored values at comparison time. A projection whose dimension_version is behind the Dimension's current version is stale. Stale projections are excluded from reranking (the Dimension's term simply drops out of the score for that Claim), re-projected lazily when the Claim is next retrieved, and backfilled by a background job in order of Claim access frequency. A version bump therefore costs up to $|C_D| \cdot c_\pi$ spread over time, which is why the Stable criterion exists: a Dimension that needs frequent redefinition is not worth holding.

6. Dimensions, Domains, and Initiatives

Domains provide broad semantic routing. Dimensions provide interpretable structure inside Domains. Embedding every Dimension in order to rediscover routing at query time would duplicate what the Domain classifier already does. The architecture instead routes first and positions second: a query or Signal is routed to Domains by the embedding classifier, and Claims within a Domain are positioned on that Domain's Dimensions by projection.

The reranking score is where salience becomes concrete. For a candidate Claim $c$ retrieved for query $q$, with hybrid base score $b(c, q)$ from the fusion-and-cross-encoder stage, define the per-Dimension feature

$$\phi_d(c, q) = r_d(c) \cdot \big(1 - \delta_d(\pi_d(c), \pi_d(q))\big)$$

where $\pi_d(q)$ is the query's target position on $d$, obtained by projecting the query with the same projector and the same one-Dimension-per-call convention as Claims, so that query projection costs up to $|A_D|$ small calls per Domain in scope, issued in parallel, with latency of one call. The query expresses no position on $d$ when the projector's relevance output for it is below the relevance threshold, $r_d(q) < \tau_r$; in that case the factor $(1 - \delta_d)$ is replaced by $1$ and $\phi_d$ reduces to the Claim's relevance. The Dimension-aware score is

$$\text{score}(c, q) = b(c, q) + \sum_{d \in A(c)} w_q(d)\, \phi_d(c, q) - \mu \cdot [\text{standing}(c) \in \{\text{contested},\ \text{proposed}\}] - \nu \cdot u_I(c)$$

where $A(c)$ is the subset of the active sets $A_D$ of $c$'s home Domains for which $c$ has a non-stale projection, and $u_I(c)$ is the number of $c$'s home Domains that the active Initiative does not attach, zero outside Initiatives and zero under the subset visibility rule of Section 3.2, which never surfaces such a Claim; the term exists for the intersection rule and is fit only when that rule is under test.

The salience is a fitted quantity indexed by Domain as well as Dimension. For each Domain $D$ and each $d \in A_D$, $\beta_{D,d}$ is a coefficient fit on the validation split by pairwise learning-to-rank over the features $\phi_d$ with graded relevance labels, constrained non-negative (being close on a Dimension should never count against a Claim) and $L_1$-penalized so that Dimensions that do not help receive exactly zero. Outside any Initiative, $w_q(d)$ is $\beta_{D,d}$ for the Domain $D$ in the query's scope that is also a home Domain of $c$ and has $d$ active; when more than one Domain qualifies, which happens for Claims homed in several Domains and for Initiative-born Dimensions homed in each Domain the Initiative attaches, the maximum over the qualifying Domains is used, so that a Dimension counts at the strength of the Domain that has learned most about it. The penalty $\mu$ on unsettled standing and the penalty $\nu$ on unattached home Domains are fit in the same procedure, and $\mu$ can also be fit alone, with no Dimension features, which Section 10.1 uses to separate its effect from the geometry's. Coefficients are fit per Domain, so a Domain needs enough validation queries scoped to it for the fit to mean anything: the minimum is 30 validation queries whose Domain scope includes $D$, and a Domain below the minimum has no fitted coefficients, keeps its Dimensions inactive, is excluded from the Dimension-aware arms of Section 10.1 for that workspace, and is reported as unfit. Below that count an $L_1$ fit would zero Dimensions for want of data, and the experiment could not tell "this Dimension does not help" from "too few queries to fit it". Because $\beta_{D,d}$ is fit rather than assigned, it is what the Useful screen in Section 5.4 reads, and there is no separate global scale to tune. Domain salience is simply $\beta_{D,d}$; it is what the Domain has learned about how much the Dimension matters to its queries.

An Initiative composes several Domains and changes which Dimensions matter. Initiative context does not change the underlying knowledge; it changes attention. Inside an Initiative $I$, $w_q(d)$ is multiplied by $(1 + a_I(d))$, where $a_I(d) \in [0, 1]$ is Initiative attention, so an Initiative can at most double a Dimension's fitted weight and can never revive one the Domain fit to zero. Attention starts at $a_I(d) = 0$ and follows a stated rule: each slow-path run under $I$ that derives or revises a Claim with $r_d \geq \tau_r$ raises $a_I(d) \leftarrow \min(1,\ a_I(d) + \eta)$; each slow-path run under $I$ in which no derived Claim is relevant to $d$ decays $a_I(d) \leftarrow (1 - \gamma)\, a_I(d)$; a user pin sets $a_I(d) = 1$ and exempts it from decay. Initial settings are $\eta = 0.2$ and $\gamma = 0.1$. Funding availability might have moderate fitted weight in a Climate Domain and, after a few slow-path runs on an Initiative trying to secure implementation financing, close to double that weight there. Section 10.4 compares this rule against $a_I(d) = 0$ everywhere.

The reranker is therefore one additive term over precomputed values, with per-Domain, per-Dimension coefficients fit offline and, at query time, only the small projection calls needed to position the query. Nothing else in it is learned online.

Initiatives may also give rise to Dimensions that exist in no single source Domain. "County implementation access" might emerge from the interaction of country governance, partner relationships, funding constraints, and implementation capability. Such a Dimension is proposed by the slow path during Initiative work, validated by Section 5.4 against the Claims in scope for the Initiative, and, if it passes, homed in every Domain the Initiative attaches whose Claims it covers, where it is fit and screened like any other Dimension of that Domain. Initiative intelligence arises partly from these cross-Domain intersections.

7. Fast Search and Slow Reasoning

The architecture implies two computational paths.

The fast path is search. It optimizes for latency and retrieval quality. Its inputs are precomputed state: Domain assignments, Signal and Claim embeddings, Claim Dimension positions, fitted Dimension coefficients and Initiative attention, BM25 indexes, provenance edges, and Claim standing. Its model calls in the ordinary case are the query embedding, the cross-encoder reranker, and the query projection of Section 6, all small; the one exception is the escalation described next. A typical fast path scopes the query to Domains, retrieves candidates by BM25 and dense retrieval, reranks them with the cross-encoder and then with the Dimension-aware term, and returns cited results.

This preserves Robin's existing investment in hybrid retrieval and adds one stage on top of it. Hypothetical Document Embeddings (HyDE; Gao, Ma, Lin, and Callan, 2023), which generate a hypothetical answer document and retrieve by its embedding, remain available as an escalation rather than a default, and are the one generation call the fast path can make. Rather than generating a hypothetical document for every query, Robin first exploits Domain structure, Claims, and projections, and invokes HyDE when the top retrieval scores fall below a confidence threshold or the query requires unusually abstract expansion. Section 10.5 measures whether the escalation rate falls as structure accumulates.

The slow path is reasoning and artifact generation. It optimizes for completeness and coherence and may inspect Initiative context, retrieve across several attached Domains, examine relevant Dimension spaces, identify tensions and missing context, derive or revise Claims, search for evidence for their preconditions, project the new Claims, run the contradiction check and propagation of Section 3.4 on them, retrieve supporting Signals, generate an audience-specific artifact, and validate citations and consistency. Projection precedes the contradiction check so that the check's Claim branch has positions to compare. Unlike search, the slow path improves Robin's knowledge model. Its accepted outputs, once projected, become inputs to future searches. Slow reasoning compounds into fast retrieval; whether it compounds fast enough to outrun staleness, and whether the writes are repaid by cheaper reads, are empirical questions, and Section 10.5 states both tests.

8. Router-Controlled Execution

Users should not need to know which computational system Robin is invoking. A Router sits above the execution paths and maps a request to one of retrieve, reason, or author. It is a model-implemented classifier whose inputs are the request text, the identifiers of the active workspace, Initiative, and artifact, the attached Domains, and the last few conversational turns, and whose output is one of the three labels; it is fine-tuned on the labeled request set of Section 10.7. Simple questions route to fast retrieval; analytical questions can invoke Claim reasoning; authoring requests invoke the slow artifact path.

The Router is distinct from the Domain classifier and the Dimension system, and the three answer different questions. The Router decides what kind of computation should occur. The Domain classifier decides which persistent knowledge context an object belongs to. The Dimension system decides along which conceptual properties knowledge should be compared. Keeping these separate prevents one generalized LLM invocation from becoming an opaque bottleneck, and it lets each be evaluated on its own: Section 10.7 tests the Router and the Domain classifier, and Sections 10.1 and 10.6 test the Dimension system.

Conceptual spaces. Gärdenfors (2004) supplies the representational level Robin's Dimensions occupy: interpretable quality dimensions between symbolic and connectionist representation, with similarity as distance. Alshaikh et al. (2020) show how interpretable, subset-specific features can be learned from data-driven embeddings by hierarchical partitioning, which is both a justification for Domain-specific Dimensions and a candidate discovery method. Chatterjee et al. (2023) test whether language models recover conceptual-space rankings and find mixed, property-dependent results, which is why this paper treats projection as measurable rather than assumed. The terminological difference between Gärdenfors' quality domains and Robin's Domains is set out in Section 4.

Retrieval granularity and precomputed structure. Chen et al. (2024) compare passage, sentence, and proposition retrieval units and find that indexing a corpus by atomic, self-contained propositions outperforms passage-level units for retrieval and for downstream question answering at a fixed budget. This supports Robin's premise that Signals should be finer than documents, and it cuts the other way too: if proposition-level units already capture most of the gain, a Claim layer above them may add little. That is why the Signal-only baseline in Section 10.2 is the proposition-level retriever the Claims layer must beat, not a passage retriever. RAPTOR (Sarthi et al., 2024) recursively embeds, clusters, and summarizes text chunks into a tree at index time and retrieves from the tree at query time, and shows gains over retrieving contiguous chunks. It is a second instance of the write-expensive, read-cheap pattern Robin relies on. It differs in that the tree is built once over a corpus rather than maintained incrementally as evidence arrives. That difference is also why RAPTOR is not an arm in Section 10.5: its input is the Entry corpus, which is frozen during the replay, so its quality across the replay would be flat by construction and the comparison would measure nothing about maintenance.

Graph-based retrieval-augmented generation and temporal graphs. GraphRAG (Edge et al., 2024) is the nearest existing system to Robin's write-side design among batch indexers. Its indexer uses an LLM to extract entities and relationships from source text and, in the same pass, to extract claims about those entities (factual statements such as dates, events, and interactions); it then pregenerates summaries for communities of related entities, and at query time community summaries answer global questions that plain retrieval cannot. The extracted entity claims are the nearer analogue to Robin's Claims, and the difference is what happens after extraction. GraphRAG's claims are produced once from a text unit and attached to the graph; they carry no justification set beyond their source, no standing, and no revision when source text changes, and the indexing is a batch process. GraphRAG's pipeline is a baseline for the Claims layer in Section 10.2.

Zep (Rasmussen, Paliychuk, Beauvais, Ryan, and Chalef, 2025) is the nearest deployed system on the property GraphRAG lacks. Its Graphiti engine is a temporal knowledge graph for agent memory that ingests episodes incrementally and non-lossily, extracts entities and relational facts as edges, and stamps each edge with the interval over which the fact held and the interval over which the system believed it; when it identifies temporally overlapping contradictions, it invalidates the affected edges by setting their invalid-from time to the valid-from time of the invalidating edge. That is incremental maintenance with supersession-by-contradiction over extracted facts, and it is closer to Section 3.3's superseded state and Section 3.4's contradiction check than any other cited system. Robin differs in three ways. Its Claims carry justification sets that may include other Claims, so the effect of new evidence is computed by propagation rather than by pairwise edge invalidation. A detected contradiction produces a contested state that surfaces the conflict to a person, rather than resolving it in favor of the newer fact; supersession in Robin is an explicit edge written by the slow path or a user, not an automatic consequence of temporal overlap. And Dimensions give derived statements a geometry that a fact graph does not have. Section 10.5 uses a Graphiti-style arm as the comparison for staleness under contradiction, and for per-Signal ingest cost, which is the question Zep's design most directly answers.

Contradiction detection. The classifier step of Section 3.4 is the task de Marneffe, Rafferty, and Manning (2008) studied as finding contradictions in text. They propose a definition and typology of contradictions, argue that a contradiction system must make finer distinctions than an entailment system (event coreference in particular), and report that detecting contradictions appears to be a harder task than detecting entailment: their system, tuned for precision because contradictions are rare, reached about 23% precision and 19% recall on the RTE-3 test set against an average of about 11% and 12% for the twelve RTE-3 pilot submissions, with good performance on contradictions arising from negation and antonymy and poor performance on those requiring lexical or world knowledge. Modern NLI models are stronger than that system, but the shape of the result, precision scarce and performance uneven across contradiction types, is why Section 10.3 sets separate precision and recall bars for the check, reports candidate recall separately from classifier performance, and names a stronger model or a human queue as the fallback rather than assuming the small classifier suffices.

Truth maintenance. Doyle's truth maintenance system (1979) records justifications for beliefs and revises belief status when assumptions are contradicted; de Kleer's assumption-based TMS (1986) instead labels nodes with the assumption sets under which they hold, so inconsistent contexts can be explored in parallel without retraction. Robin's standing model (Section 3.4) is a monotone, well-founded subset of Doyle's justification network, and de Kleer's labels are the named extension if Initiatives need parallel inconsistent contexts.

Belief revision. The AGM postulates (Alchourrón, Gärdenfors, and Makinson, 1985) characterize rational contraction and revision of logically closed theories through partial meet operations over maximal non-implying subsets. Robin's Claim set is not closed under consequence and Robin does not implement an AGM operator. AGM is relevant as a standard: the retraction behavior of Section 3.4 should remove exactly the Claims whose every justification depends on withdrawn evidence and nothing else, which is the dependency-network analogue of minimal change, and Section 10.3 checks that property directly.

Argumentation. Dung (1995) defines abstract argumentation frameworks as arguments with an attack relation and gives extension semantics that determine which arguments are collectively acceptable. Robin's conflicts_with edge is an attack relation. The contested state is what results from declining to compute an extension: rather than choosing a side, Robin surfaces the conflict to a person. If chains of conflict become common, Dung's grounded semantics is the candidate rule for computing standing automatically; that is future work and not part of this design.

Hybrid retrieval and citation evaluation. The fast path's base is standard: lexical and dense retrieval fused, then reranked by a cross-encoder. HyDE (Gao, Ma, Lin, and Callan, 2023) is retained as an escalation. This stack is also the baseline every component in Section 10 must beat. For artifact evaluation, ALCE (Gao, Yen, Yu, and Chen, 2023) defines citation recall (whether each statement is fully supported by the passages it cites) and citation precision (whether each cited passage actually supports its statement), computes both with a natural-language-inference model, and reports strong correlation with human judgment; Section 10.2 adopts these metrics by name rather than defining its own.

Factor graphs (intuition only). Kschischang, Frey, and Loeliger's factor graphs (2001) decompose a global function into a product of local factors and compute marginals by message passing, and they are a tempting runtime model for Claim inference. They were considered and not adopted. Factor graphs require a probabilistic or at least algebraic semantics for the quantities being combined, and Robin's Claims carry a discrete standing, not a probability. Supplying one is possible in principle: DeepDive (Zhang et al., 2017) built knowledge bases by declaring extraction as one large factor graph and learning the factor weights from hand-labeled data or distant supervision. Robin declines that route not because it cannot work but because it has neither labeled truth values for Claims nor a distant-supervision source for them at the scale of a pilot workspace, so the factor functions would have to be invented rather than learned. What the design needed from factor graphs was locality, which the dependency network of Section 3.4 provides directly. Factor graphs remain the right reference if Robin later attaches calibrated confidences to Claims and acquires the data to learn them.

Sheaves (intuition only). Phillips (2018) describes generalization as the patching of local knowledge into globally coherent information, using the sheaf-theoretic picture in which local sections agree on overlaps or fail to glue. That picture motivated the rule that Initiatives compose Domains rather than merging them, and that disagreement between Domains is recorded rather than erased. Its operational content in this paper is exactly two things: the visibility rule of Section 3.2 and the conflicts_with edge of Section 3.4. No sheaf machinery is proposed, and "overlap between two Domains" has no formal meaning here beyond Claims whose home set includes both.

10. Evaluation Plan

None of the experiments below has been run. Each subsection names the bet being tested, the baseline, the metric, how the test set is constructed, the threshold that counts as success, and the result that would cause the component to be dropped or redesigned. Thresholds are initial settings chosen to be large enough to matter operationally and small enough to be detectable at the scale of a pilot; they are to be fixed before any experiment runs and reported alongside whatever is observed.

Shared protocol. Experiments run on at least three pilot workspaces with distinct organizational subject matter. Query sets combine anonymized queries from usage logs with queries written by domain annotators; each workspace contributes at least 150 general queries and, separately, at least 200 Initiative-scoped queries, the latter sized by the power requirement of Section 10.4. Relevance judgments are graded (0 to 3) by two annotators per query over pooled top-20 results from every system under comparison; inter-annotator agreement is reported as Cohen's $\kappa$ and queries with $\kappa < 0.4$ are re-adjudicated. Each query set is split 40/60 into a validation split (for fitting $\beta_{D,d}$, $\mu$, and $\nu$, running the Useful screen, and setting thresholds) and a held-out test split that nothing is tuned on. Per-Domain fits require at least 30 validation queries scoped to the Domain (Section 6); Domains below that count are reported as unfit and excluded from the Dimension-aware arms for that workspace, and workspaces are chosen so that at least their three largest Domains meet the minimum. Statistical significance uses a paired bootstrap over queries, one-sided, unless a test names another procedure. Synthetic queries generated from held-out Claims may supplement but never replace judged queries, because they leak the Claim layer's own vocabulary into the test.

Success rules, power, and multiplicity. Every comparative test below states a design effect, which is the smallest difference worth acting on, and sizes its sample so that a true difference of that size is detected with 80% power. The success rule is that the observed difference is positive and significant; the design effect is what the test is powered for, not a second bar the observed value must clear, because requiring both would cut the effective power to about half. Each bet has one primary clause, named in its subsection, tested at one-sided $\alpha = 0.05$; every other significance clause in that subsection is secondary, and secondary clauses within a subsection are corrected as one family by Holm's step-down procedure. A primary result that is positive but not significant is inconclusive and triggers one pre-registered extension of the sample by the same size, after which the pooled sample is tested once more. Because that is a two-look procedure, each look is tested at a nominal one-sided $0.03$, which holds the overall type I error near $0.05$; the first look therefore has slightly less than the nominal 80% power, which the extension exists to recover. If the extended test is still not significant, the component is treated as having failed. A result at or below zero is a failure without extension.

Cost accounting. Every model call in every arm is logged with its model, input tokens, and output tokens, and costs are reported two ways: as tokens per model tier, and as a single figure at the provider's list prices on the day of the experiment. The cost of serving a request, for any arm, is every model call the request triggers, including work the request causes the system to write. Cost comparisons are made only between arms whose quality is at parity or better on the relevant metric; a cheaper arm that is also worse is not a cost win.

10.1 Dimension-aware reranking

Bet: the Dimension term in Section 6 improves ranking over a strong retriever that has no access to conceptual positions, and the improvement is attributable to the geometry rather than to the standing penalty that ships with it.

Arms, all sharing the same retrieval stage over Signals and Claims (BM25 and dense retrieval fused by reciprocal rank fusion, reranked by a cross-encoder): (i) the hybrid baseline as stated; (ii) hybrid plus the standing penalty $\mu$ fit alone on the validation split, with no Dimension features; (iii) the full reranker, hybrid plus $\mu$ plus the Dimension term with $\beta_{D,d}$ and $\mu$ fit jointly; (iv) a permutation control, identical to (iii) except that each Claim's projection records are shuffled across Claims within the Domain before the coefficients are refit; and (v) a Signals-only arm, the hybrid baseline with Claims removed from the index, which is the retrieval half of the alternative named in Section 1 and also establishes whether Claims are being retrieved at all, a fact Section 10.5 depends on.

Primary metric: nDCG@10 on the held-out split; secondary: Recall@50 and MRR. The Dimension gain is (iii) minus (ii); the standing gain is (ii) minus (i); the Claims-in-index gain is (i) minus (v). Primary clause: the Dimension gain, with a design effect of $0.03$ absolute nDCG@10, for which the pooled held-out general queries (about 270 across three workspaces) give at least 80% power at a per-query difference standard deviation of $0.15$. Success for the Dimension term: the Dimension gain is positive and significant on the pooled held-out split, and no workspace shows a significant degradation (secondary). The permutation control is the attribution test. Shuffling moves both value and relevance with the projection record, so no geometric information survives it; $\mu$ is refit and does survive, which is why the control is compared against arm (ii) rather than against (i). Any gain of (iv) over (ii) is therefore neither geometry nor standing and is attributed to fitting noise in the coefficients; success requires that (iv) minus (ii) be at most half of (iii) minus (ii). Cost: the query projection calls must add no more than $10\%$ to median fast-path cost per query for queries scoped to at most three Domains, which bounds the calls at $3K$; the bound is reported per scope size.

Drop conditions are separate for the two terms. The Dimension term is dropped if the Dimension gain fails under the shared success rule, or the permutation control retains more than half of it, or the cost bound is exceeded and the gain vanishes when query projection is disabled; dropping it also parks all Dimensions that were active only by the Useful screen. The standing penalty is kept if the standing gain is positive and significant (secondary) and dropped otherwise, independently of what happens to the Dimension term. If arm (v) matches arm (i) within the noise of the test, Claims are not contributing to retrieval, and the quality half of the thesis then rests entirely on Section 10.2.

10.2 The Claims layer

Bet: artifacts rendered from persisted Claims are better than artifacts produced without a persisted knowledge model, at comparable citation fidelity, and the improvement comes from the persisted model rather than from reasoning before rendering.

Baselines: (a) Signal-only generation, where the same retriever supplies proposition-level Signals directly to the same generator in one pass, which is the strongest form of the granularity argument from Chen et al. (2024); (b) a GraphRAG-style pipeline, where an entity graph with extracted entity claims and community summaries is built over the workspace's Entries and supplied to the generator; and (c) per-request reasoning, the slow path of Section 7 run with persistence disabled: the same retriever, the same reasoning model, and the same renderer derive interpretations for the request, use them, and discard them, writing no Claims, no projections, and no standing. Baseline (c) is the artifact half of the alternative named in Section 1, and it is the one that separates the persisted model from reasoning-before-rendering, which (c) gets without persisting anything. Metrics: blinded pairwise preference on coverage, correctness, and coherence, judged by two raters per pair, with a third rater adjudicating disagreements and pairs the third rater calls a tie excluded from the count and reported; ALCE citation recall and citation precision (Gao, Yen, Yu, and Chen, 2023), computed with an NLI model as in ALCE and checked against human judgment on a $20\%$ subsample; a precondition check, the fraction of cited Claims with non-empty context whose preconditions appear in the artifact text; and cost per artifact request for every arm, counted as the shared protocol counts it, so that for Robin it includes Claim derivation, precondition search, projection, the contradiction check, and rendering.

Test set: 55 artifact requests per pilot workspace, spanning at least 10 Initiatives per workspace, with audience specified (engineering or stakeholder), so that at least 150 decided pairs per baseline comparison remain after tie exclusion. The size follows from the design effect: a true $60\%$ preference rate against a $50\%$ null is detected at one-sided $\alpha = 0.05$ with $80\%$ power by an exact binomial test on about 150 pairs, which at that size means observing roughly 86 or more wins.

Primary clause: preference against baseline (c), by exact binomial test, with $60\%$ as the design effect. Secondary: preference against (a) and (b); ALCE citation precision and recall no lower than the best baseline; precondition check at $100\%$ (it is a renderer requirement, and any miss is a defect). Cost per artifact is reported for all arms and is not a success condition here; the difference between Robin's cost and (c)'s is the persistence overhead per artifact, and Section 10.5's ledger is where it is judged, because it is repaid, if at all, by reads. Decision rule for the primary clause: if Robin is preferred to (c) significantly, the persisted model contributes to artifact quality; if the result is at or below $50\%$, or fails after extension, the Claim layer contributes nothing to artifacts that per-request reasoning does not, and the thesis is then decided by the ledger alone, with artifact quality parity taken as given. A result where Robin beats (a) but not (c) is exactly that case and is reported as such, not as a win. A result where Robin wins on preference but loses on citation precision is a redesign signal for the renderer. A result where Robin ties (a) is the Chen et al. outcome: granularity did the work, and the Claim layer should be dropped in favor of investment in Signal extraction.

10.3 Standing and dependency tracking

Bet: the contradiction check and propagation of Section 3.4 detect conflicts and retractions that matter, cheaply, without regenerating Claims, and each branch of the check can be credited separately.

Test set, two arms, both injected through the ordinary write path so that the runtime, not the experimenter, performs classification, projection, and the check, and both scored on conflicts_with edges by the branch tag that Section 3.4 records on every edge. In the Signal arm, for each pilot workspace, 100 accepted Claims are selected as targets; for each, an annotator writes one Signal that contradicts it and one distractor Signal on the same topic that does not, and the 200 Signals are injected in random order over a simulated week. This exercises the Signal branch of the candidate step (similarity alone, with the floor $\tau_s$), the lifting of contradicting Signals into Claims, and the classifier. In the Claim arm, targets are 100 accepted Claims each having at least one active Dimension with relevance $r_d \geq \tau_r$, so that the position filter can apply; for each, the annotator writes a contradicting Signal and a Claim justified by that Signal alone that opposes the target on one such Dimension, so that the Claim arrives supported and positioned, plus a distractor Signal and a distractor Claim justified by it, and each Signal-and-Claim pair is written as a unit; the runtime projects each Claim within its batch and then runs the check. The justifying Signal will in general also contradict the target and be caught by the Signal branch in the same batch; that is production behavior and is not suppressed. Instead, the Claim arm is scored only on edges tagged as written by the Claim branch, so that a Claim branch that finds nothing scores zero regardless of what the Signal branch did.

Metrics, Signal arm: precision and recall of Signal-branch conflicts_with edges against the annotator's labels, where recall is the fraction of targets that acquire a Signal-branch edge to the lifted Claim of their contradicting Signal and precision is the fraction of Signal-branch edges written during the arm that join a lifted Claim to a Claim the annotator marked as contradicted by it; candidate recall, the fraction of injected contradictions whose target was among the $k$ candidates after the floor $\tau_s$; the number of injected contradictions removed by the floor; and model calls per injected Signal. Metrics, Claim arm: the same precision and recall computed on Claim-branch edges between injected Claims and targets; candidate recall for the Claim branch; the fraction of Claim-arm checks in which the position filter applied rather than relaxed to similarity; candidate precision with the position filter versus with similarity alone at the same $k$, computed only over checks in which the filter applied; and model calls per injected Claim, including projection. Both arms: wall-clock from write to the contested transition. Retraction, both arms: a minimal-change check in which, after withdrawing the Entries behind 20 accepted Claims, the set of Claims that become retracted must equal the set whose every justification depended on those Entries, with no extra retractions, and restoring the Entries must return exactly those Claims to proposed, which Section 3.3's rule that re-entered Claims are never auto-accepted guarantees in every workspace configuration.

Primary clause: Signal-branch recall. Success: recall at least $0.8$ and precision at least $0.7$ on each branch's own edges; candidate recall at least $0.9$ on each branch, with the floor removing none of the injected contradictions; the position filter raises candidate precision over similarity alone on the checks where it applied without lowering candidate recall below $0.9$; model calls per injected object at most $k + 1$ for the check, which Section 3.4's exemption of lifted Claims from the write path guarantees, plus at most $K$ projection calls in the Claim arm; median wall-clock to the contested transition under the batch interval $\Delta$ plus one minute, with $\Delta = 5$ minutes as in Section 3.4; minimal-change check exact in both directions. Redesign conditions: candidate recall below $0.7$ on the Signal branch means $k$ nearest by similarity is too narrow, and $k$ must rise, at linear cost, or the floor is removing contradictions and $\tau_s$ must fall; on the Claim branch, if the position filter lowers candidate recall below $0.9$, the filter is removed and the Claim branch falls back to similarity alone, which also removes the Section 5.3 signature from the check; precision below $0.5$ on either branch means contradicts is being over-assigned and the classifier step must move to a stronger model or a human queue, the fallback Section 9's contradiction-detection paragraph anticipates. Drop condition: if recall cannot reach $0.6$ on the Signal branch at $k = 50$ with the floor removed, automatic standing changes are disabled and standing becomes a purely human-maintained field.

10.4 Initiative composition

Bet: Initiative attention $a_I$ and the visibility rule improve Initiative-scoped retrieval over Domain-level coefficients alone, and Initiatives produce cross-Domain Claims that people find useful.

Treatment: the attention rule of Section 6 with $\eta = 0.2$ and $\gamma = 0.1$, run for the slow-path history of each Initiative before its queries are scored. Baselines: (a) $a_I(d) = 0$ for every Dimension, so that only fitted Domain coefficients apply; (b) no Initiative scoping, global retrieval over the workspace. Visibility ablation: the subset rule of Section 3.2 against the intersection rule with the fitted penalty $\nu$ of Section 6, each run with attention on. Metrics: nDCG@10 on the Initiative-scoped held-out queries; and, for each slow-path run under an Initiative, the number of newly derived Claims whose home set spans at least two Domains and that a rater scores as both non-obvious and useful on a 3-point scale.

Sample size: the attention comparison is paired, and per-query nDCG@10 differences between two rerankers sharing a retrieval stage have a standard deviation on the order of $0.15$; detecting a design effect of $0.02$ at one-sided $\alpha = 0.05$ with $80\%$ power then needs about 350 held-out Initiative-scoped queries pooled across workspaces. With a 60% held-out share over three workspaces, that is the source of the 200 Initiative-scoped queries per workspace required in the shared protocol. If the pooled held-out count falls short, the design effect is raised to what the available count can detect at the same power, and the raised figure is reported before scoring.

Primary clause: attention against $a_I = 0$. Success: attention beats $a_I = 0$ by a positive and significant margin, powered for $0.02$; Domain scoping beats global retrieval by a positive and significant margin, powered for $0.05$ (secondary); at least one rated-useful cross-Domain Claim per three slow-path runs. Visibility decision rule (secondary): the intersection rule is adopted if its held-out nDCG@10 on Initiative-scoped queries is significantly higher than the subset rule's; otherwise the subset rule stays, as the conservative default that never surfaces a Claim whose evidence the Initiative has not attached. Drop conditions: no significant lift from attention removes the rule, leaving Initiatives as Domain groupings with $a_I = 0$; no lift from Domain scoping over global retrieval is a more serious result, since it questions whether Domains earn their place in the fast path at all, and would be read together with the classifier figures of Section 10.7 before anything else.

10.5 Fast/slow compounding, staleness, and the cost ledger

Bet: accumulated slow-path work makes the fast path better and cheaper over time, the total spend on writes, ingest checks, and reads falls below the alternative's spend at realistic read/write ratios, and the structure does not go stale faster than it is maintained.

Two replay series are run on each pilot workspace, both starting from a fresh copy containing only its Signals. Both the $m$ artifact requests and the $N$ read queries are taken from one window of the workspace's request log in their logged order: the requests labeled author in Section 10.7 become the artifact runs, and the requests labeled retrieve become the reads, so that the topical overlap between what is written and what is read is whatever the workspace exhibits rather than a choice of the experimenter, and so that routing does not vary between arms. $N$ is at least 60 per workspace, 180 pooled, which gives 80% power for the design effect below. In the clean series, the only thing that changes between checkpoints is the slow-path artifact runs: the $N$ queries are replayed at $m = 0$ and after $m = 5$, $10$, and $20$ artifact requests, with the Signal corpus, the query set, and the Dimension set frozen. Coefficients $\beta_{D,d}$ and $\mu$ are fit once, on the validation split against the Claims present at the final checkpoint, and applied unchanged at every checkpoint; at $m = 0$ there are no Claims, so the Dimension term is inert there by construction. Claims that first appear in any arm's top 20 at any checkpoint did not exist when judgments were pooled, so a post-replay pooling and judging pass under the shared protocol is run before any checkpoint is scored. This series measures compounding and read-side cost. In the injected series, the same artifact runs are performed, and in addition, at each checkpoint $m$, a contradiction set is constructed against the accepted Claims that exist at that checkpoint and injected before the next replay. This series measures staleness and per-Signal ingest cost, since it is the series in which Signals are ingested. The two are separated because injections add both new evidence and new conflicts, and a single series could not tell compounding from injected noise.

Contradiction set construction. At checkpoint $m$, annotators select up to 100 accepted Claims from those that exist, and for each write one contradicting Signal, following the Section 10.3 Signal-arm procedure. The target count at each checkpoint is reported, and if fewer than 20 accepted Claims exist at a checkpoint, staleness there is reported as not measurable rather than as zero. Because the injected Signals and their targets are known, it is known for every Claim in the workspace whether a contradicting Signal is present at each replay.

Quality and staleness metrics at each $m$ on the clean series: fast-path nDCG@10; HyDE escalation rate; and p50 and p95 query latency. On the injected series: the staleness rate, defined as the fraction of top-10 results that are Claims whose standing is accepted or proposed while an injected Signal contradicting them has been present for longer than the batch interval $\Delta$. A contested Claim in the top 10 with its conflict surfaced is the design working and is not counted. As a sanity check rather than a metric, the number of top-10 results that are retracted or superseded Claims is also reported and must be zero, since Section 3.3 excludes both from retrieval; a non-zero count is a retrieval defect, not a staleness result. Primary clause: the gain in nDCG@10 from $m = 0$ to $m = 20$ on the clean series, positive and significant by paired bootstrap over the $N$ queries, powered for a design effect of $0.03$. Secondary: no checkpoint significantly below the checkpoint before it; the escalation rate falls; p95 latency does not rise. Success on the injected series: staleness below $2\%$ at every measurable checkpoint.

Arms for the injected series: Robin as specified, and a Graphiti-style arm (Rasmussen et al., 2025) in which the same Signals and injected Signals are ingested incrementally into a temporal fact graph that invalidates temporally overlapping contradicted facts; its staleness rate is the fraction of top-10 facts that are contradicted by a present injected Signal and not invalidated. Both arms' per-Signal ingest cost is measured on this series: for Robin, the classifier and lifting calls of Section 3.4 per ingested Signal, written $c_{\text{ing}}$; for the Graphiti-style arm, its extraction and invalidation calls per ingested Signal. This arm is the nearest existing design for the maintenance question, and if it matches Robin's staleness at a per-Signal ingest cost no higher than Robin's, Robin's justification network is not earning its complexity on this axis.

Read arms on the clean series. Robin's fast path is compared with two baseline read arms that hold no Claims: hybrid retrieval over Signals alone, which is the configuration of arm (v) in Section 10.1 and is the natural way to serve a retrieve-labeled request; and hybrid retrieval followed by the reasoning model over the retrieved Signals, which is the most that the alternative would spend on a read. Read quality is compared on the same $N$ judged queries at the reasoning arm's own evidence depth: for each query, let $|C_q|$ be the number of Signals the reasoning arm's answer cites; every arm's list is truncated to its top $|C_q|$ items and scored against the graded relevance judgments with nDCG and precision at depth $|C_q|$, so that no arm is penalized for the length of its list. A baseline arm reaches parity when Robin is not significantly better than it on that metric. The baseline read cost $r_{\text{base}}$ is the per-query cost of the cheapest baseline arm that reaches parity, and the ledger reports which arm that was. If plain hybrid retrieval reaches parity, Robin's reads add nothing that plain retrieval lacks, $r_{\text{base}}$ is close to $r_{\text{fast}}$, and the ledger will show it. If neither baseline reaches parity, $r_{\text{base}}$ is the reasoning arm's cost and the ledger says that Robin's reads were better than anything the alternative could offer at that price.

Cost ledger. The workload for every arm is the same: $m$ artifact requests, $N$ read queries, and the Signals ingested over the period in which a workspace would produce $m$ artifacts. Ingest volume is not observed in the clean series, so it is taken from logs: $\sigma$, the number of Signals ingested per artifact-generating request, is measured from the same pilot logs that give $\bar{N}$, and the ledger charges Robin $m \, \sigma \, c_{\text{ing}}$ with $c_{\text{ing}}$ measured on the injected series. The alternative has no counterpart to this line: it embeds and indexes Signals, as Robin also does, and performs no further work at ingest, so the ingest line is charged to Robin alone. For Robin, $W(m)$ is the total cost of the $m$ slow-path runs on the clean series, counted as the shared protocol counts it, and $r_{\text{fast}}$ is the mean per-query cost of the fast path at $m = 20$, including query embedding, cross-encoder, query projection, and any HyDE escalations; Robin's total is $W(m) + m \, \sigma \, c_{\text{ing}} + N \cdot r_{\text{fast}}$. For the alternative, each of the $m$ artifact requests is served by baseline (c) of Section 10.2 at its measured cost per artifact $g_{\text{base}}$, so that the ledger's artifact baseline and read baseline are the same system, and each of the $N$ reads at $r_{\text{base}}$ as defined above; its total is $m \cdot g_{\text{base}} + N \cdot r_{\text{base}}$. The break-even read count is

$$N^{*} = \frac{W(m) + m \, \sigma \, c_{\text{ing}} - m \cdot g_{\text{base}}}{r_{\text{base}} - r_{\text{fast}}}$$

which is the number of reads over which Robin's extra write and ingest cost is repaid. The ledger reports the projection line and the ingest line separately, so that the question left open in Section 5.5, which of the two dominates write spend at the pilot's Signal-to-Claim ratio, is answered by measurement.

The observed read/write ratio $\bar{N}$ is measured from pilot workspace logs as read queries per artifact-generating request, not assumed. The discriminating success condition is $N^{*} \leq \bar{N} \cdot m$ at $m = 20$: the structure pays for itself within the reads a workspace actually performs per twenty artifacts. The condition $r_{\text{fast}} < r_{\text{base}}$ is necessary for a break-even to exist; when the parity arm is the reasoning arm it is expected to hold by a wide margin, and when the parity arm is plain retrieval it is expected to fail, which is the ledger doing its job. It is reported as a sanity check and is not by itself a success.

Falsification: no significant quality gain by $m = 20$ on the clean series means slow-path outputs are not being reused, and the compounding claim fails; staleness rising with $m$ on the injected series means the structure decays faster than propagation maintains it, which falsifies the thesis in the weaker sense stated in Section 1; $N^{*}$ above $\bar{N} \cdot m$ at the observed ratios, or no break-even at all, means the cost half of the thesis is false even if the quality half holds. Any of these would return Robin to the alternative.

10.6 Dimension discovery and projection

Bet: the discovery pipeline of Section 5.4 produces Dimensions people recognize as meaningful, and projection can be done by a small model.

Metrics: the promotion rate of candidates through validation; for each promoted Dimension, two raters answer "would you use this axis to compare these Claims?" on a sample of projected Claims, with $\kappa$ reported; the fraction of promoted Dimensions rated meaningful by both raters; for the two candidate generators (model proposal versus Alshaikh-style disentanglement), promotion rate and meaningfulness rate side by side; and projector agreement, $r_s$ or $\kappa$ between a small projector fine-tuned on the frontier bootstrap and the frontier projector itself, on a held-out sample per Dimension of up to 200 Claims and at least the 30 that Section 5.4 requires of any Domain, reported with a confidence interval so that small Domains are not over-read, together with the ratio of the two projectors' per-projection costs. Primary clause: the meaningfulness rate. Success: at least $50\%$ of promoted Dimensions rated meaningful by both raters; small-projector agreement meeting the Measurable thresholds of Section 5.4 on at least three quarters of active Dimensions, at a per-projection cost no more than one tenth of the frontier projector's. Fallback conditions: meaningfulness below $50\%$ replaces automatic discovery with human-authored Dimensions per Domain, keeping validation and projection unchanged; small-projector agreement below threshold keeps projection on the larger model and makes $c_\pi$ the binding constraint on the number of active Dimensions, which would lower $K$ and raise $W(m)$ in the Section 10.5 ledger.

10.7 Router and Domain classifier

Bet: the two routing decisions the fast path depends on are accurate enough that the failures of Sections 10.1 through 10.5 can be attributed to the components under test rather than to misrouting.

Router. Test set: 300 requests per workspace sampled from logs and labeled retrieve, reason, or author by two annotators, with $\kappa$ reported; the labeled requests also supply the read queries and artifact runs of Section 10.5, and a disjoint portion of them is the Router's fine-tuning set. Metrics: routing accuracy; and the two misroute rates separately, since they cost differently: a request routed to a slower path than needed wastes compute, and a request routed to a faster path than needed returns a shallower answer. Primary clause: accuracy. Success: accuracy at least $0.9$, with the shallow-misroute rate at most $0.05$. Redesign condition: below either bar, the Router's inputs are revisited before any downstream result is interpreted.

Domain classifier. Test set: 500 Signals per workspace with Domain labels from two annotators. Metrics: per-Domain precision and recall of Signal-to-Domain assignment, and macro-F1. Success: macro-F1 at least $0.85$ and no Domain with recall below $0.75$, because Domain scope is a hard filter on the fast path and a Signal missed by the classifier is invisible to every query scoped to that Domain. Redesign condition: any Domain below the recall bar has its description and classification logic revised and the Signals reclassified before Sections 10.1 and 10.4 are run on that workspace.

10.8 What falsifies the thesis

The quality half of the thesis fails if Sections 10.1 and 10.2 both fail against the alternative: if the Signals-only hybrid arm matches the full system on retrieval and per-request reasoning without persistence matches it on artifacts, the persisted structure is not improving what users see. The cost half fails if Section 10.5's ledger, with ingest checks charged and the read baseline set to the cheapest arm at parity, finds $N^{*}$ above the observed $\bar{N} \cdot m$, or no break-even at all. The thesis fails in the weaker sense if Section 10.5 shows staleness rising with accumulated structure. Any single component failing its own drop condition removes that component and leaves the thesis to be judged on the rest. The paper's frameworks were adopted on the condition that they earn their place under these tests; a framework that fails remains research, not architecture.

11. Conclusion

Robin's proposed architecture is a layered system for contextual organizational reasoning. Signals preserve evidence. Domains preserve persistent semantic boundaries. Claims interpret evidence and carry a maintained standing. Dimensions make aspects of those interpretations comparable along named axes. Initiatives compose knowledge from several Domains around an objective and shift attention among Dimensions. Explicit graph edges hold the relationships Robin can name: provenance, citation, justification, conflict, supersession, attachment. Conceptual geometry holds the relationships better understood through position and distance. A justification network keeps standing local so that new evidence changes labels in a neighborhood rather than recomputing the whole. The runtime separates fast retrieval, which reads precomputed state, from slow reasoning, which writes it.

The organizing asymmetry is that expensive intelligence writes structure and cheap intelligence reads it. Robin does not need to continuously think about everything it knows. Like a person who assumes the floor will continue to bear their weight, most knowledge stays dormant until new evidence, a conflict, or an active objective makes a particular region matter.

The design commits to specific mechanisms so that it can be wrong in specific ways. Standing has five states, stated transitions, two overrides, and a well-foundedness check. Dimensions have a contract, a validation procedure with thresholds, a cost formula, and a versioning rule. Reranking is one additive term with fitted per-Domain, per-Dimension coefficients, and its evaluation separates the geometry from the standing penalty that travels with it. The contradiction check has two branches, each tagged on the edges it writes so that each can be credited or dropped on its own. Both halves of the thesis are tested against the same alternative, a system that persists nothing and reasons per request only when a request needs it, and the cost claim has a ledger that charges Robin for what it does at ingest as well as at write time, a symmetric workload, and a break-even condition. Each of these has a baseline and a drop condition in Section 10. If that alternative does as well, or does as well for less, the answer is to build it, and this paper will have been useful chiefly for saying so early.

References

Alchourrón, C. E., Gärdenfors, P., & Makinson, D. (1985). On the Logic of Theory Change: Partial Meet Contraction and Revision Functions. The Journal of Symbolic Logic, 50(2), 510–530.

Alshaikh, R., Bouraoui, Z., & Schockaert, S. (2020). Hierarchical Linear Disentanglement of Data-Driven Conceptual Spaces. Proceedings of the Twenty-Ninth International Joint Conference on Artificial Intelligence (IJCAI-20), 3573–3579.

Chatterjee, U., Gajbhiye, A., & Schockaert, S. (2023). Cabbage Sweeter than Cake? Analysing the Potential of Large Language Models for Learning Conceptual Spaces. Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, 11836–11842.

Chen, T., Wang, H., Chen, S., Yu, W., Ma, K., Zhao, X., Zhang, H., & Yu, D. (2024). Dense X Retrieval: What Retrieval Granularity Should We Use? Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, 15159–15177. (First posted as arXiv:2312.06648, 2023.)

de Kleer, J. (1986). An Assumption-based TMS. Artificial Intelligence, 28(2), 127–162.

de Marneffe, M.-C., Rafferty, A. N., & Manning, C. D. (2008). Finding Contradictions in Text. Proceedings of ACL-08: HLT, 1039–1047.

Doyle, J. (1979). A Truth Maintenance System. Artificial Intelligence, 12(3), 231–272.

Dung, P. M. (1995). On the Acceptability of Arguments and its Fundamental Role in Nonmonotonic Reasoning, Logic Programming and n-Person Games. Artificial Intelligence, 77(2), 321–357.

Edge, D., Trinh, H., Cheng, N., Bradley, J., Chao, A., Mody, A., Truitt, S., & Larson, J. (2024). From Local to Global: A Graph RAG Approach to Query-Focused Summarization. arXiv:2404.16130v1 (April 2024; the February 2025 revision, v2, adds two authors).

Gao, L., Ma, X., Lin, J., & Callan, J. (2023). Precise Zero-Shot Dense Retrieval without Relevance Labels. Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), 1762–1777.

Gao, T., Yen, H., Yu, J., & Chen, D. (2023). Enabling Large Language Models to Generate Text with Citations. Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, 6465–6488.

Gärdenfors, P. (2004). Conceptual Spaces as a Framework for Knowledge Representation. Mind and Matter, 2(2), 9–27.

Kschischang, F. R., Frey, B. J., & Loeliger, H.-A. (2001). Factor Graphs and the Sum-Product Algorithm. IEEE Transactions on Information Theory, 47(2), 498–519.

Phillips, S. (2018). Going Beyond the Data as the Patching (Sheaving) of Local Knowledge. Frontiers in Psychology, 9, 1926. https://doi.org/10.3389/fpsyg.2018.01926

Rasmussen, P., Paliychuk, P., Beauvais, T., Ryan, J., & Chalef, D. (2025). Zep: A Temporal Knowledge Graph Architecture for Agent Memory. arXiv:2501.13956.

Sarthi, P., Abdullah, S., Tuli, A., Khanna, S., Goldie, A., & Manning, C. D. (2024). RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval. Proceedings of the Twelfth International Conference on Learning Representations (ICLR 2024).

Zhang, C., Ré, C., Cafarella, M., De Sa, C., Ratner, A., Shin, J., Wang, F., & Wu, S. (2017). DeepDive: Declarative Knowledge Base Construction. Communications of the ACM, 60(5), 93–102.